16 files changed, 444 insertions, 662 deletions

diff --git a/source/Bindings.cpp b/source/Bindings.cpp
index 5c7ee3b1d..2f7ce10ce 100644
--- a/source/Bindings.cpp
+++ b/source/Bindings.cpp
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 03/14/13 10:02:26.
+** Generated automatically by tolua++-1.0.92 on 03/17/13 18:47:08.
 */
 
 #ifndef __cplusplus
@@ -347,9 +347,9 @@ static int tolua_AllToLua_cVine_DirectionToMetaData00(lua_State* tolua_S)
  else
 #endif
  {
-  char a_Direction = ((char)  tolua_tonumber(tolua_S,2,0));
+  char a_BlockFace = ((char)  tolua_tonumber(tolua_S,2,0));
   {
-   unsigned char tolua_ret = (unsigned char)  cVine::DirectionToMetaData(a_Direction);
+   unsigned char tolua_ret = (unsigned char)  cVine::DirectionToMetaData(a_BlockFace);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
@@ -19595,6 +19595,105 @@ static int tolua_AllToLua_cBlockArea_HasBlockSkyLights00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
+/* method: GetChunkX of class  cChunkDesc */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetChunkX00
+static int tolua_AllToLua_cChunkDesc_GetChunkX00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkX'", NULL);
+#endif
+  {
+   int tolua_ret = (int)  self->GetChunkX();
+   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+  }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetChunkX'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetChunkZ of class  cChunkDesc */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetChunkZ00
+static int tolua_AllToLua_cChunkDesc_GetChunkZ00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkZ'", NULL);
+#endif
+  {
+   int tolua_ret = (int)  self->GetChunkZ();
+   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+  }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetChunkZ'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetChunkCoords of class  cChunkDesc */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetChunkCoords00
+static int tolua_AllToLua_cChunkDesc_SetChunkCoords00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
+     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,0);
+  int a_ChunkX = ((int)  tolua_tonumber(tolua_S,2,0));
+  int a_ChunkZ = ((int)  tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetChunkCoords'", NULL);
+#endif
+  {
+   self->SetChunkCoords(a_ChunkX,a_ChunkZ);
+  }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetChunkCoords'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
 /* method: FillBlocks of class  cChunkDesc */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_FillBlocks00
 static int tolua_AllToLua_cChunkDesc_FillBlocks00(lua_State* tolua_S)
@@ -20423,6 +20522,38 @@ static int tolua_AllToLua_cChunkDesc_ReadBlockArea00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
+/* method: GetMaxHeight of class  cChunkDesc */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetMaxHeight00
+static int tolua_AllToLua_cChunkDesc_GetMaxHeight00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxHeight'", NULL);
+#endif
+  {
+   unsigned char tolua_ret = ( unsigned char)  self->GetMaxHeight();
+   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+  }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetMaxHeight'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
 /* method: new of class  cCraftingGrid */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_new00
 static int tolua_AllToLua_cCraftingGrid_new00(lua_State* tolua_S)
@@ -22505,6 +22636,9 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"cChunkDesc","cChunkDesc","",NULL);
   tolua_beginmodule(tolua_S,"cChunkDesc");
+   tolua_function(tolua_S,"GetChunkX",tolua_AllToLua_cChunkDesc_GetChunkX00);
+   tolua_function(tolua_S,"GetChunkZ",tolua_AllToLua_cChunkDesc_GetChunkZ00);
+   tolua_function(tolua_S,"SetChunkCoords",tolua_AllToLua_cChunkDesc_SetChunkCoords00);
    tolua_function(tolua_S,"FillBlocks",tolua_AllToLua_cChunkDesc_FillBlocks00);
    tolua_function(tolua_S,"SetBlockTypeMeta",tolua_AllToLua_cChunkDesc_SetBlockTypeMeta00);
    tolua_function(tolua_S,"GetBlockTypeMeta",tolua_AllToLua_cChunkDesc_GetBlockTypeMeta00);
@@ -22528,6 +22662,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_function(tolua_S,"IsUsingDefaultFinish",tolua_AllToLua_cChunkDesc_IsUsingDefaultFinish00);
    tolua_function(tolua_S,"WriteBlockArea",tolua_AllToLua_cChunkDesc_WriteBlockArea00);
    tolua_function(tolua_S,"ReadBlockArea",tolua_AllToLua_cChunkDesc_ReadBlockArea00);
+   tolua_function(tolua_S,"GetMaxHeight",tolua_AllToLua_cChunkDesc_GetMaxHeight00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"cCraftingGrid","cCraftingGrid","",tolua_collect_cCraftingGrid);
diff --git a/source/Bindings.h b/source/Bindings.h
index 525565986..d3e0643c2 100644
--- a/source/Bindings.h
+++ b/source/Bindings.h
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 03/14/13 10:02:26.
+** Generated automatically by tolua++-1.0.92 on 03/17/13 18:47:09.
 */
 
 /* Exported function */
diff --git a/source/Generating/Caves.cpp b/source/Generating/Caves.cpp
index 2bf145de6..fdd6d4dce 100644
--- a/source/Generating/Caves.cpp
+++ b/source/Generating/Caves.cpp
@@ -755,20 +755,15 @@ void cStructGenWormNestCaves::ClearCache(void)
 

 

 

-void cStructGenWormNestCaves::GenStructures(

-	int a_ChunkX, int a_ChunkZ,

-	cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-	cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-	cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-	cEntityList & a_Entities,               // Entities may be added or deleted

-	cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-)

+void cStructGenWormNestCaves::GenStructures(cChunkDesc & a_ChunkDesc)

 {

+	int ChunkX = a_ChunkDesc.GetChunkX();

+	int ChunkZ = a_ChunkDesc.GetChunkZ();

 	cCaveSystems Caves;

-	GetCavesForChunk(a_ChunkX, a_ChunkZ, Caves);

+	GetCavesForChunk(ChunkX, ChunkZ, Caves);

 	for (cCaveSystems::const_iterator itr = Caves.begin(); itr != Caves.end(); ++itr)

 	{

-		(*itr)->ProcessChunk(a_ChunkX, a_ChunkZ, a_BlockTypes, a_HeightMap);

+		(*itr)->ProcessChunk(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());

 	}  // for itr - Caves[]

 }

 

@@ -900,27 +895,20 @@ static float GetMarbleNoise( float x, float y, float z, cNoise & a_Noise )
 

 

 

-void cStructGenMarbleCaves::GenStructures(

-	int a_ChunkX, int a_ChunkZ, 

-	cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-	cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-	cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-	cEntityList & a_Entities,               // Entities may be added or deleted

-	cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-)

+void cStructGenMarbleCaves::GenStructures(cChunkDesc & a_ChunkDesc)

 {

 	cNoise Noise(m_Seed);

 	for (int z = 0; z < cChunkDef::Width; z++) 

 	{

-		const float zz = (float)(a_ChunkZ * cChunkDef::Width + z);

+		const float zz = (float)(a_ChunkDesc.GetChunkZ() * cChunkDef::Width + z);

 		for (int x = 0; x < cChunkDef::Width; x++)

 		{

-			const float xx = (float)(a_ChunkX * cChunkDef::Width + x);

+			const float xx = (float)(a_ChunkDesc.GetChunkX() * cChunkDef::Width + x);

 			

-			int Top = cChunkDef::GetHeight(a_HeightMap, x, z);

+			int Top = a_ChunkDesc.GetHeight(x, z);

 			for (int y = 1; y < Top; ++y )

 			{

-				if (cChunkDef::GetBlock(a_BlockTypes, x, y, z) != E_BLOCK_STONE)

+				if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_STONE)

 				{

 					continue;

 				}

@@ -929,7 +917,7 @@ void cStructGenMarbleCaves::GenStructures(
 				const float WaveNoise = 1;

 				if (cosf(GetMarbleNoise(xx, yy * 0.5f, zz, Noise)) * fabs(cosf(yy * 0.2f + WaveNoise * 2) * 0.75f + WaveNoise) > 0.0005f)

 				{

-					cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);

+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);

 				}

 			}  // for y

 		}  // for x

@@ -943,43 +931,27 @@ void cStructGenMarbleCaves::GenStructures(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 // cStructGenDualRidgeCaves:

 

-void cStructGenDualRidgeCaves::GenStructures(

-	int a_ChunkX, int a_ChunkZ, 

-	cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-	cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-	cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-	cEntityList & a_Entities,               // Entities may be added or deleted

-	cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-)

+void cStructGenDualRidgeCaves::GenStructures(cChunkDesc & a_ChunkDesc)

 {

-	cNoise Noise1(m_Seed);

-	cNoise Noise2(2 * m_Seed + 19999);

 	for (int z = 0; z < cChunkDef::Width; z++) 

 	{

-		const float zz = (float)(a_ChunkZ * cChunkDef::Width + z) / 10;

+		const float zz = (float)(a_ChunkDesc.GetChunkZ() * cChunkDef::Width + z) / 10;

 		for (int x = 0; x < cChunkDef::Width; x++)

 		{

-			const float xx = (float)(a_ChunkX * cChunkDef::Width + x) / 10;

+			const float xx = (float)(a_ChunkDesc.GetChunkX() * cChunkDef::Width + x) / 10;

 			

-			int Top = cChunkDef::GetHeight(a_HeightMap, x, z);

+			int Top = a_ChunkDesc.GetHeight(x, z);

 			for (int y = 1; y <= Top; ++y)

 			{

-				/*

-				if (cChunkDef::GetBlock(a_BlockTypes, x, y, z) != E_BLOCK_STONE)

-				{

-					continue;

-				}

-				*/

-

 				const float yy = (float)y / 10;

 				const float WaveNoise = 1;

-				float n1 = Noise1.CubicNoise3D(xx, yy, zz);

-				float n2 = Noise2.CubicNoise3D(xx, yy, zz);

-				float n3 = Noise1.CubicNoise3D(xx * 4, yy * 4, zz * 4) / 4;

-				float n4 = Noise2.CubicNoise3D(xx * 4, yy * 4, zz * 4) / 4;

+				float n1 = m_Noise1.CubicNoise3D(xx, yy, zz);

+				float n2 = m_Noise2.CubicNoise3D(xx, yy, zz);

+				float n3 = m_Noise1.CubicNoise3D(xx * 4, yy * 4, zz * 4) / 4;

+				float n4 = m_Noise2.CubicNoise3D(xx * 4, yy * 4, zz * 4) / 4;

 				if ((abs(n1 + n3) * abs(n2 + n4)) > m_Threshold)

 				{

-					cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);

+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);

 				}

 			}  // for y

 		}  // for x

diff --git a/source/Generating/Caves.h b/source/Generating/Caves.h
index 58213abe2..bb69550a8 100644
--- a/source/Generating/Caves.h
+++ b/source/Generating/Caves.h
@@ -30,14 +30,7 @@ protected:
 	int m_Seed;

 	

 	// cStructureGen override:

-	virtual void GenStructures(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-		cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-		cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-		cEntityList & a_Entities,               // Entities may be added or deleted

-		cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-	) override;

+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

 } ;

 

 

@@ -49,25 +42,21 @@ class cStructGenDualRidgeCaves :
 {

 public:

 	cStructGenDualRidgeCaves(int a_Seed, float a_Threshold) :

+		m_Noise1(a_Seed),

+		m_Noise2(2 * a_Seed + 19999),

 		m_Seed(a_Seed),

 		m_Threshold(a_Threshold)

 	{

 	}

 	

 protected:

-

-	int m_Seed;

-	float m_Threshold;

+	cNoise m_Noise1;

+	cNoise m_Noise2;

+	int    m_Seed;

+	float  m_Threshold;

 	

 	// cStructureGen override:

-	virtual void GenStructures(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-		cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-		cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-		cEntityList & a_Entities,               // Entities may be added or deleted

-		cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-	) override;

+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

 } ;

 

 

@@ -105,14 +94,7 @@ protected:
 	void GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cCaveSystems & a_Caves);

 	

 	// cStructGen override:

-	virtual void GenStructures(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-		cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-		cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-		cEntityList & a_Entities,               // Entities may be added or deleted

-		cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-	) override;

+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

 } ;

 

 

diff --git a/source/Generating/ChunkDesc.cpp b/source/Generating/ChunkDesc.cpp
index f19c0ae1e..00ccacc07 100644
--- a/source/Generating/ChunkDesc.cpp
+++ b/source/Generating/ChunkDesc.cpp
@@ -39,6 +39,16 @@ cChunkDesc::~cChunkDesc()
 

 

 

+void cChunkDesc::SetChunkCoords(int a_ChunkX, int a_ChunkZ)

+{

+	m_ChunkX = a_ChunkX;

+	m_ChunkZ = a_ChunkZ;

+}

+

+

+

+

+

 void cChunkDesc::FillBlocks(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)

 {

 	const NIBBLETYPE CompressedMeta = a_BlockMeta | (a_BlockMeta << 4);

@@ -411,3 +421,19 @@ void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX
 

 

 

+HEIGHTTYPE cChunkDesc::GetMaxHeight(void) const

+{

+	HEIGHTTYPE MaxHeight = m_HeightMap[0];

+	for (int i = 1; i < ARRAYCOUNT(m_HeightMap); i++)

+	{

+		if (m_HeightMap[i] > MaxHeight)

+		{

+			MaxHeight = m_HeightMap[i];

+		}

+	}

+	return MaxHeight;

+}

+

+

+

+

diff --git a/source/Generating/ChunkDesc.h b/source/Generating/ChunkDesc.h
index afe3df331..7df7a1d35 100644
--- a/source/Generating/ChunkDesc.h
+++ b/source/Generating/ChunkDesc.h
@@ -33,6 +33,11 @@ public:
 
 	// tolua_begin
 
+	int GetChunkX(void) const { return m_ChunkX; }
+	int GetChunkZ(void) const { return m_ChunkZ; }
+	
+	void SetChunkCoords(int a_ChunkX, int a_ChunkZ);
+	
 	void       FillBlocks(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	void       SetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	void       GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
@@ -67,16 +72,19 @@ public:
 	/// Reads an area from the chunk into a cBlockArea
 	void ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ);
 
+	/// Returns the maximum height value in the heightmap
+	HEIGHTTYPE GetMaxHeight(void) const;
+	
 	// tolua_end
 	
 	
 	// Accessors used by cChunkGenerator::Generator descendants:
-	cChunkDef::BiomeMap &     GetBiomeMap     (void) { return m_BiomeMap; }
-	cChunkDef::BlockTypes &   GetBlockTypes   (void) { return m_BlockTypes; }
-	cChunkDef::BlockNibbles & GetBlockMetas   (void) { return m_BlockMeta; }
-	cChunkDef::HeightMap &    GetHeightMap    (void) { return m_HeightMap; }
-	cEntityList &             GetEntities     (void) { return m_Entities; }
-	cBlockEntityList &        GetBlockEntities(void) { return m_BlockEntities; }
+	inline cChunkDef::BiomeMap &     GetBiomeMap     (void) { return m_BiomeMap; }
+	inline cChunkDef::BlockTypes &   GetBlockTypes   (void) { return m_BlockTypes; }
+	inline cChunkDef::BlockNibbles & GetBlockMetas   (void) { return m_BlockMeta; }
+	inline cChunkDef::HeightMap &    GetHeightMap    (void) { return m_HeightMap; }
+	inline cEntityList &             GetEntities     (void) { return m_Entities; }
+	inline cBlockEntityList &        GetBlockEntities(void) { return m_BlockEntities; }
 	
 private:
 	int m_ChunkX;
diff --git a/source/Generating/CompoGen.cpp b/source/Generating/CompoGen.cpp
index e1d620ab3..34a83bd52 100644
--- a/source/Generating/CompoGen.cpp
+++ b/source/Generating/CompoGen.cpp
@@ -18,18 +18,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cCompoGenSameBlock:
 
-void cCompoGenSameBlock::ComposeTerrain(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-	cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-	const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-	const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-	cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-	cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-)
+void cCompoGenSameBlock::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 {
-	memset(a_BlockTypes, E_BLOCK_AIR, sizeof(a_BlockTypes));
-	memset(a_BlockMeta, 0, sizeof(a_BlockMeta));
+	memset(a_ChunkDesc.GetBlockTypes(), E_BLOCK_AIR, sizeof(a_ChunkDesc.GetBlockTypes()));
+	memset(a_ChunkDesc.GetBlockMetas(), 0, sizeof(a_ChunkDesc.GetBlockMetas()));
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
 		for (int x = 0; x < cChunkDef::Width; x++)
@@ -37,16 +29,16 @@ void cCompoGenSameBlock::ComposeTerrain(
 			int Start;
 			if (m_IsBedrocked)
 			{
-				a_BlockTypes[cChunkDef::MakeIndex(x, 0, z)] = E_BLOCK_BEDROCK;
+				a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
 				Start = 1;
 			}
 			else
 			{
 				Start = 0;
 			}
-			for (int y = a_HeightMap[x + cChunkDef::Width * z]; y >= Start; y--)
+			for (int y = a_ChunkDesc.GetHeight(x, z); y >= Start; y--)
 			{
-				a_BlockTypes[cChunkDef::MakeIndex(x, y, z)] = m_BlockType;
+				a_ChunkDesc.SetBlockType(x, y, z, m_BlockType);
 			}  // for y
 		}  // for z
 	}  // for x
@@ -59,15 +51,7 @@ void cCompoGenSameBlock::ComposeTerrain(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cCompoGenDebugBiomes:
 
-void cCompoGenDebugBiomes::ComposeTerrain(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-	cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-	const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-	const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-	cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-	cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-)
+void cCompoGenDebugBiomes::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 {
 	static BLOCKTYPE Blocks[] =
 	{
@@ -96,17 +80,17 @@ void cCompoGenDebugBiomes::ComposeTerrain(
 		E_BLOCK_BEDROCK,
 	} ;
 	
-	memset(a_BlockTypes, E_BLOCK_AIR, sizeof(a_BlockTypes));
-	memset(a_BlockMeta, 0, sizeof(a_BlockMeta));
+	memset(a_ChunkDesc.GetBlockTypes(), E_BLOCK_AIR, sizeof(a_ChunkDesc.GetBlockTypes()));
+	memset(a_ChunkDesc.GetBlockMetas(), 0,           sizeof(a_ChunkDesc.GetBlockMetas()));
 
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			BLOCKTYPE BlockType = Blocks[cChunkDef::GetBiome(a_BiomeMap, x, z) % ARRAYCOUNT(Blocks)];
-			for (int y = a_HeightMap[x + cChunkDef::Width * z]; y >= 0; y--)
+			BLOCKTYPE BlockType = Blocks[a_ChunkDesc.GetBiome(x, z)];
+			for (int y = a_ChunkDesc.GetHeight(x, z); y >= 0; y--)
 			{
-				cChunkDef::SetBlock(a_BlockTypes, x, y, z, BlockType);
+				a_ChunkDesc.SetBlockType(x, y, z, BlockType);
 			}  // for y
 		}  // for z
 	}  // for x
@@ -140,15 +124,7 @@ cCompoGenClassic::cCompoGenClassic(
 
 
 
-void cCompoGenClassic::ComposeTerrain(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-	cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-	const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-	const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-	cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-	cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-)
+void cCompoGenClassic::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 {
 	/* The classic composition means:
 		- 1 layer of grass, 3 of dirt and the rest stone, if the height > sealevel + beachheight
@@ -158,13 +134,13 @@ void cCompoGenClassic::ComposeTerrain(
 		- bedrock at the bottom
 	*/
 
-	memset(a_BlockTypes, E_BLOCK_AIR, sizeof(a_BlockTypes));
-	memset(a_BlockMeta, 0, sizeof(a_BlockMeta));
+	memset(a_ChunkDesc.GetBlockTypes(), E_BLOCK_AIR, sizeof(a_ChunkDesc.GetBlockTypes()));
+	memset(a_ChunkDesc.GetBlockMetas(), 0,           sizeof(a_ChunkDesc.GetBlockMetas()));
 
 	// The patterns to use for different situations, must be same length!
-	static const BLOCKTYPE PatternGround[] = {m_BlockTop, m_BlockMiddle, m_BlockMiddle, m_BlockMiddle} ;
-	static const BLOCKTYPE PatternBeach[]  = {m_BlockBeach,  m_BlockBeach, m_BlockBeach, m_BlockBeachBottom} ;
-	static const BLOCKTYPE PatternOcean[]  = {m_BlockMiddle,  m_BlockMiddle, m_BlockMiddle, m_BlockBottom} ;
+	const BLOCKTYPE PatternGround[] = {m_BlockTop,    m_BlockMiddle, m_BlockMiddle, m_BlockMiddle} ;
+	const BLOCKTYPE PatternBeach[]  = {m_BlockBeach,  m_BlockBeach,  m_BlockBeach,  m_BlockBeachBottom} ;
+	const BLOCKTYPE PatternOcean[]  = {m_BlockMiddle, m_BlockMiddle, m_BlockMiddle, m_BlockBottom} ;
 	static int PatternLength = ARRAYCOUNT(PatternGround);
 	ASSERT(ARRAYCOUNT(PatternGround) == ARRAYCOUNT(PatternBeach));
 	ASSERT(ARRAYCOUNT(PatternGround) == ARRAYCOUNT(PatternOcean));
@@ -173,7 +149,7 @@ void cCompoGenClassic::ComposeTerrain(
 	{
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			int Height = cChunkDef::GetHeight(a_HeightMap, x, z);
+			int Height = a_ChunkDesc.GetHeight(x, z);
 			const BLOCKTYPE * Pattern;
 			if (Height > m_SeaLevel + m_BeachHeight)
 			{
@@ -191,17 +167,17 @@ void cCompoGenClassic::ComposeTerrain(
 			// Fill water from sealevel down to height (if any):
 			for (int y = m_SeaLevel; y >= Height; --y)
 			{
-				cChunkDef::SetBlock(a_BlockTypes, x, y, z, m_BlockSea);
+				a_ChunkDesc.SetBlockType(x, y, z, m_BlockSea);
 			}
 			
 			// Fill from height till the bottom:
 			for (int y = Height; y >= 1; y--)
 			{
-				cChunkDef::SetBlock(a_BlockTypes, x, y, z, (Height - y < PatternLength) ? Pattern[Height - y] : m_BlockBottom);
+				a_ChunkDesc.SetBlockType(x, y, z, (Height - y < PatternLength) ? Pattern[Height - y] : m_BlockBottom);
 			}
 			
 			// The last layer is always bedrock:
-			cChunkDef::SetBlock(a_BlockTypes, x, 0, z, E_BLOCK_BEDROCK);
+			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
 		}  // for x
 	}  // for z
 }
@@ -213,26 +189,21 @@ void cCompoGenClassic::ComposeTerrain(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cCompoGenBiomal:
 
-void cCompoGenBiomal::ComposeTerrain(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-	cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-	const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-	const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-	cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-	cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-)
+void cCompoGenBiomal::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 {
-	memset(a_BlockTypes, 0, sizeof(a_BlockTypes));
-	memset(a_BlockMeta,  0, sizeof(a_BlockMeta));
+	memset(a_ChunkDesc.GetBlockTypes(), E_BLOCK_AIR, sizeof(a_ChunkDesc.GetBlockTypes()));
+	memset(a_ChunkDesc.GetBlockMetas(), 0,           sizeof(a_ChunkDesc.GetBlockMetas()));
+
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			int Height = cChunkDef::GetHeight(a_HeightMap, x, z);
+			int Height = a_ChunkDesc.GetHeight(x, z);
 			if (Height > m_SeaLevel)
 			{
-				switch (cChunkDef::GetBiome(a_BiomeMap, x, z))
+				switch (a_ChunkDesc.GetBiome(x, z))
 				{
 					case biOcean:
 					case biPlains:
@@ -251,20 +222,20 @@ void cCompoGenBiomal::ComposeTerrain(
 					case biJungle:
 					case biJungleHills:
 					{
-						FillColumnGrass(x, z, Height, a_BlockTypes);
+						FillColumnGrass(x, z, Height, a_ChunkDesc.GetBlockTypes());
 						break;
 					}
 					case biDesertHills:
 					case biDesert:
 					case biBeach:
 					{
-						FillColumnSand(x, z, Height, a_BlockTypes);
+						FillColumnSand(x, z, Height, a_ChunkDesc.GetBlockTypes());
 						break;
 					}
 					case biMushroomIsland:
 					case biMushroomShore:
 					{
-						FillColumnMycelium(x, z, Height, a_BlockTypes);
+						FillColumnMycelium(x, z, Height, a_ChunkDesc.GetBlockTypes());
 						break;
 					}
 					default:
@@ -277,24 +248,24 @@ void cCompoGenBiomal::ComposeTerrain(
 			}
 			else
 			{
-				switch (cChunkDef::GetBiome(a_BiomeMap, x, z))
+				switch (a_ChunkDesc.GetBiome(x, z))
 				{
 					case biDesert:
 					case biBeach:
 					{
 						// Fill with water, sand, sandstone and stone
-						FillColumnWaterSand(x, z, Height, a_BlockTypes);
+						FillColumnWaterSand(x, z, Height, a_ChunkDesc.GetBlockTypes());
 						break;
 					}
 					default:
 					{
 						// Fill with water, sand/dirt/clay mix and stone
-						FillColumnWaterMix(a_ChunkX, a_ChunkZ, x, z, Height, a_BlockTypes);
+						FillColumnWaterMix(ChunkX, ChunkZ, x, z, Height, a_ChunkDesc.GetBlockTypes());
 						break;
 					}
 				}  // switch (biome)
 			}  // else (under water)
-			cChunkDef::SetBlock(a_BlockTypes, x, 0, z, E_BLOCK_BEDROCK);
+			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
 		}  // for x
 	}  // for z
 }
@@ -440,29 +411,14 @@ cCompoGenNether::cCompoGenNether(int a_Seed) :
 
 
 
-void cCompoGenNether::ComposeTerrain(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-	cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-	const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-	const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-	cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-	cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-)
+void cCompoGenNether::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 {
-	HEIGHTTYPE MaxHeight = 0;
-	for (int i = 0; i < ARRAYCOUNT(a_HeightMap); i++)
-	{
-		if (a_HeightMap[i] > MaxHeight)
-		{
-			MaxHeight = a_HeightMap[i];
-		}
-	}
+	HEIGHTTYPE MaxHeight = a_ChunkDesc.GetMaxHeight();
 	
 	const int SEGMENT_HEIGHT = 8;
 	const int INTERPOL_X = 16;  // Must be a divisor of 16
 	const int INTERPOL_Z = 16;  // Must be a divisor of 16
-	// Interpolate the chunk in 16 * SEGMENT_HEIGHT * 16 "segments", each 8 blocks high and each linearly interpolated separately.
+	// Interpolate the chunk in 16 * SEGMENT_HEIGHT * 16 "segments", each SEGMENT_HEIGHT blocks high and each linearly interpolated separately.
 	// Have two buffers, one for the lowest floor and one for the highest floor, so that Y-interpolation can be done between them
 	// Then swap the buffers and use the previously-top one as the current-bottom, without recalculating it.
 	
@@ -470,8 +426,8 @@ void cCompoGenNether::ComposeTerrain(
 	int FloorBuf2[17 * 17];
 	int * FloorHi = FloorBuf1;
 	int * FloorLo = FloorBuf2;
-	int BaseX = a_ChunkX * cChunkDef::Width;
-	int BaseZ = a_ChunkZ * cChunkDef::Width;
+	int BaseX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BaseZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
 	
 	// Interpolate the lowest floor:
 	for (int z = 0; z <= 16 / INTERPOL_Z; z++) for (int x = 0; x <= 16 / INTERPOL_X; x++)
@@ -504,7 +460,7 @@ void cCompoGenNether::ComposeTerrain(
 			for (int y = 0; y < SEGMENT_HEIGHT; y++)
 			{
 				int Val = Lo + (Hi - Lo) * y / SEGMENT_HEIGHT;
-				cChunkDef::SetBlock(a_BlockTypes, x, y + Segment, z, (Val < m_Threshold) ? E_BLOCK_NETHERRACK : E_BLOCK_AIR);
+				a_ChunkDesc.SetBlockType(x, y + Segment, z, (Val < m_Threshold) ? E_BLOCK_NETHERRACK : E_BLOCK_AIR);
 			}
 		}
 		
@@ -515,8 +471,8 @@ void cCompoGenNether::ComposeTerrain(
 	// Bedrock at the bottom and at the top:
 	for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++)
 	{
-		cChunkDef::SetBlock(a_BlockTypes, x, 0, z, E_BLOCK_BEDROCK);
-		cChunkDef::SetBlock(a_BlockTypes, x, cChunkDef::GetHeight(a_HeightMap, x, z), z, E_BLOCK_BEDROCK);
+		a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
+		a_ChunkDesc.SetBlockType(x, a_ChunkDesc.GetHeight(x, z), z, E_BLOCK_BEDROCK);
 	}
 }
 
diff --git a/source/Generating/CompoGen.h b/source/Generating/CompoGen.h
index e92ba505c..9880ce1a0 100644
--- a/source/Generating/CompoGen.h
+++ b/source/Generating/CompoGen.h
@@ -36,15 +36,7 @@ protected:
 	bool      m_IsBedrocked;
 	
 	// cTerrainCompositionGen overrides:
-	virtual void ComposeTerrain(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-		cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-		const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-		const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-		cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-		cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-	) override;
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -60,15 +52,7 @@ public:
 protected:
 	
 	// cTerrainCompositionGen overrides:
-	virtual void ComposeTerrain(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-		cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-		const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-		const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-		cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-		cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-	) override;
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -98,15 +82,7 @@ protected:
 	BLOCKTYPE m_BlockSea;
 	
 	// cTerrainCompositionGen overrides:
-	virtual void ComposeTerrain(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-		cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-		const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-		const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-		cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-		cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-	) override;
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -129,15 +105,7 @@ protected:
 	int    m_SeaLevel;
 	
 	// cTerrainCompositionGen overrides:
-	virtual void ComposeTerrain(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-		cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-		const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-		const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-		cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-		cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-	) override;
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
 	
 	void FillColumnGrass    (int a_RelX, int a_RelZ, int a_Height, cChunkDef::BlockTypes & a_BlockTypes);
 	void FillColumnSand     (int a_RelX, int a_RelZ, int a_Height, cChunkDef::BlockTypes & a_BlockTypes);
@@ -166,15 +134,7 @@ protected:
 	int m_Threshold;
 	
 	// cTerrainCompositionGen overrides:
-	virtual void ComposeTerrain(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated
-		cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated
-		const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit
-		const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to
-		cEntityList & a_Entities,                  // Entitites may be generated along with the terrain
-		cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)
-	) override;
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
diff --git a/source/Generating/ComposableGenerator.cpp b/source/Generating/ComposableGenerator.cpp
index e9196757b..b88fb90c7 100644
--- a/source/Generating/ComposableGenerator.cpp
+++ b/source/Generating/ComposableGenerator.cpp
@@ -9,7 +9,6 @@
 #include "../World.h"

 #include "../../iniFile/iniFile.h"

 #include "../Root.h"

-#include "ChunkDesc.h"

 

 // Individual composed algorithms:

 #include "BioGen.h"

@@ -114,14 +113,14 @@ void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a
 	

 	if (a_ChunkDesc.IsUsingDefaultComposition())

 	{

-		m_CompositionGen->ComposeTerrain(a_ChunkX, a_ChunkZ, BlockTypes, BlockMeta, HeightMap, BiomeMap, Entities, BlockEntities);

+		m_CompositionGen->ComposeTerrain(a_ChunkDesc);

 	}

 

 	if (a_ChunkDesc.IsUsingDefaultStructures())

 	{	

 		for (cStructureGenList::iterator itr = m_StructureGens.begin(); itr != m_StructureGens.end(); ++itr)

 		{

-			(*itr)->GenStructures(a_ChunkX, a_ChunkZ, BlockTypes, BlockMeta, HeightMap, Entities, BlockEntities);

+			(*itr)->GenStructures(a_ChunkDesc);

 		}   // for itr - m_StructureGens[]

 	}

 	

@@ -129,7 +128,7 @@ void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a
 	{

 		for (cFinishGenList::iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)

 		{

-			(*itr)->GenFinish(a_ChunkX, a_ChunkZ, BlockTypes, BlockMeta, HeightMap, BiomeMap, Entities, BlockEntities);

+			(*itr)->GenFinish(a_ChunkDesc);

 		}  // for itr - m_FinishGens[]

 	}

 }

@@ -372,7 +371,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		}

 		else if (NoCaseCompare(*itr, "DeadBushes") == 0)

 		{

-			m_FinishGens.push_back(new cFinishGenDeadBushes(Seed));

+			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, biDesert, 2, E_BLOCK_SAND, E_BLOCK_SAND));

 		}

 		else if (NoCaseCompare(*itr, "Ice") == 0)

 		{

@@ -384,7 +383,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		}

 		else if (NoCaseCompare(*itr, "Lilypads") == 0)

 		{

-			m_FinishGens.push_back(new cFinishGenLilypads(Seed));

+			m_FinishGens.push_back(new cFinishGenSingleBiomeSingleTopBlock(Seed, E_BLOCK_LILY_PAD, biSwampland, 4, E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER));

 		}

 		else if (NoCaseCompare(*itr, "PreSimulator") == 0)

 		{

diff --git a/source/Generating/ComposableGenerator.h b/source/Generating/ComposableGenerator.h
index b6f946eb3..fca2c26c6 100644
--- a/source/Generating/ComposableGenerator.h
+++ b/source/Generating/ComposableGenerator.h
@@ -18,6 +18,7 @@ See http://forum.mc-server.org/showthread.php?tid=409 for details.
 #pragma once

 

 #include "ChunkGenerator.h"

+#include "ChunkDesc.h"

 

 

 

@@ -72,15 +73,7 @@ class cTerrainCompositionGen
 public:

 	virtual ~cTerrainCompositionGen() {}  // Force a virtual destructor in descendants

 	

-	virtual void ComposeTerrain(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,      // BlockTypes to be generated (the whole array gets initialized, even air)

-		cChunkDef::BlockNibbles & a_BlockMeta,     // BlockMetas to be generated (the whole array gets initialized)

-		const cChunkDef::HeightMap & a_HeightMap,  // The height map to fit

-		const cChunkDef::BiomeMap & a_BiomeMap,    // Biomes to adhere to

-		cEntityList & a_Entities,                  // Entitites may be generated along with the terrain

-		cBlockEntityList & a_BlockEntities         // Block entitites may be generated (chests / furnaces / ...)

-	) = 0;

+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) = 0;

 } ;

 

 

@@ -98,14 +91,7 @@ class cStructureGen
 public:

 	virtual ~cStructureGen() {}  // Force a virtual destructor in descendants

 	

-	virtual void GenStructures(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-		cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-		cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-		cEntityList & a_Entities,               // Entities may be added or deleted

-		cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-	) = 0;

+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) = 0;

 } ;

 

 typedef std::list<cStructureGen *> cStructureGenList;

@@ -122,15 +108,7 @@ class cFinishGen
 public:

 	virtual ~cFinishGen() {}  // Force a virtual destructor in descendants

 	

-	virtual void GenFinish(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change

-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change

-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data

-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to

-		cEntityList & a_Entities,                // Entities may be added or deleted

-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted

-	) = 0;

+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) = 0;

 } ;

 

 typedef std::list<cFinishGen *> cFinishGenList;

diff --git a/source/Generating/FinishGen.cpp b/source/Generating/FinishGen.cpp
index ab3d9488d..6a7d53b14 100644
--- a/source/Generating/FinishGen.cpp
+++ b/source/Generating/FinishGen.cpp
@@ -42,12 +42,7 @@ static inline bool IsWater(BLOCKTYPE a_BlockType)
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFinishGenSprinkleFoliage:
 
-bool cFinishGenSprinkleFoliage::TryAddSugarcane(
-	int a_ChunkX, int a_ChunkZ,
-	int a_RelX, int a_RelY, int a_RelZ,
-	cChunkDef::BlockTypes & a_BlockTypes,
-	cChunkDef::BlockNibbles & a_BlockMeta
-)
+bool cFinishGenSprinkleFoliage::TryAddSugarcane(cChunkDesc & a_ChunkDesc, int a_RelX, int a_RelY, int a_RelZ)
 {
 	// We'll be doing comparison to neighbors, so require the coords to be 1 block away from the chunk edges:
 	if (
@@ -60,7 +55,7 @@ bool cFinishGenSprinkleFoliage::TryAddSugarcane(
 	}
 
 	// Only allow dirt, grass or sand below sugarcane:
-	switch (cChunkDef::GetBlock(a_BlockTypes, a_RelX, a_RelY, a_RelZ))
+	switch (a_ChunkDesc.GetBlockType(a_RelX, a_RelY, a_RelZ))
 	{
 		case E_BLOCK_DIRT:
 		case E_BLOCK_GRASS:
@@ -76,17 +71,17 @@ bool cFinishGenSprinkleFoliage::TryAddSugarcane(
 
 	// Water is required next to the block below the sugarcane:
 	if (
-		!IsWater(cChunkDef::GetBlock(a_BlockTypes, a_RelX - 1, a_RelY, a_RelZ)) &&
-		!IsWater(cChunkDef::GetBlock(a_BlockTypes, a_RelX + 1, a_RelY, a_RelZ)) &&
-		!IsWater(cChunkDef::GetBlock(a_BlockTypes, a_RelX    , a_RelY, a_RelZ - 1)) &&
-		!IsWater(cChunkDef::GetBlock(a_BlockTypes, a_RelX    , a_RelY, a_RelZ + 1))
+		!IsWater(a_ChunkDesc.GetBlockType(a_RelX - 1, a_RelY, a_RelZ)) &&
+		!IsWater(a_ChunkDesc.GetBlockType(a_RelX + 1, a_RelY, a_RelZ)) &&
+		!IsWater(a_ChunkDesc.GetBlockType(a_RelX    , a_RelY, a_RelZ - 1)) &&
+		!IsWater(a_ChunkDesc.GetBlockType(a_RelX    , a_RelY, a_RelZ + 1))
 	)
 	{
 		return false;
 	}
 	
 	// All conditions met, place a sugarcane here:
-	cChunkDef::SetBlock(a_BlockTypes, a_RelX, a_RelY + 1, a_RelZ, E_BLOCK_SUGARCANE);
+	a_ChunkDesc.SetBlockType(a_RelX, a_RelY + 1, a_RelZ, E_BLOCK_SUGARCANE);
 	return true;
 }
 
@@ -94,38 +89,29 @@ bool cFinishGenSprinkleFoliage::TryAddSugarcane(
 
 
 
-void cFinishGenSprinkleFoliage::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	)
+void cFinishGenSprinkleFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	// Generate small foliage (1-block):
 	
 	// TODO: Update heightmap with 1-block-tall foliage
-	cNoise Noise(m_Seed);
 	for (int z = 0; z < cChunkDef::Width; z++) 
 	{
-		int BlockZ = a_ChunkZ * cChunkDef::Width + z;
+		int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width + z;
 		const float zz = (float)BlockZ;
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			int BlockX = a_ChunkX * cChunkDef::Width + x;
-			if (((Noise.IntNoise2DInt(BlockX, BlockZ) / 8) % 128) < 124)
+			int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width + x;
+			if (((m_Noise.IntNoise2DInt(BlockX, BlockZ) / 8) % 128) < 124)
 			{
 				continue;
 			}
-			int Top = cChunkDef::GetHeight(a_HeightMap, x, z);
+			int Top = a_ChunkDesc.GetHeight(x, z);
 			if (Top > 250)
 			{
 				// Nothing grows above Y=250
 				continue;
 			}
-			if (cChunkDef::GetBlock(a_BlockTypes, x, Top + 1, z) != E_BLOCK_AIR)
+			if (a_ChunkDesc.GetBlockType(x, Top + 1, z) != E_BLOCK_AIR)
 			{
 				// Space already taken by something else, don't grow here
 				// WEIRD, since we're using heightmap, so there should NOT be anything above it
@@ -133,43 +119,41 @@ void cFinishGenSprinkleFoliage::GenFinish(
 			}
 			
 			const float xx = (float)BlockX;
-			float val1 = Noise.CubicNoise2D(xx * 0.1f,  zz * 0.1f );
-			float val2 = Noise.CubicNoise2D(xx * 0.01f, zz * 0.01f );
-			switch (cChunkDef::GetBlock(a_BlockTypes, x, Top, z))
+			float val1 = m_Noise.CubicNoise2D(xx * 0.1f,  zz * 0.1f );
+			float val2 = m_Noise.CubicNoise2D(xx * 0.01f, zz * 0.01f );
+			switch (a_ChunkDesc.GetBlockType(x, Top, z))
 			{
 				case E_BLOCK_GRASS:
 				{
-					float val3 = Noise.CubicNoise2D(xx * 0.01f + 10, zz * 0.01f + 10 );
-					float val4 = Noise.CubicNoise2D(xx * 0.05f + 20, zz * 0.05f + 20 );
+					float val3 = m_Noise.CubicNoise2D(xx * 0.01f + 10, zz * 0.01f + 10 );
+					float val4 = m_Noise.CubicNoise2D(xx * 0.05f + 20, zz * 0.05f + 20 );
 					if (val1 + val2 > 0.2f)
 					{
-						cChunkDef::SetBlock(a_BlockTypes, x, ++Top, z, E_BLOCK_YELLOW_FLOWER);
+						a_ChunkDesc.SetBlockType(x, ++Top, z, E_BLOCK_YELLOW_FLOWER);
 					}
 					else if (val2 + val3 > 0.2f)
 					{
-						cChunkDef::SetBlock(a_BlockTypes, x, ++Top, z, E_BLOCK_RED_ROSE);
+						a_ChunkDesc.SetBlockType(x, ++Top, z, E_BLOCK_RED_ROSE);
 					}
 					else if (val3 + val4 > 0.2f)
 					{
-						cChunkDef::SetBlock(a_BlockTypes, x, ++Top, z, E_BLOCK_RED_MUSHROOM);
+						a_ChunkDesc.SetBlockType(x, ++Top, z, E_BLOCK_RED_MUSHROOM);
 					}
 					else if (val1 + val4 > 0.2f)
 					{
-						cChunkDef::SetBlock(a_BlockTypes, x, ++Top, z, E_BLOCK_BROWN_MUSHROOM);
+						a_ChunkDesc.SetBlockType(x, ++Top, z, E_BLOCK_BROWN_MUSHROOM);
 					}
 					else if (val1 + val2 + val3 + val4 < -0.1)
 					{
-						cChunkDef::SetBlock (a_BlockTypes, x, ++Top, z, E_BLOCK_TALL_GRASS);
-						cChunkDef::SetNibble(a_BlockMeta,  x,   Top, z, E_META_TALL_GRASS_GRASS);
+						a_ChunkDesc.SetBlockTypeMeta(x, ++Top, z, E_BLOCK_TALL_GRASS, E_META_TALL_GRASS_GRASS);
 					}
-					else if (TryAddSugarcane(a_ChunkX, a_ChunkZ, x, Top, z, a_BlockTypes, a_BlockMeta))
+					else if (TryAddSugarcane(a_ChunkDesc, x, Top, z))
 					{
 						++Top;
 					}
 					else if ((val1 > 0.5) && (val2 < -0.5))
 					{
-						cChunkDef::SetBlock (a_BlockTypes, x, ++Top, z, E_BLOCK_PUMPKIN);
-						cChunkDef::SetNibble(a_BlockMeta,  x,   Top, z, (int)(val3 * 8) % 4);
+						a_ChunkDesc.SetBlockTypeMeta(x, ++Top, z, E_BLOCK_PUMPKIN, (int)(val3 * 8) % 4);
 					}
 					break;
 				}  // case E_BLOCK_GRASS
@@ -181,22 +165,22 @@ void cFinishGenSprinkleFoliage::GenFinish(
 						(x > 0) && (x < cChunkDef::Width - 1) &&
 						(z > 0) && (z < cChunkDef::Width - 1) &&
 						(val1 + val2 > 0.5f) &&
-						(cChunkDef::GetBlock(a_BlockTypes, x + 1, y, z)     == E_BLOCK_AIR) &&
-						(cChunkDef::GetBlock(a_BlockTypes, x - 1, y, z)     == E_BLOCK_AIR) &&
-						(cChunkDef::GetBlock(a_BlockTypes, x,     y, z + 1) == E_BLOCK_AIR) &&
-						(cChunkDef::GetBlock(a_BlockTypes, x,     y, z - 1) == E_BLOCK_AIR)
+						(a_ChunkDesc.GetBlockType(x + 1, y, z)     == E_BLOCK_AIR) &&
+						(a_ChunkDesc.GetBlockType(x - 1, y, z)     == E_BLOCK_AIR) &&
+						(a_ChunkDesc.GetBlockType(x,     y, z + 1) == E_BLOCK_AIR) &&
+						(a_ChunkDesc.GetBlockType(x,     y, z - 1) == E_BLOCK_AIR)
 					)
 					{
-						cChunkDef::SetBlock(a_BlockTypes, x, ++Top, z, E_BLOCK_CACTUS);
+						a_ChunkDesc.SetBlockType(x, ++Top, z, E_BLOCK_CACTUS);
 					}
-					else if (TryAddSugarcane(a_ChunkX, a_ChunkZ, x, Top, z, a_BlockTypes, a_BlockMeta))
+					else if (TryAddSugarcane(a_ChunkDesc, x, Top, z))
 					{
 						++Top;
 					}
 					break;
 				}
 			}  // switch (TopBlock)
-			cChunkDef::SetHeight(a_HeightMap, x, z, Top);
+			a_ChunkDesc.SetHeight(x, z, Top);
 		}  // for y
 	}  // for z
 }
@@ -208,22 +192,14 @@ void cFinishGenSprinkleFoliage::GenFinish(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFinishGenSnow:
 
-void cFinishGenSnow::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	)
+void cFinishGenSnow::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	// Add a snow block in snowy biomes onto blocks that can be snowed over
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			switch (cChunkDef::GetBiome(a_BiomeMap, x, z))
+			switch (a_ChunkDesc.GetBiome(x, z))
 			{
 				case biIcePlains:
 				case biIceMountains:
@@ -232,11 +208,11 @@ void cFinishGenSnow::GenFinish(
 				case biFrozenRiver:
 				case biFrozenOcean:
 				{
-					int Height = cChunkDef::GetHeight(a_HeightMap, x, z);
-					if (g_BlockIsSnowable[cChunkDef::GetBlock(a_BlockTypes, x, Height, z)])
+					int Height = a_ChunkDesc.GetHeight(x, z);
+					if (g_BlockIsSnowable[a_ChunkDesc.GetBlockType(x, Height, z)])
 					{
-						cChunkDef::SetBlock(a_BlockTypes, x, Height + 1, z, E_BLOCK_SNOW);
-						cChunkDef::SetHeight(a_HeightMap, x, z, Height + 1);
+						a_ChunkDesc.SetBlockType(x, Height + 1, z, E_BLOCK_SNOW);
+						a_ChunkDesc.SetHeight(x, z, Height + 1);
 					}
 					break;
 				}
@@ -252,22 +228,14 @@ void cFinishGenSnow::GenFinish(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFinishGenIce:
 
-void cFinishGenIce::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	)
+void cFinishGenIce::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	// Turn surface water into ice in icy biomes
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
-			switch (cChunkDef::GetBiome(a_BiomeMap, x, z))
+			switch (a_ChunkDesc.GetBiome(x, z))
 			{
 				case biIcePlains:
 				case biIceMountains:
@@ -276,13 +244,13 @@ void cFinishGenIce::GenFinish(
 				case biFrozenRiver:
 				case biFrozenOcean:
 				{
-					int Height = cChunkDef::GetHeight(a_HeightMap, x, z);
-					switch (cChunkDef::GetBlock(a_BlockTypes, x, Height, z))
+					int Height = a_ChunkDesc.GetHeight(x, z);
+					switch (a_ChunkDesc.GetBlockType(x, Height, z))
 					{
 						case E_BLOCK_WATER:
 						case E_BLOCK_STATIONARY_WATER:
 						{
-							cChunkDef::SetBlock(a_BlockTypes, x, Height, z, E_BLOCK_ICE);
+							a_ChunkDesc.SetBlockType(x, Height, z, E_BLOCK_ICE);
 							break;
 						}
 					}
@@ -300,68 +268,58 @@ void cFinishGenIce::GenFinish(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFinishGenLilypads:
 
-int cFinishGenLilypads::GetNumLilypads(const cChunkDef::BiomeMap & a_BiomeMap)
+int cFinishGenSingleBiomeSingleTopBlock::GetNumToGen(const cChunkDef::BiomeMap & a_BiomeMap)
 {
 	int res = 0;
 	for (int i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)
 	{
-		if (a_BiomeMap[i] == biSwampland)
+		if (a_BiomeMap[i] == m_Biome)
 		{
 			res++;
 		}
 	}  // for i - a_BiomeMap[]
-	return res / 64;
+	return m_Amount * res / 256;
 }
 
 
 
 
 
-void cFinishGenLilypads::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-)
+void cFinishGenSingleBiomeSingleTopBlock::GenFinish(cChunkDesc & a_ChunkDesc)
 {
 	// Add Lilypads on top of water surface in Swampland
 
-	int NumLilypads = GetNumLilypads(a_BiomeMap);
-	for (int i = 0; i < NumLilypads; i++)
+	int NumToGen = GetNumToGen(a_ChunkDesc.GetBiomeMap());
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	for (int i = 0; i < NumToGen; i++)
 	{
-		int x = (m_Noise.IntNoise3DInt(a_ChunkX + a_ChunkZ, a_ChunkZ, i) / 13) % cChunkDef::Width;
-		int z = (m_Noise.IntNoise3DInt(a_ChunkX - a_ChunkZ, i, a_ChunkZ) / 11) % cChunkDef::Width;
+		int x = (m_Noise.IntNoise3DInt(ChunkX + ChunkZ, ChunkZ, i) / 13) % cChunkDef::Width;
+		int z = (m_Noise.IntNoise3DInt(ChunkX - ChunkZ, i, ChunkZ) / 11) % cChunkDef::Width;
 
-		// Place a lily pad at {x, z} if possible (swampland, empty block, water below):
-		if (cChunkDef::GetBiome(a_BiomeMap, x, z) != biSwampland)
+		// Place the block at {x, z} if possible:
+		if (a_ChunkDesc.GetBiome(x, z) != m_Biome)
 		{
-			// not swampland
+			// Incorrect biome
 			continue;
 		}
-		int Height = cChunkDef::GetHeight(a_HeightMap, x, z);
+		int Height = a_ChunkDesc.GetHeight(x, z);
 		if (Height >= cChunkDef::Height)
 		{
 			// Too high up
 			continue;
 		}
-		if (cChunkDef::GetBlock(a_BlockTypes, x, Height + 1, z) != E_BLOCK_AIR)
+		if (a_ChunkDesc.GetBlockType(x, Height + 1, z) != E_BLOCK_AIR)
 		{
-			// not empty block
+			// Not an empty block
 			continue;
 		}
-		switch (cChunkDef::GetBlock(a_BlockTypes, x, Height, z))
+		BLOCKTYPE BlockBelow = a_ChunkDesc.GetBlockType(x, Height, z);
+		if ((BlockBelow == m_AllowedBelow1) || (BlockBelow == m_AllowedBelow2))
 		{
-			case E_BLOCK_WATER:
-			case E_BLOCK_STATIONARY_WATER:
-			{
-				cChunkDef::SetBlock(a_BlockTypes, x, Height + 1, z, E_BLOCK_LILY_PAD);
-				cChunkDef::SetHeight(a_HeightMap, x, z, Height + 1);
-				break;
-			}
-		}  // switch (GetBlock)
+			a_ChunkDesc.SetBlockType(x, Height + 1, z, m_BlockType);
+			a_ChunkDesc.SetHeight(x, z, Height + 1);
+		}
 	}  // for i
 }
 
@@ -372,24 +330,17 @@ void cFinishGenLilypads::GenFinish(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFinishGenBottomLava:
 
-void cFinishGenBottomLava::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-)
+void cFinishGenBottomLava::GenFinish(cChunkDesc & a_ChunkDesc)
 {
+	cChunkDef::BlockTypes & BlockTypes = a_ChunkDesc.GetBlockTypes();
 	for (int y = m_Level; y > 0; y--)
 	{
 		for (int z = 0; z < cChunkDef::Width; z++) for (int x = 0; x < cChunkDef::Width; x++)
 		{
 			int Index = cChunkDef::MakeIndexNoCheck(x, y, z);
-			if (a_BlockTypes[Index] == E_BLOCK_AIR)
+			if (BlockTypes[Index] == E_BLOCK_AIR)
 			{
-				a_BlockTypes[Index] = E_BLOCK_STATIONARY_LAVA;
+				BlockTypes[Index] = E_BLOCK_STATIONARY_LAVA;
 			}
 		}  // for x, for z
 	}  // for y
@@ -411,19 +362,11 @@ cFinishGenPreSimulator::cFinishGenPreSimulator(void)
 
 
 
-void cFinishGenPreSimulator::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-)
+void cFinishGenPreSimulator::GenFinish(cChunkDesc & a_ChunkDesc)
 {
-	CollapseSandGravel(a_BlockTypes, a_HeightMap);
-	StationarizeFluid(a_BlockTypes, a_HeightMap, E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER);
-	StationarizeFluid(a_BlockTypes, a_HeightMap, E_BLOCK_LAVA,  E_BLOCK_STATIONARY_LAVA);
+	CollapseSandGravel(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
+	StationarizeFluid(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap(), E_BLOCK_WATER, E_BLOCK_STATIONARY_WATER);
+	StationarizeFluid(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap(), E_BLOCK_LAVA,  E_BLOCK_STATIONARY_LAVA);
 	// TODO: other operations
 }
 
@@ -575,77 +518,6 @@ void cFinishGenPreSimulator::StationarizeFluid(
 
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cFinishGenDeadBushes:
-
-int cFinishGenDeadBushes::GetNumDeadBushes(const cChunkDef::BiomeMap & a_BiomeMap)
-{
-	int res = 0;
-	for (int i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)
-	{
-		if (a_BiomeMap[i] == biDesert)
-		{
-			res++;
-		}
-	}  // for i - a_BiomeMap[]
-	return res / 128;
-}
-
-
-
-
-
-void cFinishGenDeadBushes::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-)
-{
-	// Add DeadBushes on top of sand surface in Desert
-
-	int NumDeadBushes = GetNumDeadBushes(a_BiomeMap);
-	for (int i = 0; i < NumDeadBushes; i++)
-	{
-		int x = (m_Noise.IntNoise3DInt(a_ChunkX + a_ChunkZ, a_ChunkZ, i) / 13) % cChunkDef::Width;
-		int z = (m_Noise.IntNoise3DInt(a_ChunkX - a_ChunkZ, i, a_ChunkZ) / 11) % cChunkDef::Width;
-
-		// Place a dead bush at {x, z} if possible (desert, empty block, sand below):
-		if (cChunkDef::GetBiome(a_BiomeMap, x, z) != biDesert)
-		{
-			// not swampland
-			continue;
-		}
-		int Height = cChunkDef::GetHeight(a_HeightMap, x, z);
-		if (Height >= cChunkDef::Height)
-		{
-			// Too high up
-			continue;
-		}
-		if (cChunkDef::GetBlock(a_BlockTypes, x, Height + 1, z) != E_BLOCK_AIR)
-		{
-			// not empty block
-			continue;
-		}
-		switch (cChunkDef::GetBlock(a_BlockTypes, x, Height, z))
-		{
-			case E_BLOCK_SAND:
-			{
-				cChunkDef::SetBlock(a_BlockTypes, x, Height + 1, z, E_BLOCK_DEAD_BUSH);
-				cChunkDef::SetHeight(a_HeightMap, x, z, Height + 1);
-				break;
-			}
-		}  // switch (GetBlock)
-	}  // for i
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cFinishGenFluidSprings:
 
 cFinishGenFluidSprings::cFinishGenFluidSprings(int a_Seed, BLOCKTYPE a_Fluid, cIniFile & a_IniFile, const cWorld & a_World) :
@@ -699,17 +571,9 @@ cFinishGenFluidSprings::cFinishGenFluidSprings(int a_Seed, BLOCKTYPE a_Fluid, cI
 
 
 
-void cFinishGenFluidSprings::GenFinish(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-)
+void cFinishGenFluidSprings::GenFinish(cChunkDesc & a_ChunkDesc)
 {
-	int ChanceRnd = (m_Noise.IntNoise3DInt(128 * a_ChunkX, 512, 256 * a_ChunkZ) / 13) % 100;
+	int ChanceRnd = (m_Noise.IntNoise3DInt(128 * a_ChunkDesc.GetChunkX(), 512, 256 * a_ChunkDesc.GetChunkZ()) / 13) % 100;
 	if (ChanceRnd > m_Chance)
 	{
 		// Not in this chunk
@@ -717,7 +581,7 @@ void cFinishGenFluidSprings::GenFinish(
 	}
 	
 	// Get the height at which to try:
-	int Height = m_Noise.IntNoise3DInt(128 * a_ChunkX, 512, 256 * a_ChunkZ) / 11;
+	int Height = m_Noise.IntNoise3DInt(128 * a_ChunkDesc.GetChunkX(), 1024, 256 * a_ChunkDesc.GetChunkZ()) / 11;
 	Height %= m_HeightDistribution.GetSum();
 	Height = m_HeightDistribution.MapValue(Height);
 	
@@ -729,20 +593,12 @@ void cFinishGenFluidSprings::GenFinish(
 		{
 			for (int x = 1; x < cChunkDef::Width - 1; x++)
 			{
-				switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))
+				switch (a_ChunkDesc.GetBlockType(x, y, z))
 				{
 					case E_BLOCK_NETHERRACK:
-					{
-						if (m_Fluid != E_BLOCK_LAVA)
-						{
-							// Only lava springs in the netherrack
-							continue;
-						}
-						// fallthrough:
-					}
 					case E_BLOCK_STONE:
 					{
-						if (TryPlaceSpring(a_BlockTypes, a_BlockMeta, x, y, z))
+						if (TryPlaceSpring(a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetBlockMetas(), x, y, z))
 						{
 							// Succeeded, bail out
 							return;
diff --git a/source/Generating/FinishGen.h b/source/Generating/FinishGen.h
index dde073f67..b4bf67022 100644
--- a/source/Generating/FinishGen.h
+++ b/source/Generating/FinishGen.h
@@ -28,15 +28,7 @@ class cFinishGenSnow :
 {
 protected:
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -48,15 +40,7 @@ class cFinishGenIce :
 {
 protected:
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -67,59 +51,57 @@ class cFinishGenSprinkleFoliage :
 	public cFinishGen
 {
 public:
-	cFinishGenSprinkleFoliage(int a_Seed) : m_Seed(a_Seed) {}
+	cFinishGenSprinkleFoliage(int a_Seed) : m_Noise(a_Seed), m_Seed(a_Seed) {}
 	
 protected:
-	int m_Seed;
+	cNoise m_Noise;
+	int    m_Seed;
 	
 	/// Tries to place sugarcane at the coords specified, returns true if successful
-	bool TryAddSugarcane(
-		int a_ChunkX, int a_ChunkZ,
-		int a_RelX, int a_RelY, int a_RelZ,      // relative block coords of the sugarcane's base
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta    // Block meta to read and change
-	);
+	bool TryAddSugarcane(cChunkDesc & a_ChunkDesc, int a_RelX, int a_RelY, int a_RelZ);
 	
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
 
 
 
-class cFinishGenLilypads :
+/** This class adds a single top block in random positions in the specified biome on top of specified allowed blocks.
+Used for:
+- Lilypads finisher
+- DeadBushes finisher
+*/
+class cFinishGenSingleBiomeSingleTopBlock :
 	public cFinishGen
 {
 public:
-	cFinishGenLilypads(int a_Seed) :
-		m_Noise(a_Seed)
+	cFinishGenSingleBiomeSingleTopBlock(
+		int a_Seed, BLOCKTYPE a_BlockType, EMCSBiome a_Biome, int a_Amount,
+		BLOCKTYPE a_AllowedBelow1, BLOCKTYPE a_AllowedBelow2
+	) :
+		m_Noise(a_Seed),
+		m_BlockType(a_BlockType),
+		m_Biome(a_Biome),
+		m_Amount(a_Amount),
+		m_AllowedBelow1(a_AllowedBelow1),
+		m_AllowedBelow2(a_AllowedBelow2)
 	{
 	}
 	
 protected:
 	cNoise m_Noise;
+	BLOCKTYPE m_BlockType;
+	EMCSBiome m_Biome;
+	int       m_Amount;         ///< Relative amount of blocks to try adding. 1 = one block per 256 biome columns.
+	BLOCKTYPE m_AllowedBelow1;  ///< First  of the two blocktypes that are allowed below m_BlockType
+	BLOCKTYPE m_AllowedBelow2;  ///< Second of the two blocktypes that are allowed below m_BlockType
 	
-	int GetNumLilypads(const cChunkDef::BiomeMap & a_BiomeMap);
+	int GetNumToGen(const cChunkDef::BiomeMap & a_BiomeMap);
 	
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -139,15 +121,7 @@ protected:
 	int m_Level;
 	
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -179,52 +153,13 @@ protected:
 	);
 
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
-} ;
-
-
-
-
-
-class cFinishGenDeadBushes :
-	public cFinishGen
-{
-public:
-	cFinishGenDeadBushes(int a_Seed) :
-		m_Noise(a_Seed)
-	{
-	}
-	
-protected:
-	cNoise m_Noise;
-	
-	int GetNumDeadBushes(const cChunkDef::BiomeMap & a_BiomeMap);
-	
-	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
 
 
 
-
 class cFinishGenFluidSprings :
 	public cFinishGen
 {
@@ -239,15 +174,7 @@ protected:
 	int            m_Chance;  ///< Chance, [0..100], that a spring will be generated in a chunk
 
 	// cFinishGen override:
-	virtual void GenFinish(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,   // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		const cChunkDef::BiomeMap & a_BiomeMap,  // Biomes to adhere to
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 
 	/// Tries to place a spring at the specified coords, checks neighbors. Returns true	if successful
 	bool TryPlaceSpring(
diff --git a/source/Generating/Ravines.cpp b/source/Generating/Ravines.cpp
index af53259bc..94d91c0bb 100644
--- a/source/Generating/Ravines.cpp
+++ b/source/Generating/Ravines.cpp
@@ -117,20 +117,15 @@ void cStructGenRavines::ClearCache(void)
 

 

 

-void cStructGenRavines::GenStructures(

-	int a_ChunkX, int a_ChunkZ,

-	cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-	cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-	cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-	cEntityList & a_Entities,               // Entities may be added or deleted

-	cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-)

+void cStructGenRavines::GenStructures(cChunkDesc & a_ChunkDesc)

 {

+	int ChunkX = a_ChunkDesc.GetChunkX();

+	int ChunkZ = a_ChunkDesc.GetChunkZ();

 	cRavines Ravines;

-	GetRavinesForChunk(a_ChunkX, a_ChunkZ, Ravines);

-	for (cRavines::const_iterator itr = Ravines.begin(); itr != Ravines.end(); ++itr)

+	GetRavinesForChunk(ChunkX, ChunkZ, Ravines);

+	for (cRavines::const_iterator itr = Ravines.begin(), end = Ravines.end(); itr != end; ++itr)

 	{

-		(*itr)->ProcessChunk(a_ChunkX, a_ChunkZ, a_BlockTypes, a_HeightMap);

+		(*itr)->ProcessChunk(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());

 	}  // for itr - Ravines[]

 }

 

diff --git a/source/Generating/Ravines.h b/source/Generating/Ravines.h
index 79db697d0..1c559c70d 100644
--- a/source/Generating/Ravines.h
+++ b/source/Generating/Ravines.h
@@ -38,14 +38,7 @@ protected:
 	void GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cRavines & a_Ravines);

 	

 	// cStructureGen override:

-	virtual void GenStructures(

-		int a_ChunkX, int a_ChunkZ,

-		cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change

-		cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change

-		cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data

-		cEntityList & a_Entities,               // Entities may be added or deleted

-		cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted

-	) override;

+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

 } ;

 

 

diff --git a/source/Generating/StructGen.cpp b/source/Generating/StructGen.cpp
index b0828f15a..6d139da2a 100644
--- a/source/Generating/StructGen.cpp
+++ b/source/Generating/StructGen.cpp
@@ -70,68 +70,62 @@ static bool SortTreeBlocks(const sSetBlock & a_First, const sSetBlock & a_Second
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenTrees:
 
-void cStructGenTrees::GenStructures(
-	int a_ChunkX, int a_ChunkZ, 
-	cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMetas,  // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-	cEntityList & a_Entities,                // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-)
+void cStructGenTrees::GenStructures(cChunkDesc & a_ChunkDesc)
 {
-	cChunkDef::BlockTypes   WorkerBlockTypes;
-	cChunkDef::BlockNibbles WorkerBlockMeta;
-	cChunkDef::HeightMap    WorkerHeight;
-
-	cEntityList Entities;
-	cBlockEntityList BlockEntities;
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	
+	cChunkDesc WorkerDesc(ChunkX, ChunkZ);
 	
 	// Generate trees:
 	for (int x = 0; x <= 2; x++)
 	{
-		int BaseX = a_ChunkX + x - 1;
+		int BaseX = ChunkX + x - 1;
 		for (int z = 0; z <= 2; z++)
 		{
-			int BaseZ = a_ChunkZ + z - 1;
+			int BaseZ = ChunkZ + z - 1;
 			
 			cChunkDef::BlockTypes *   BlT;
 			cChunkDef::BlockNibbles * BlM;
 			cChunkDef::HeightMap *    Hei;
-			
-			cChunkDef::BiomeMap Biomes;
-			m_BiomeGen->GenBiomes(BaseX, BaseZ, Biomes);
+			cChunkDef::BiomeMap *     Bio;
+
 
 			if ((x != 1) || (z != 1))
 			{
-				BlT = &WorkerBlockTypes;
-				BlM = &WorkerBlockMeta;
-				Hei = &WorkerHeight;
+				BlT = &(WorkerDesc.GetBlockTypes());
+				BlM = &(WorkerDesc.GetBlockMetas());
+				Hei = &(WorkerDesc.GetHeightMap());
+				Bio = &(WorkerDesc.GetBiomeMap());
+				WorkerDesc.SetChunkCoords(BaseX, BaseZ);
 				
-				m_HeightGen->GenHeightMap       (BaseX, BaseZ, *Hei);
-				m_CompositionGen->ComposeTerrain(BaseX, BaseZ, *BlT, *BlM, *Hei, Biomes, Entities, BlockEntities);
+				m_BiomeGen->GenBiomes           (BaseX, BaseZ, WorkerDesc.GetBiomeMap());
+				m_HeightGen->GenHeightMap       (BaseX, BaseZ, WorkerDesc.GetHeightMap());
+				m_CompositionGen->ComposeTerrain(WorkerDesc);
 				// TODO: Free the entity lists
 			}
 			else
 			{
-				BlT = &a_BlockTypes;
-				BlM = &a_BlockMetas;
-				Hei = &a_HeightMap;
+				BlT = &(a_ChunkDesc.GetBlockTypes());
+				BlM = &(a_ChunkDesc.GetBlockMetas());
+				Hei = &(a_ChunkDesc.GetHeightMap());
+				Bio = &(a_ChunkDesc.GetBiomeMap());
 			}
 
-			int NumTrees = GetNumTrees(BaseX, BaseZ, Biomes);
+			int NumTrees = GetNumTrees(BaseX, BaseZ, *Bio);
 
 			sSetBlockVector OutsideLogs, OutsideOther;
 			for (int i = 0; i < NumTrees; i++)
 			{
-				GenerateSingleTree(BaseX, BaseZ, i, *BlT, *BlM, *Hei, Biomes, OutsideLogs, OutsideOther);
+				GenerateSingleTree(BaseX, BaseZ, i, *BlT, *BlM, *Hei, *Bio, OutsideLogs, OutsideOther);
 			}
 
 			sSetBlockVector IgnoredOverflow;
 			IgnoredOverflow.reserve(OutsideOther.size());
-			ApplyTreeImage(a_ChunkX, a_ChunkZ, a_BlockTypes, a_BlockMetas, OutsideOther, IgnoredOverflow);
+			ApplyTreeImage(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetBlockMetas(), OutsideOther, IgnoredOverflow);
 			IgnoredOverflow.clear();
 			IgnoredOverflow.reserve(OutsideLogs.size());
-			ApplyTreeImage(a_ChunkX, a_ChunkZ, a_BlockTypes, a_BlockMetas, OutsideLogs, IgnoredOverflow);
+			ApplyTreeImage(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetBlockMetas(), OutsideLogs, IgnoredOverflow);
 		}  // for z
 	}  // for x
 	
@@ -142,9 +136,9 @@ void cStructGenTrees::GenStructures(
 		{
 			for (int y = cChunkDef::Height - 1; y >= 0; y--)
 			{
-				if (cChunkDef::GetBlock(a_BlockTypes, x, y, z) != E_BLOCK_AIR)
+				if (cChunkDef::GetBlock(a_ChunkDesc.GetBlockTypes(), x, y, z) != E_BLOCK_AIR)
 				{
-					cChunkDef::SetHeight(a_HeightMap, x, z, y);
+					cChunkDef::SetHeight(a_ChunkDesc.GetHeightMap(), x, z, y);
 					break;
 				}
 			}  // for y
@@ -306,23 +300,19 @@ int cStructGenTrees::GetNumTrees(
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenOreNests:
 
-void cStructGenOreNests::GenStructures(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change
-	cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change
-	cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data
-	cEntityList & a_Entities,               // Entities may be added or deleted
-	cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted
-)
+void cStructGenOreNests::GenStructures(cChunkDesc & a_ChunkDesc)
 {
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_COAL_ORE,     MAX_HEIGHT_COAL,     NUM_NESTS_COAL,     NEST_SIZE_COAL,     a_BlockTypes, 1);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_IRON_ORE,     MAX_HEIGHT_IRON,     NUM_NESTS_IRON,     NEST_SIZE_IRON,     a_BlockTypes, 2);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_REDSTONE_ORE, MAX_HEIGHT_REDSTONE, NUM_NESTS_REDSTONE, NEST_SIZE_REDSTONE, a_BlockTypes, 3);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_GOLD_ORE,     MAX_HEIGHT_GOLD,     NUM_NESTS_GOLD,     NEST_SIZE_GOLD,     a_BlockTypes, 4);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_DIAMOND_ORE,  MAX_HEIGHT_DIAMOND,  NUM_NESTS_DIAMOND,  NEST_SIZE_DIAMOND,  a_BlockTypes, 5);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_LAPIS_ORE,    MAX_HEIGHT_LAPIS,    NUM_NESTS_LAPIS,    NEST_SIZE_LAPIS,    a_BlockTypes, 6);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_DIRT,         MAX_HEIGHT_DIRT,     NUM_NESTS_DIRT,     NEST_SIZE_DIRT,     a_BlockTypes, 10);
-	GenerateOre(a_ChunkX, a_ChunkZ, E_BLOCK_GRAVEL,       MAX_HEIGHT_GRAVEL,   NUM_NESTS_GRAVEL,   NEST_SIZE_GRAVEL,   a_BlockTypes, 11);
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cChunkDef::BlockTypes & BlockTypes = a_ChunkDesc.GetBlockTypes();
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_COAL_ORE,     MAX_HEIGHT_COAL,     NUM_NESTS_COAL,     NEST_SIZE_COAL,     BlockTypes, 1);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_IRON_ORE,     MAX_HEIGHT_IRON,     NUM_NESTS_IRON,     NEST_SIZE_IRON,     BlockTypes, 2);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_REDSTONE_ORE, MAX_HEIGHT_REDSTONE, NUM_NESTS_REDSTONE, NEST_SIZE_REDSTONE, BlockTypes, 3);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_GOLD_ORE,     MAX_HEIGHT_GOLD,     NUM_NESTS_GOLD,     NEST_SIZE_GOLD,     BlockTypes, 4);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_DIAMOND_ORE,  MAX_HEIGHT_DIAMOND,  NUM_NESTS_DIAMOND,  NEST_SIZE_DIAMOND,  BlockTypes, 5);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_LAPIS_ORE,    MAX_HEIGHT_LAPIS,    NUM_NESTS_LAPIS,    NEST_SIZE_LAPIS,    BlockTypes, 6);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_DIRT,         MAX_HEIGHT_DIRT,     NUM_NESTS_DIRT,     NEST_SIZE_DIRT,     BlockTypes, 10);
+	GenerateOre(ChunkX, ChunkZ, E_BLOCK_GRAVEL,       MAX_HEIGHT_GRAVEL,   NUM_NESTS_GRAVEL,   NEST_SIZE_GRAVEL,   BlockTypes, 11);
 }
 
 
diff --git a/source/Generating/StructGen.h b/source/Generating/StructGen.h
index 1b2941649..c627499e2 100644
--- a/source/Generating/StructGen.h
+++ b/source/Generating/StructGen.h
@@ -69,14 +69,7 @@ protected:
 	);
 	
 	// cStructureGen override:
-	virtual void GenStructures(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,    // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMetas,  // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,      // Height map to read and change by the current data
-		cEntityList & a_Entities,                // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities       // Block entities may be added or deleted
-	) override;
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -94,14 +87,7 @@ protected:
 	int    m_Seed;
 	
 	// cStructureGen override:
-	virtual void GenStructures(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,   // Block types to read and change
-		cChunkDef::BlockNibbles & a_BlockMeta,  // Block meta to read and change
-		cChunkDef::HeightMap & a_HeightMap,     // Height map to read and change by the current data
-		cEntityList & a_Entities,               // Entities may be added or deleted
-		cBlockEntityList & a_BlockEntities      // Block entities may be added or deleted
-	) override;
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
 	
 	void GenerateOre(int a_ChunkX, int a_ChunkZ, BLOCKTYPE a_OreType, int a_MaxHeight, int a_NumNests, int a_NestSize, cChunkDef::BlockTypes & a_BlockTypes, int a_Seq);
 } ;
@@ -110,3 +96,22 @@ protected:
 
 
 
+class cStructGenLakes :
+	public cStructureGen
+{
+public:
+	cStructGenLakes(int a_Seed, BLOCKTYPE a_Fluid) : m_Noise(a_Seed), m_Seed(a_Seed), m_Fluid(a_Fluid) {}
+	
+protected:
+	cNoise    m_Noise;
+	int       m_Seed;
+	BLOCKTYPE m_Fluid;
+	
+	// cStructureGen override:
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
+