15 files changed, 5904 insertions, 5904 deletions

diff --git a/source/Generating/Caves.cpp b/source/Generating/Caves.cpp
index 2bfef8054..4221ea187 100644
--- a/source/Generating/Caves.cpp
+++ b/source/Generating/Caves.cpp
@@ -1,970 +1,970 @@
-

-// Caves.cpp

-

-// Implements the various cave structure generators:

-//   - cStructGenWormNestCaves

-//   - cStructGenDualRidgeCaves

-//   - cStructGenMarbleCaves

-//   - cStructGenNetherCaves

-

-/*

-WormNestCave generator:

-Caves are generated in "nests" - groups of tunnels generated from a single point.

-For each chunk, all the nests that could intersect it are generated.

-For each nest, first the schematic structure is generated (tunnel from ... to ..., branch, tunnel2 from ... to ...)

-Then each tunnel is randomized by inserting points in between its ends.

-Finally each tunnel is smoothed and Bresenham-3D-ed so that it is a collection of spheres with their centers next to each other.

-When the tunnels are ready, they are simply carved into the chunk, one by one.

-To optimize, each tunnel keeps track of its bounding box, so that it can be skipped for chunks that don't intersect it.

-

-MarbleCaves generator:

-For each voxel a 3D noise function is evaluated, if the value crosses a boundary, the voxel is dug out, otherwise it is kept.

-Problem with this is the amount of CPU work needed for each chunk.

-Also the overall shape of the generated holes is unsatisfactory - there are whole "sheets" of holes in the ground.

-

-DualRidgeCaves generator:

-Instead of evaluating a single noise function, two different noise functions are multiplied. This produces

-regular tunnels instead of sheets. However due to the sheer amount of CPU work needed, the noise functions need to be

-reduced in complexity in order for this generator to be useful, so the caves' shapes are "bubbly" at best.

-*/

-

-#include "Globals.h"

-#include "Caves.h"

-

-

-

-

-

-/// How many nests in each direction are generated for a given chunk. Must be an even number

-#define NEIGHBORHOOD_SIZE 8

-

-

-

-

-

-const int MIN_RADIUS = 3;

-const int MAX_RADIUS = 8;

-

-

-

-

-

-struct cCaveDefPoint

-{

-	int m_BlockX;

-	int m_BlockY;

-	int m_BlockZ;

-	int m_Radius;

-	

-	cCaveDefPoint(int a_BlockX, int a_BlockY, int a_BlockZ, int a_Radius) :

-		m_BlockX(a_BlockX),

-		m_BlockY(a_BlockY),

-		m_BlockZ(a_BlockZ),

-		m_Radius(a_Radius)

-	{

-	}

-} ;

-

-typedef std::vector<cCaveDefPoint> cCaveDefPoints;

-

-

-

-

-

-/// A single non-branching tunnel of a WormNestCave

-class cCaveTunnel

-{

-	// The bounding box, including the radii around defpoints:

-	int m_MinBlockX, m_MaxBlockX;

-	int m_MinBlockY, m_MaxBlockY;

-	int m_MinBlockZ, m_MaxBlockZ;

-	

-	/// Generates the shaping defpoints for the ravine, based on the ravine block coords and noise

-	void Randomize(cNoise & a_Noise);

-	

-	/// Refines (adds and smooths) defpoints from a_Src into a_Dst; returns false if no refinement possible (segments too short)

-	bool RefineDefPoints(const cCaveDefPoints & a_Src, cCaveDefPoints & a_Dst);

-	

-	/// Does rounds of smoothing, two passes of RefineDefPoints(), as long as they return true

-	void Smooth(void);

-	

-	/// Linearly interpolates the points so that the maximum distance between two neighbors is max 1 block

-	void FinishLinear(void);

-	

-	/// Calculates the bounding box of the points present

-	void CalcBoundingBox(void);

-	

-public:

-	cCaveDefPoints m_Points;

-

-	cCaveTunnel(

-		int a_BlockStartX, int a_BlockStartY, int a_BlockStartZ, int a_StartRadius,

-		int a_BlockEndX,   int a_BlockEndY,   int a_BlockEndZ,   int a_EndRadius,

-		cNoise & a_Noise

-	);

-	

-	/// Carves the tunnel into the chunk specified

-	void ProcessChunk(

-		int a_ChunkX, int a_ChunkZ, 

-		cChunkDef::BlockTypes & a_BlockTypes, 

-		cChunkDef::HeightMap & a_HeightMap

-	);

-	

-	#ifdef _DEBUG

-	AString ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const;

-	#endif  // _DEBUG

-} ;

-

-typedef std::vector<cCaveTunnel *> cCaveTunnels;

-

-

-

-

-

-/// A collection of connected tunnels, possibly branching.

-class cStructGenWormNestCaves::cCaveSystem

-{

-public:

-	// The generating block position; is read directly in cStructGenWormNestCaves::GetCavesForChunk()

-	int m_BlockX;

-	int m_BlockZ;

-	

-	cCaveSystem(int a_BlockX, int a_BlockZ, int a_MaxOffset, int a_Size, cNoise & a_Noise);

-	~cCaveSystem();

-	

-	/// Carves the cave system into the chunk specified

-	void ProcessChunk(

-		int a_ChunkX, int a_ChunkZ, 

-		cChunkDef::BlockTypes & a_BlockTypes, 

-		cChunkDef::HeightMap & a_HeightMap

-	);

-	

-	#ifdef _DEBUG

-	AString ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const;

-	#endif  // _DEBUG

-

-protected:

-	int m_Size;

-	cCaveTunnels m_Tunnels;

-	

-	void Clear(void);

-

-	/// Generates a_Segment successive tunnels, with possible branches. Generates the same output for the same [x, y, z, a_Segments]

-	void GenerateTunnelsFromPoint(

-		int a_OriginX, int a_OriginY, int a_OriginZ, 

-		cNoise & a_Noise, int a_Segments

-	);

-	

-	/// Returns a radius based on the location provided.

-	int GetRadius(cNoise & a_Noise, int a_OriginX, int a_OriginY, int a_OriginZ);

-} ;

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cCaveTunnel:

-

-cCaveTunnel::cCaveTunnel(

-	int a_BlockStartX, int a_BlockStartY, int a_BlockStartZ, int a_StartRadius,

-	int a_BlockEndX,   int a_BlockEndY,   int a_BlockEndZ,   int a_EndRadius,

-	cNoise & a_Noise

-)

-{

-	m_Points.push_back(cCaveDefPoint(a_BlockStartX, a_BlockStartY, a_BlockStartZ, a_StartRadius));

-	m_Points.push_back(cCaveDefPoint(a_BlockEndX,   a_BlockEndY,   a_BlockEndZ,   a_EndRadius));

-	

-	if ((a_BlockStartY <= 0) && (a_BlockEndY <= 0))

-	{

-		// Don't bother detailing this cave, it's under the world anyway

-		return;

-	}

-	

-	Randomize(a_Noise);

-	Smooth();

-	

-	// We know that the linear finishing won't affect the bounding box, so let's calculate it now, as we have less data:

-	CalcBoundingBox();

-	

-	FinishLinear();

-}

-

-

-

-

-

-void cCaveTunnel::Randomize(cNoise & a_Noise)

-{

-	// Repeat 4 times:

-	for (int i = 0; i < 4; i++)

-	{

-		// For each already present point, insert a point in between it and its predecessor, shifted randomly.

-		int PrevX = m_Points.front().m_BlockX;

-		int PrevY = m_Points.front().m_BlockY;

-		int PrevZ = m_Points.front().m_BlockZ;

-		int PrevR = m_Points.front().m_Radius;

-		cCaveDefPoints Pts;

-		Pts.reserve(m_Points.size() * 2 + 1);

-		Pts.push_back(m_Points.front());

-		for (cCaveDefPoints::const_iterator itr = m_Points.begin() + 1, end = m_Points.end(); itr != end; ++itr)

-		{

-			int Random = a_Noise.IntNoise3DInt(PrevX, PrevY, PrevZ + i) / 11;

-			int len = (PrevX - itr->m_BlockX) * (PrevX - itr->m_BlockX);

-			len += (PrevY - itr->m_BlockY) * (PrevY - itr->m_BlockY);

-			len += (PrevZ - itr->m_BlockZ) * (PrevZ - itr->m_BlockZ);

-			len = 3 * (int)sqrt((double)len) / 4;

-			int Rad = std::min(MAX_RADIUS, std::max(MIN_RADIUS, (PrevR + itr->m_Radius) / 2 + (Random % 3) - 1));

-			Random /= 4;

-			int x = (itr->m_BlockX + PrevX) / 2 + (Random % (len + 1) - len / 2);

-			Random /= 256;

-			int y = (itr->m_BlockY + PrevY) / 2 + (Random % (len / 2 + 1) - len / 4);

-			Random /= 256;

-			int z = (itr->m_BlockZ + PrevZ) / 2 + (Random % (len + 1) - len / 2);

-			Pts.push_back(cCaveDefPoint(x, y, z, Rad));

-			Pts.push_back(*itr);

-			PrevX = itr->m_BlockX;

-			PrevY = itr->m_BlockY;

-			PrevZ = itr->m_BlockZ;

-			PrevR = itr->m_Radius;

-		}

-		std::swap(Pts, m_Points);

-	}

-}

-

-

-

-

-

-bool cCaveTunnel::RefineDefPoints(const cCaveDefPoints & a_Src, cCaveDefPoints & a_Dst)

-{

-	// Smoothing: for each line segment, add points on its 1/4 lengths

-	bool res = false;

-	int Num = a_Src.size() - 2;  // this many intermediary points

-	a_Dst.clear();

-	a_Dst.reserve(Num * 2 + 2);

-	cCaveDefPoints::const_iterator itr = a_Src.begin() + 1;

-	a_Dst.push_back(a_Src.front());

-	int PrevX = a_Src.front().m_BlockX;

-	int PrevY = a_Src.front().m_BlockY;

-	int PrevZ = a_Src.front().m_BlockZ;

-	int PrevR = a_Src.front().m_Radius;

-	for (int i = 0; i <= Num; ++i, ++itr)

-	{

-		int dx = itr->m_BlockX - PrevX;

-		int dy = itr->m_BlockY - PrevY;

-		int dz = itr->m_BlockZ - PrevZ;

-		if (abs(dx) + abs(dz) + abs(dy) < 6)

-		{

-			// Too short a segment to smooth-subdivide into quarters

-			PrevX = itr->m_BlockX;

-			PrevY = itr->m_BlockY;

-			PrevZ = itr->m_BlockZ;

-			PrevR = itr->m_Radius;

-			continue;

-		}

-		int dr = itr->m_Radius - PrevR;

-		int Rad1 = std::max(PrevR + 1 * dr / 4, 1);

-		int Rad2 = std::max(PrevR + 3 * dr / 4, 1);

-		a_Dst.push_back(cCaveDefPoint(PrevX + 1 * dx / 4, PrevY + 1 * dy / 4, PrevZ + 1 * dz / 4, Rad1));

-		a_Dst.push_back(cCaveDefPoint(PrevX + 3 * dx / 4, PrevY + 3 * dy / 4, PrevZ + 3 * dz / 4, Rad2));

-		PrevX = itr->m_BlockX;

-		PrevY = itr->m_BlockY;

-		PrevZ = itr->m_BlockZ;

-		PrevR = itr->m_Radius;

-		res = true;

-	}

-	a_Dst.push_back(a_Src.back());

-	return res && (a_Src.size() < a_Dst.size());

-}

-

-

-

-

-

-void cCaveTunnel::Smooth(void)

-{

-	cCaveDefPoints Pts;

-	while (true)

-	{

-		if (!RefineDefPoints(m_Points, Pts))

-		{

-			std::swap(Pts, m_Points);

-			return;

-		}

-		if (!RefineDefPoints(Pts, m_Points))

-		{

-			return;

-		}

-	}

-}

-

-

-

-

-

-void cCaveTunnel::FinishLinear(void)

-{

-	// For each segment, use Bresenham's 3D line algorithm to draw a "line" of defpoints

-	cCaveDefPoints Pts;

-	std::swap(Pts, m_Points);

-	

-	m_Points.reserve(Pts.size() * 3);

-	int PrevX = Pts.front().m_BlockX;

-	int PrevY = Pts.front().m_BlockY;

-	int PrevZ = Pts.front().m_BlockZ;

-	for (cCaveDefPoints::const_iterator itr = Pts.begin() + 1, end = Pts.end(); itr != end; ++itr)

-	{

-		int x1 = itr->m_BlockX;

-		int y1 = itr->m_BlockY;

-		int z1 = itr->m_BlockZ;

-		int dx = abs(x1 - PrevX);

-		int dy = abs(y1 - PrevY);

-		int dz = abs(z1 - PrevZ);

-		int sx = (PrevX < x1) ? 1 : -1;

-		int sy = (PrevY < y1) ? 1 : -1;

-		int sz = (PrevZ < z1) ? 1 : -1;

-		int err = dx - dz;

-		int R = itr->m_Radius;

-

-		if (dx >= std::max(dy, dz))  // x dominant

-		{

-			int yd = dy - dx / 2;

-			int zd = dz - dx / 2;

-

-			while (true)

-			{

-				m_Points.push_back(cCaveDefPoint(PrevX, PrevY, PrevZ, R));

-

-				if (PrevX == x1)

-				{

-					break;

-				}

-

-				if (yd >= 0)  // move along y

-				{

-					PrevY += sy;

-					yd -= dx;

-				}

-

-				if (zd >= 0)  // move along z

-				{

-					PrevZ += sz;

-					zd -= dx;

-				}

-

-				// move along x

-				PrevX  += sx;

-				yd += dy;

-				zd += dz;

-			}

-		}

-		else if (dy >= std::max(dx, dz))  // y dominant

-		{

-			int xd = dx - dy / 2;

-			int zd = dz - dy / 2;

-

-			while (true)

-			{

-				m_Points.push_back(cCaveDefPoint(PrevX, PrevY, PrevZ, R));

-

-				if (PrevY == y1)

-				{

-					break;

-				}

-

-				if (xd >= 0)  // move along x

-				{

-					PrevX += sx;

-					xd -= dy;

-				}

-

-				if (zd >= 0)  // move along z

-				{

-					PrevZ += sz;

-					zd -= dy;

-				}

-

-				// move along y

-				PrevY += sy;

-				xd += dx;

-				zd += dz;

-			}

-		}

-		else

-		{

-			// z dominant

-			ASSERT(dz >= std::max(dx, dy));

-			int xd = dx - dz / 2;

-			int yd = dy - dz / 2;

-

-			while (true)

-			{

-				m_Points.push_back(cCaveDefPoint(PrevX, PrevY, PrevZ, R));

-

-				if (PrevZ == z1)

-				{

-					break;

-				}

-

-				if (xd >= 0)  // move along x

-				{

-					PrevX += sx;

-					xd -= dz;

-				}

-

-				if (yd >= 0)  // move along y

-				{

-					PrevY += sy;

-					yd -= dz;

-				}

-				

-				// move along z

-				PrevZ += sz;

-				xd += dx;

-				yd += dy;

-			}

-		}  // if (which dimension is dominant)

-	}  // for itr

-}

-

-

-

-

-

-void cCaveTunnel::CalcBoundingBox(void)

-{

-	m_MinBlockX = m_MaxBlockX = m_Points.front().m_BlockX;

-	m_MinBlockY = m_MaxBlockY = m_Points.front().m_BlockY;

-	m_MinBlockZ = m_MaxBlockZ = m_Points.front().m_BlockZ;

-	for (cCaveDefPoints::const_iterator itr = m_Points.begin() + 1, end = m_Points.end(); itr != end; ++itr)

-	{

-		m_MinBlockX = std::min(m_MinBlockX, itr->m_BlockX - itr->m_Radius);

-		m_MaxBlockX = std::max(m_MaxBlockX, itr->m_BlockX + itr->m_Radius);

-		m_MinBlockY = std::min(m_MinBlockY, itr->m_BlockY - itr->m_Radius);

-		m_MaxBlockY = std::max(m_MaxBlockY, itr->m_BlockY + itr->m_Radius);

-		m_MinBlockZ = std::min(m_MinBlockZ, itr->m_BlockZ - itr->m_Radius);

-		m_MaxBlockZ = std::max(m_MaxBlockZ, itr->m_BlockZ + itr->m_Radius);

-	}  // for itr - m_Points[]

-}

-

-

-

-

-

-void cCaveTunnel::ProcessChunk(

-	int a_ChunkX, int a_ChunkZ, 

-	cChunkDef::BlockTypes & a_BlockTypes, 

-	cChunkDef::HeightMap & a_HeightMap

-)

-{

-	int BaseX = a_ChunkX * cChunkDef::Width;

-	int BaseZ = a_ChunkZ * cChunkDef::Width;

-	if (

-		(BaseX > m_MaxBlockX) || (BaseX + cChunkDef::Width < m_MinBlockX) ||

-		(BaseX > m_MaxBlockX) || (BaseX + cChunkDef::Width < m_MinBlockX)

-	)

-	{

-		// Tunnel does not intersect the chunk at all, bail out

-		return;

-	}

-

-	int BlockStartX = a_ChunkX * cChunkDef::Width;

-	int BlockStartZ = a_ChunkZ * cChunkDef::Width;

-	int BlockEndX = BlockStartX + cChunkDef::Width;

-	int BlockEndZ = BlockStartZ + cChunkDef::Width;

-	for (cCaveDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)

-	{

-		if (

-			(itr->m_BlockX + itr->m_Radius < BlockStartX) ||

-			(itr->m_BlockX - itr->m_Radius > BlockEndX) ||

-			(itr->m_BlockZ + itr->m_Radius < BlockStartZ) ||

-			(itr->m_BlockZ - itr->m_Radius > BlockEndZ)

-		)

-		{

-			// Cannot intersect, bail out early

-			continue;

-		}

-		

-		// Carve out a sphere around the xyz point, m_Radius in diameter; skip 3/7 off the top and bottom:

-		int DifX = itr->m_BlockX - BlockStartX;  // substitution for faster calc

-		int DifY = itr->m_BlockY;

-		int DifZ = itr->m_BlockZ - BlockStartZ;  // substitution for faster calc

-		int Bottom = std::max(itr->m_BlockY - 3 * itr->m_Radius / 7, 1);

-		int Top    = std::min(itr->m_BlockY + 3 * itr->m_Radius / 7, (int)(cChunkDef::Height));

-		int SqRad  = itr->m_Radius * itr->m_Radius;

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

-		{

-			for (int y = Bottom; y <= Top; y++)

-			{

-				int SqDist = (DifX - x) * (DifX - x) + (DifY - y) * (DifY - y) + (DifZ - z) * (DifZ - z);

-				if (4 * SqDist <= SqRad)

-				{

-					switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))

-					{

-						// Only carve out these specific block types

-						case E_BLOCK_DIRT:

-						case E_BLOCK_GRASS:

-						case E_BLOCK_STONE:

-						case E_BLOCK_COBBLESTONE:

-						case E_BLOCK_GRAVEL:

-						case E_BLOCK_SAND:

-						case E_BLOCK_SANDSTONE:

-						case E_BLOCK_NETHERRACK:

-						case E_BLOCK_COAL_ORE:

-						case E_BLOCK_IRON_ORE:

-						case E_BLOCK_GOLD_ORE:

-						case E_BLOCK_DIAMOND_ORE:

-						case E_BLOCK_REDSTONE_ORE:

-						case E_BLOCK_REDSTONE_ORE_GLOWING:

-						{

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

-							break;

-						}

-						default: break;

-					}

-				}

-			}  // for y

-		}  // for x, z

-	}  // for itr - m_Points[]

-	

-	/*

-	#ifdef _DEBUG		

-	// For debugging purposes, outline the shape of the cave using glowstone, *after* carving the entire cave:

-	for (cCaveDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)

-	{

-		int DifX = itr->m_BlockX - BlockStartX;  // substitution for faster calc

-		int DifZ = itr->m_BlockZ - BlockStartZ;  // substitution for faster calc

-		if (

-			(DifX >= 0) && (DifX < cChunkDef::Width) &&

-			(itr->m_BlockY > 0) && (itr->m_BlockY < cChunkDef::Height) &&

-			(DifZ >= 0) && (DifZ < cChunkDef::Width)

-		)

-		{

-			cChunkDef::SetBlock(a_BlockTypes, DifX, itr->m_BlockY, DifZ, E_BLOCK_GLOWSTONE);

-		}

-	}  // for itr - m_Points[]

-	#endif  // _DEBUG

-	//*/

-}

-

-

-

-

-

-#ifdef _DEBUG

-AString cCaveTunnel::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const

-{

-	AString SVG;

-	SVG.reserve(m_Points.size() * 20 + 200);

-  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#%06x;stroke-width:1px;\"\nd=\"", a_Color);

-  char Prefix = 'M';  // The first point needs "M" prefix, all the others need "L"

-  for (cCaveDefPoints::const_iterator itr = m_Points.begin(); itr != m_Points.end(); ++itr)

-  {

-		AppendPrintf(SVG, "%c %d,%d ", Prefix, a_OffsetX + itr->m_BlockX, a_OffsetZ + itr->m_BlockZ);

-		Prefix = 'L';

-  }

-  SVG.append("\"/>\n");

-	return SVG;

-}

-#endif  // _DEBUG

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenWormNestCaves::cCaveSystem:

-

-cStructGenWormNestCaves::cCaveSystem::cCaveSystem(int a_BlockX, int a_BlockZ, int a_MaxOffset, int a_Size, cNoise & a_Noise) :

-	m_BlockX(a_BlockX),

-	m_BlockZ(a_BlockZ),

-	m_Size(a_Size)

-{

-	int Num = 1 + a_Noise.IntNoise2DInt(a_BlockX, a_BlockZ) % 3;

-	for (int i = 0; i < Num; i++)

-	{

-		int OriginX = a_BlockX + (a_Noise.IntNoise3DInt(13 * a_BlockX, 17 * a_BlockZ, 11 * i) / 19) % a_MaxOffset;

-		int OriginZ = a_BlockZ + (a_Noise.IntNoise3DInt(17 * a_BlockX, 13 * a_BlockZ, 11 * i) / 23) % a_MaxOffset;

-		int OriginY  = 20 + (a_Noise.IntNoise3DInt(19 * a_BlockX, 13 * a_BlockZ, 11 * i) / 17) % 20;

-		

-		// Generate three branches from the origin point:

-		// The tunnels generated depend on X, Y, Z and Branches,

-		// for the same set of numbers it generates the same offsets!

-		// That's why we add a +1 to X in the third line

-		GenerateTunnelsFromPoint(OriginX,     OriginY, OriginZ, a_Noise, 3);

-		GenerateTunnelsFromPoint(OriginX,     OriginY, OriginZ, a_Noise, 2);

-		GenerateTunnelsFromPoint(OriginX + 1, OriginY, OriginZ, a_Noise, 3);

-	}

-}

-

-

-

-

-

-cStructGenWormNestCaves::cCaveSystem::~cCaveSystem()

-{

-	Clear();

-}

-

-

-

-

-

-

-void cStructGenWormNestCaves::cCaveSystem::ProcessChunk(

-	int a_ChunkX, int a_ChunkZ, 

-	cChunkDef::BlockTypes & a_BlockTypes, 

-	cChunkDef::HeightMap & a_HeightMap

-)

-{

-	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)

-	{

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

-	}  // for itr - m_Tunnels[]

-}

-

-

-

-

-

-#ifdef _DEBUG

-AString cStructGenWormNestCaves::cCaveSystem::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const

-{

-	AString SVG;

-	SVG.reserve(512 * 1024);

-	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)

-	{

-		SVG.append((*itr)->ExportAsSVG(a_Color, a_OffsetX, a_OffsetZ));

-	}  // for itr - m_Tunnels[]

-

-	// Base point highlight:

-	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",

-		a_OffsetX + m_BlockX - 5, a_OffsetZ + m_BlockZ, a_OffsetX + m_BlockX + 5, a_OffsetZ + m_BlockZ

-	);

-	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",

-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ - 5, a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ + 5

-	);

-	

-	// A gray line from the base point to the first point of the ravine, for identification:

-	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#cfcfcf;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",

-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ, 

-		a_OffsetX + m_Tunnels.front()->m_Points.front().m_BlockX, 

-		a_OffsetZ + m_Tunnels.front()->m_Points.front().m_BlockZ

-	);

-	

-	// Offset guides:

-	if (a_OffsetX > 0)

-	{

-		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M %d,0 L %d,1024\"/>\n",

-			a_OffsetX, a_OffsetX

-		);

-	}

-	if (a_OffsetZ > 0)

-	{

-		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M 0,%d L 1024,%d\"/>\n",

-			a_OffsetZ, a_OffsetZ

-		);

-	}

-	

-	return SVG;

-}

-#endif  // _DEBUG

-

-

-

-

-

-void cStructGenWormNestCaves::cCaveSystem::Clear(void)

-{

-	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)

-	{

-		delete *itr;

-	}

-	m_Tunnels.clear();

-}

-

-

-

-

-

-void cStructGenWormNestCaves::cCaveSystem::GenerateTunnelsFromPoint(

-	int a_OriginX, int a_OriginY, int a_OriginZ, 

-	cNoise & a_Noise, int a_NumSegments

-)

-{

-	int DoubleSize = m_Size * 2;

-	int Radius = GetRadius(a_Noise, a_OriginX + a_OriginY, a_OriginY + a_OriginZ, a_OriginZ + a_OriginX);

-	for (int i = a_NumSegments - 1; i >= 0; --i)

-	{

-		int EndX = a_OriginX + (((a_Noise.IntNoise3DInt(a_OriginX, a_OriginY, a_OriginZ + 11 * a_NumSegments) / 7) % DoubleSize) - m_Size) / 2;

-		int EndY = a_OriginY + (((a_Noise.IntNoise3DInt(a_OriginY, 13 * a_NumSegments, a_OriginZ + a_OriginX) / 7) % DoubleSize) - m_Size) / 4;

-		int EndZ = a_OriginZ + (((a_Noise.IntNoise3DInt(a_OriginZ + 17 * a_NumSegments, a_OriginX, a_OriginY) / 7) % DoubleSize) - m_Size) / 2;

-		int EndR = GetRadius(a_Noise, a_OriginX + 7 * i, a_OriginY + 11 * i, a_OriginZ + a_OriginX);

-		m_Tunnels.push_back(new cCaveTunnel(a_OriginX, a_OriginY, a_OriginZ, Radius, EndX, EndY, EndZ, EndR, a_Noise));

-		GenerateTunnelsFromPoint(EndX, EndY, EndZ, a_Noise, i);

-		a_OriginX = EndX;

-		a_OriginY = EndY;

-		a_OriginZ = EndZ;

-		Radius = EndR;

-	}  // for i - a_NumSegments

-}

-

-

-

-

-

-int cStructGenWormNestCaves::cCaveSystem::GetRadius(cNoise & a_Noise, int a_OriginX, int a_OriginY, int a_OriginZ)

-{

-	// Instead of a flat distribution noise function, we need to shape it, so that most caves are smallish and only a few select are large

-	int rnd = a_Noise.IntNoise3DInt(a_OriginX, a_OriginY, a_OriginZ) / 11;

-	/*

-	// Not good enough:

-	// The algorithm of choice: emulate gauss-distribution noise by adding 3 flat noises, then fold it in half using absolute value.

-	// To save on processing, use one random value and extract 3 bytes to be separately added as the gaussian noise

-	int sum = (rnd & 0xff) + ((rnd >> 8) & 0xff) + ((rnd >> 16) & 0xff);

-	// sum is now a gaussian-distribution noise within [0 .. 767], with center at 384.

-	// We want mapping 384 -> 3, 0 -> 19, 768 -> 19, so divide by 24 to get [0 .. 31] with center at 16, then use abs() to fold around the center

-	int res = 3 + abs((sum / 24) - 16);

-	*/

-	

-	// Algorithm of choice: random value in the range of zero to random value - heavily towards zero

-	int res = MIN_RADIUS + (rnd >> 8) % ((rnd % (MAX_RADIUS - MIN_RADIUS)) + 1);

-	return res;

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenWormNestCaves:

-

-cStructGenWormNestCaves::~cStructGenWormNestCaves()

-{

-	ClearCache();

-}

-

-

-

-

-

-void cStructGenWormNestCaves::ClearCache(void)

-{

-	for (cCaveSystems::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)

-	{

-		delete *itr;

-	}  // for itr - m_Cache[]

-	m_Cache.clear();

-}

-

-

-

-

-

-void cStructGenWormNestCaves::GenStructures(cChunkDesc & a_ChunkDesc)

-{

-	int ChunkX = a_ChunkDesc.GetChunkX();

-	int ChunkZ = a_ChunkDesc.GetChunkZ();

-	cCaveSystems Caves;

-	GetCavesForChunk(ChunkX, ChunkZ, Caves);

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

-	{

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

-	}  // for itr - Caves[]

-}

-

-

-

-

-

-void cStructGenWormNestCaves::GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cStructGenWormNestCaves::cCaveSystems & a_Caves)

-{

-	int BaseX = a_ChunkX * cChunkDef::Width / m_Grid;

-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_Grid;

-	if (BaseX < 0)

-	{

-		--BaseX;

-	}

-	if (BaseZ < 0)

-	{

-		--BaseZ;

-	}

-	BaseX -= NEIGHBORHOOD_SIZE / 2;

-	BaseZ -= NEIGHBORHOOD_SIZE / 2;

-

-	// Walk the cache, move each cave system that we want into a_Caves:

-	int StartX = BaseX * m_Grid;

-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_Grid;

-	int StartZ = BaseZ * m_Grid;

-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_Grid;

-	for (cCaveSystems::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)

-	{

-		if (

-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&

-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)

-		)

-		{

-			// want

-			a_Caves.push_back(*itr);

-			itr = m_Cache.erase(itr);

-		}

-		else

-		{

-			// don't want

-			++itr;

-		}

-	}  // for itr - m_Cache[]

-	

-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)

-	{

-		int RealX = (BaseX + x) * m_Grid;

-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)

-		{

-			int RealZ = (BaseZ + z) * m_Grid;

-			bool Found = false;

-			for (cCaveSystems::const_iterator itr = a_Caves.begin(), end = a_Caves.end(); itr != end; ++itr)

-			{

-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))

-				{

-					Found = true;

-					break;

-				}

-			}

-			if (!Found)

-			{

-				a_Caves.push_back(new cCaveSystem(RealX, RealZ, m_MaxOffset, m_Size, m_Noise));

-			}

-		}

-	}

-	

-	// Copy a_Caves into m_Cache to the beginning:

-	cCaveSystems CavesCopy(a_Caves);

-	m_Cache.splice(m_Cache.begin(), CavesCopy, CavesCopy.begin(), CavesCopy.end());

-	

-	// Trim the cache if it's too long:

-	if (m_Cache.size() > 100)

-	{

-		cCaveSystems::iterator itr = m_Cache.begin();

-		std::advance(itr, 100);

-		for (cCaveSystems::iterator end = m_Cache.end(); itr != end; ++itr)

-		{

-			delete *itr;

-		}

-		itr = m_Cache.begin();

-		std::advance(itr, 100);

-		m_Cache.erase(itr, m_Cache.end());

-	}

-	

-	/*

-	// Uncomment this block for debugging the caves' shapes in 2D using an SVG export

-	#ifdef _DEBUG

-	AString SVG;

-	SVG.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1024\" height = \"1024\">\n");

-	SVG.reserve(2 * 1024 * 1024);

-	for (cCaveSystems::const_iterator itr = a_Caves.begin(), end = a_Caves.end(); itr != end; ++itr)

-	{

-		int Color = 0x10 * abs((*itr)->m_BlockX / m_Grid);

-		Color |= 0x1000 * abs((*itr)->m_BlockZ / m_Grid);

-		SVG.append((*itr)->ExportAsSVG(Color, 512, 512));

-	}

-	SVG.append("</svg>\n");

-	

-	AString fnam;

-	Printf(fnam, "wnc\\%03d_%03d.svg", a_ChunkX, a_ChunkZ);

-	cFile File(fnam, cFile::fmWrite);

-	File.Write(SVG.c_str(), SVG.size());

-	#endif  // _DEBUG

-	//*/

-}

-

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenMarbleCaves:

-

-static float GetMarbleNoise( float x, float y, float z, cNoise & a_Noise )

-{

-	static const float PI_2 = 1.57079633f;

-	float oct1 = (a_Noise.CubicNoise3D(x * 0.1f, y * 0.1f, z * 0.1f )) * 4;

-

-	oct1 = oct1 * oct1 * oct1;

-	if (oct1 < 0.f)  oct1 = PI_2;

-	if (oct1 > PI_2) oct1 = PI_2;

-

-	return oct1;

-}

-

-

-

-

-

-void cStructGenMarbleCaves::GenStructures(cChunkDesc & a_ChunkDesc)

-{

-	cNoise Noise(m_Seed);

-	for (int z = 0; z < 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_ChunkDesc.GetChunkX() * cChunkDef::Width + x);

-			

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

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

-			{

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

-				{

-					continue;

-				}

-

-				const float yy = (float)y;

-				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)

-				{

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

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenDualRidgeCaves:

-

-void cStructGenDualRidgeCaves::GenStructures(cChunkDesc & a_ChunkDesc)

-{

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

-	{

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

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

-		{

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

-			

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

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

-			{

-				const float yy = (float)y / 10;

-				const float WaveNoise = 1;

-				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)

-				{

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

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

+
+// Caves.cpp
+
+// Implements the various cave structure generators:
+//   - cStructGenWormNestCaves
+//   - cStructGenDualRidgeCaves
+//   - cStructGenMarbleCaves
+//   - cStructGenNetherCaves
+
+/*
+WormNestCave generator:
+Caves are generated in "nests" - groups of tunnels generated from a single point.
+For each chunk, all the nests that could intersect it are generated.
+For each nest, first the schematic structure is generated (tunnel from ... to ..., branch, tunnel2 from ... to ...)
+Then each tunnel is randomized by inserting points in between its ends.
+Finally each tunnel is smoothed and Bresenham-3D-ed so that it is a collection of spheres with their centers next to each other.
+When the tunnels are ready, they are simply carved into the chunk, one by one.
+To optimize, each tunnel keeps track of its bounding box, so that it can be skipped for chunks that don't intersect it.
+
+MarbleCaves generator:
+For each voxel a 3D noise function is evaluated, if the value crosses a boundary, the voxel is dug out, otherwise it is kept.
+Problem with this is the amount of CPU work needed for each chunk.
+Also the overall shape of the generated holes is unsatisfactory - there are whole "sheets" of holes in the ground.
+
+DualRidgeCaves generator:
+Instead of evaluating a single noise function, two different noise functions are multiplied. This produces
+regular tunnels instead of sheets. However due to the sheer amount of CPU work needed, the noise functions need to be
+reduced in complexity in order for this generator to be useful, so the caves' shapes are "bubbly" at best.
+*/
+
+#include "Globals.h"
+#include "Caves.h"
+
+
+
+
+
+/// How many nests in each direction are generated for a given chunk. Must be an even number
+#define NEIGHBORHOOD_SIZE 8
+
+
+
+
+
+const int MIN_RADIUS = 3;
+const int MAX_RADIUS = 8;
+
+
+
+
+
+struct cCaveDefPoint
+{
+	int m_BlockX;
+	int m_BlockY;
+	int m_BlockZ;
+	int m_Radius;
+	
+	cCaveDefPoint(int a_BlockX, int a_BlockY, int a_BlockZ, int a_Radius) :
+		m_BlockX(a_BlockX),
+		m_BlockY(a_BlockY),
+		m_BlockZ(a_BlockZ),
+		m_Radius(a_Radius)
+	{
+	}
+} ;
+
+typedef std::vector<cCaveDefPoint> cCaveDefPoints;
+
+
+
+
+
+/// A single non-branching tunnel of a WormNestCave
+class cCaveTunnel
+{
+	// The bounding box, including the radii around defpoints:
+	int m_MinBlockX, m_MaxBlockX;
+	int m_MinBlockY, m_MaxBlockY;
+	int m_MinBlockZ, m_MaxBlockZ;
+	
+	/// Generates the shaping defpoints for the ravine, based on the ravine block coords and noise
+	void Randomize(cNoise & a_Noise);
+	
+	/// Refines (adds and smooths) defpoints from a_Src into a_Dst; returns false if no refinement possible (segments too short)
+	bool RefineDefPoints(const cCaveDefPoints & a_Src, cCaveDefPoints & a_Dst);
+	
+	/// Does rounds of smoothing, two passes of RefineDefPoints(), as long as they return true
+	void Smooth(void);
+	
+	/// Linearly interpolates the points so that the maximum distance between two neighbors is max 1 block
+	void FinishLinear(void);
+	
+	/// Calculates the bounding box of the points present
+	void CalcBoundingBox(void);
+	
+public:
+	cCaveDefPoints m_Points;
+
+	cCaveTunnel(
+		int a_BlockStartX, int a_BlockStartY, int a_BlockStartZ, int a_StartRadius,
+		int a_BlockEndX,   int a_BlockEndY,   int a_BlockEndZ,   int a_EndRadius,
+		cNoise & a_Noise
+	);
+	
+	/// Carves the tunnel into the chunk specified
+	void ProcessChunk(
+		int a_ChunkX, int a_ChunkZ, 
+		cChunkDef::BlockTypes & a_BlockTypes, 
+		cChunkDef::HeightMap & a_HeightMap
+	);
+	
+	#ifdef _DEBUG
+	AString ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const;
+	#endif  // _DEBUG
+} ;
+
+typedef std::vector<cCaveTunnel *> cCaveTunnels;
+
+
+
+
+
+/// A collection of connected tunnels, possibly branching.
+class cStructGenWormNestCaves::cCaveSystem
+{
+public:
+	// The generating block position; is read directly in cStructGenWormNestCaves::GetCavesForChunk()
+	int m_BlockX;
+	int m_BlockZ;
+	
+	cCaveSystem(int a_BlockX, int a_BlockZ, int a_MaxOffset, int a_Size, cNoise & a_Noise);
+	~cCaveSystem();
+	
+	/// Carves the cave system into the chunk specified
+	void ProcessChunk(
+		int a_ChunkX, int a_ChunkZ, 
+		cChunkDef::BlockTypes & a_BlockTypes, 
+		cChunkDef::HeightMap & a_HeightMap
+	);
+	
+	#ifdef _DEBUG
+	AString ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const;
+	#endif  // _DEBUG
+
+protected:
+	int m_Size;
+	cCaveTunnels m_Tunnels;
+	
+	void Clear(void);
+
+	/// Generates a_Segment successive tunnels, with possible branches. Generates the same output for the same [x, y, z, a_Segments]
+	void GenerateTunnelsFromPoint(
+		int a_OriginX, int a_OriginY, int a_OriginZ, 
+		cNoise & a_Noise, int a_Segments
+	);
+	
+	/// Returns a radius based on the location provided.
+	int GetRadius(cNoise & a_Noise, int a_OriginX, int a_OriginY, int a_OriginZ);
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cCaveTunnel:
+
+cCaveTunnel::cCaveTunnel(
+	int a_BlockStartX, int a_BlockStartY, int a_BlockStartZ, int a_StartRadius,
+	int a_BlockEndX,   int a_BlockEndY,   int a_BlockEndZ,   int a_EndRadius,
+	cNoise & a_Noise
+)
+{
+	m_Points.push_back(cCaveDefPoint(a_BlockStartX, a_BlockStartY, a_BlockStartZ, a_StartRadius));
+	m_Points.push_back(cCaveDefPoint(a_BlockEndX,   a_BlockEndY,   a_BlockEndZ,   a_EndRadius));
+	
+	if ((a_BlockStartY <= 0) && (a_BlockEndY <= 0))
+	{
+		// Don't bother detailing this cave, it's under the world anyway
+		return;
+	}
+	
+	Randomize(a_Noise);
+	Smooth();
+	
+	// We know that the linear finishing won't affect the bounding box, so let's calculate it now, as we have less data:
+	CalcBoundingBox();
+	
+	FinishLinear();
+}
+
+
+
+
+
+void cCaveTunnel::Randomize(cNoise & a_Noise)
+{
+	// Repeat 4 times:
+	for (int i = 0; i < 4; i++)
+	{
+		// For each already present point, insert a point in between it and its predecessor, shifted randomly.
+		int PrevX = m_Points.front().m_BlockX;
+		int PrevY = m_Points.front().m_BlockY;
+		int PrevZ = m_Points.front().m_BlockZ;
+		int PrevR = m_Points.front().m_Radius;
+		cCaveDefPoints Pts;
+		Pts.reserve(m_Points.size() * 2 + 1);
+		Pts.push_back(m_Points.front());
+		for (cCaveDefPoints::const_iterator itr = m_Points.begin() + 1, end = m_Points.end(); itr != end; ++itr)
+		{
+			int Random = a_Noise.IntNoise3DInt(PrevX, PrevY, PrevZ + i) / 11;
+			int len = (PrevX - itr->m_BlockX) * (PrevX - itr->m_BlockX);
+			len += (PrevY - itr->m_BlockY) * (PrevY - itr->m_BlockY);
+			len += (PrevZ - itr->m_BlockZ) * (PrevZ - itr->m_BlockZ);
+			len = 3 * (int)sqrt((double)len) / 4;
+			int Rad = std::min(MAX_RADIUS, std::max(MIN_RADIUS, (PrevR + itr->m_Radius) / 2 + (Random % 3) - 1));
+			Random /= 4;
+			int x = (itr->m_BlockX + PrevX) / 2 + (Random % (len + 1) - len / 2);
+			Random /= 256;
+			int y = (itr->m_BlockY + PrevY) / 2 + (Random % (len / 2 + 1) - len / 4);
+			Random /= 256;
+			int z = (itr->m_BlockZ + PrevZ) / 2 + (Random % (len + 1) - len / 2);
+			Pts.push_back(cCaveDefPoint(x, y, z, Rad));
+			Pts.push_back(*itr);
+			PrevX = itr->m_BlockX;
+			PrevY = itr->m_BlockY;
+			PrevZ = itr->m_BlockZ;
+			PrevR = itr->m_Radius;
+		}
+		std::swap(Pts, m_Points);
+	}
+}
+
+
+
+
+
+bool cCaveTunnel::RefineDefPoints(const cCaveDefPoints & a_Src, cCaveDefPoints & a_Dst)
+{
+	// Smoothing: for each line segment, add points on its 1/4 lengths
+	bool res = false;
+	int Num = a_Src.size() - 2;  // this many intermediary points
+	a_Dst.clear();
+	a_Dst.reserve(Num * 2 + 2);
+	cCaveDefPoints::const_iterator itr = a_Src.begin() + 1;
+	a_Dst.push_back(a_Src.front());
+	int PrevX = a_Src.front().m_BlockX;
+	int PrevY = a_Src.front().m_BlockY;
+	int PrevZ = a_Src.front().m_BlockZ;
+	int PrevR = a_Src.front().m_Radius;
+	for (int i = 0; i <= Num; ++i, ++itr)
+	{
+		int dx = itr->m_BlockX - PrevX;
+		int dy = itr->m_BlockY - PrevY;
+		int dz = itr->m_BlockZ - PrevZ;
+		if (abs(dx) + abs(dz) + abs(dy) < 6)
+		{
+			// Too short a segment to smooth-subdivide into quarters
+			PrevX = itr->m_BlockX;
+			PrevY = itr->m_BlockY;
+			PrevZ = itr->m_BlockZ;
+			PrevR = itr->m_Radius;
+			continue;
+		}
+		int dr = itr->m_Radius - PrevR;
+		int Rad1 = std::max(PrevR + 1 * dr / 4, 1);
+		int Rad2 = std::max(PrevR + 3 * dr / 4, 1);
+		a_Dst.push_back(cCaveDefPoint(PrevX + 1 * dx / 4, PrevY + 1 * dy / 4, PrevZ + 1 * dz / 4, Rad1));
+		a_Dst.push_back(cCaveDefPoint(PrevX + 3 * dx / 4, PrevY + 3 * dy / 4, PrevZ + 3 * dz / 4, Rad2));
+		PrevX = itr->m_BlockX;
+		PrevY = itr->m_BlockY;
+		PrevZ = itr->m_BlockZ;
+		PrevR = itr->m_Radius;
+		res = true;
+	}
+	a_Dst.push_back(a_Src.back());
+	return res && (a_Src.size() < a_Dst.size());
+}
+
+
+
+
+
+void cCaveTunnel::Smooth(void)
+{
+	cCaveDefPoints Pts;
+	while (true)
+	{
+		if (!RefineDefPoints(m_Points, Pts))
+		{
+			std::swap(Pts, m_Points);
+			return;
+		}
+		if (!RefineDefPoints(Pts, m_Points))
+		{
+			return;
+		}
+	}
+}
+
+
+
+
+
+void cCaveTunnel::FinishLinear(void)
+{
+	// For each segment, use Bresenham's 3D line algorithm to draw a "line" of defpoints
+	cCaveDefPoints Pts;
+	std::swap(Pts, m_Points);
+	
+	m_Points.reserve(Pts.size() * 3);
+	int PrevX = Pts.front().m_BlockX;
+	int PrevY = Pts.front().m_BlockY;
+	int PrevZ = Pts.front().m_BlockZ;
+	for (cCaveDefPoints::const_iterator itr = Pts.begin() + 1, end = Pts.end(); itr != end; ++itr)
+	{
+		int x1 = itr->m_BlockX;
+		int y1 = itr->m_BlockY;
+		int z1 = itr->m_BlockZ;
+		int dx = abs(x1 - PrevX);
+		int dy = abs(y1 - PrevY);
+		int dz = abs(z1 - PrevZ);
+		int sx = (PrevX < x1) ? 1 : -1;
+		int sy = (PrevY < y1) ? 1 : -1;
+		int sz = (PrevZ < z1) ? 1 : -1;
+		int err = dx - dz;
+		int R = itr->m_Radius;
+
+		if (dx >= std::max(dy, dz))  // x dominant
+		{
+			int yd = dy - dx / 2;
+			int zd = dz - dx / 2;
+
+			while (true)
+			{
+				m_Points.push_back(cCaveDefPoint(PrevX, PrevY, PrevZ, R));
+
+				if (PrevX == x1)
+				{
+					break;
+				}
+
+				if (yd >= 0)  // move along y
+				{
+					PrevY += sy;
+					yd -= dx;
+				}
+
+				if (zd >= 0)  // move along z
+				{
+					PrevZ += sz;
+					zd -= dx;
+				}
+
+				// move along x
+				PrevX  += sx;
+				yd += dy;
+				zd += dz;
+			}
+		}
+		else if (dy >= std::max(dx, dz))  // y dominant
+		{
+			int xd = dx - dy / 2;
+			int zd = dz - dy / 2;
+
+			while (true)
+			{
+				m_Points.push_back(cCaveDefPoint(PrevX, PrevY, PrevZ, R));
+
+				if (PrevY == y1)
+				{
+					break;
+				}
+
+				if (xd >= 0)  // move along x
+				{
+					PrevX += sx;
+					xd -= dy;
+				}
+
+				if (zd >= 0)  // move along z
+				{
+					PrevZ += sz;
+					zd -= dy;
+				}
+
+				// move along y
+				PrevY += sy;
+				xd += dx;
+				zd += dz;
+			}
+		}
+		else
+		{
+			// z dominant
+			ASSERT(dz >= std::max(dx, dy));
+			int xd = dx - dz / 2;
+			int yd = dy - dz / 2;
+
+			while (true)
+			{
+				m_Points.push_back(cCaveDefPoint(PrevX, PrevY, PrevZ, R));
+
+				if (PrevZ == z1)
+				{
+					break;
+				}
+
+				if (xd >= 0)  // move along x
+				{
+					PrevX += sx;
+					xd -= dz;
+				}
+
+				if (yd >= 0)  // move along y
+				{
+					PrevY += sy;
+					yd -= dz;
+				}
+				
+				// move along z
+				PrevZ += sz;
+				xd += dx;
+				yd += dy;
+			}
+		}  // if (which dimension is dominant)
+	}  // for itr
+}
+
+
+
+
+
+void cCaveTunnel::CalcBoundingBox(void)
+{
+	m_MinBlockX = m_MaxBlockX = m_Points.front().m_BlockX;
+	m_MinBlockY = m_MaxBlockY = m_Points.front().m_BlockY;
+	m_MinBlockZ = m_MaxBlockZ = m_Points.front().m_BlockZ;
+	for (cCaveDefPoints::const_iterator itr = m_Points.begin() + 1, end = m_Points.end(); itr != end; ++itr)
+	{
+		m_MinBlockX = std::min(m_MinBlockX, itr->m_BlockX - itr->m_Radius);
+		m_MaxBlockX = std::max(m_MaxBlockX, itr->m_BlockX + itr->m_Radius);
+		m_MinBlockY = std::min(m_MinBlockY, itr->m_BlockY - itr->m_Radius);
+		m_MaxBlockY = std::max(m_MaxBlockY, itr->m_BlockY + itr->m_Radius);
+		m_MinBlockZ = std::min(m_MinBlockZ, itr->m_BlockZ - itr->m_Radius);
+		m_MaxBlockZ = std::max(m_MaxBlockZ, itr->m_BlockZ + itr->m_Radius);
+	}  // for itr - m_Points[]
+}
+
+
+
+
+
+void cCaveTunnel::ProcessChunk(
+	int a_ChunkX, int a_ChunkZ, 
+	cChunkDef::BlockTypes & a_BlockTypes, 
+	cChunkDef::HeightMap & a_HeightMap
+)
+{
+	int BaseX = a_ChunkX * cChunkDef::Width;
+	int BaseZ = a_ChunkZ * cChunkDef::Width;
+	if (
+		(BaseX > m_MaxBlockX) || (BaseX + cChunkDef::Width < m_MinBlockX) ||
+		(BaseX > m_MaxBlockX) || (BaseX + cChunkDef::Width < m_MinBlockX)
+	)
+	{
+		// Tunnel does not intersect the chunk at all, bail out
+		return;
+	}
+
+	int BlockStartX = a_ChunkX * cChunkDef::Width;
+	int BlockStartZ = a_ChunkZ * cChunkDef::Width;
+	int BlockEndX = BlockStartX + cChunkDef::Width;
+	int BlockEndZ = BlockStartZ + cChunkDef::Width;
+	for (cCaveDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)
+	{
+		if (
+			(itr->m_BlockX + itr->m_Radius < BlockStartX) ||
+			(itr->m_BlockX - itr->m_Radius > BlockEndX) ||
+			(itr->m_BlockZ + itr->m_Radius < BlockStartZ) ||
+			(itr->m_BlockZ - itr->m_Radius > BlockEndZ)
+		)
+		{
+			// Cannot intersect, bail out early
+			continue;
+		}
+		
+		// Carve out a sphere around the xyz point, m_Radius in diameter; skip 3/7 off the top and bottom:
+		int DifX = itr->m_BlockX - BlockStartX;  // substitution for faster calc
+		int DifY = itr->m_BlockY;
+		int DifZ = itr->m_BlockZ - BlockStartZ;  // substitution for faster calc
+		int Bottom = std::max(itr->m_BlockY - 3 * itr->m_Radius / 7, 1);
+		int Top    = std::min(itr->m_BlockY + 3 * itr->m_Radius / 7, (int)(cChunkDef::Height));
+		int SqRad  = itr->m_Radius * itr->m_Radius;
+		for (int z = 0; z < cChunkDef::Width; z++) for (int x = 0; x < cChunkDef::Width; x++) 
+		{
+			for (int y = Bottom; y <= Top; y++)
+			{
+				int SqDist = (DifX - x) * (DifX - x) + (DifY - y) * (DifY - y) + (DifZ - z) * (DifZ - z);
+				if (4 * SqDist <= SqRad)
+				{
+					switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))
+					{
+						// Only carve out these specific block types
+						case E_BLOCK_DIRT:
+						case E_BLOCK_GRASS:
+						case E_BLOCK_STONE:
+						case E_BLOCK_COBBLESTONE:
+						case E_BLOCK_GRAVEL:
+						case E_BLOCK_SAND:
+						case E_BLOCK_SANDSTONE:
+						case E_BLOCK_NETHERRACK:
+						case E_BLOCK_COAL_ORE:
+						case E_BLOCK_IRON_ORE:
+						case E_BLOCK_GOLD_ORE:
+						case E_BLOCK_DIAMOND_ORE:
+						case E_BLOCK_REDSTONE_ORE:
+						case E_BLOCK_REDSTONE_ORE_GLOWING:
+						{
+							cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);
+							break;
+						}
+						default: break;
+					}
+				}
+			}  // for y
+		}  // for x, z
+	}  // for itr - m_Points[]
+	
+	/*
+	#ifdef _DEBUG		
+	// For debugging purposes, outline the shape of the cave using glowstone, *after* carving the entire cave:
+	for (cCaveDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)
+	{
+		int DifX = itr->m_BlockX - BlockStartX;  // substitution for faster calc
+		int DifZ = itr->m_BlockZ - BlockStartZ;  // substitution for faster calc
+		if (
+			(DifX >= 0) && (DifX < cChunkDef::Width) &&
+			(itr->m_BlockY > 0) && (itr->m_BlockY < cChunkDef::Height) &&
+			(DifZ >= 0) && (DifZ < cChunkDef::Width)
+		)
+		{
+			cChunkDef::SetBlock(a_BlockTypes, DifX, itr->m_BlockY, DifZ, E_BLOCK_GLOWSTONE);
+		}
+	}  // for itr - m_Points[]
+	#endif  // _DEBUG
+	//*/
+}
+
+
+
+
+
+#ifdef _DEBUG
+AString cCaveTunnel::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const
+{
+	AString SVG;
+	SVG.reserve(m_Points.size() * 20 + 200);
+  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#%06x;stroke-width:1px;\"\nd=\"", a_Color);
+  char Prefix = 'M';  // The first point needs "M" prefix, all the others need "L"
+  for (cCaveDefPoints::const_iterator itr = m_Points.begin(); itr != m_Points.end(); ++itr)
+  {
+		AppendPrintf(SVG, "%c %d,%d ", Prefix, a_OffsetX + itr->m_BlockX, a_OffsetZ + itr->m_BlockZ);
+		Prefix = 'L';
+  }
+  SVG.append("\"/>\n");
+	return SVG;
+}
+#endif  // _DEBUG
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenWormNestCaves::cCaveSystem:
+
+cStructGenWormNestCaves::cCaveSystem::cCaveSystem(int a_BlockX, int a_BlockZ, int a_MaxOffset, int a_Size, cNoise & a_Noise) :
+	m_BlockX(a_BlockX),
+	m_BlockZ(a_BlockZ),
+	m_Size(a_Size)
+{
+	int Num = 1 + a_Noise.IntNoise2DInt(a_BlockX, a_BlockZ) % 3;
+	for (int i = 0; i < Num; i++)
+	{
+		int OriginX = a_BlockX + (a_Noise.IntNoise3DInt(13 * a_BlockX, 17 * a_BlockZ, 11 * i) / 19) % a_MaxOffset;
+		int OriginZ = a_BlockZ + (a_Noise.IntNoise3DInt(17 * a_BlockX, 13 * a_BlockZ, 11 * i) / 23) % a_MaxOffset;
+		int OriginY  = 20 + (a_Noise.IntNoise3DInt(19 * a_BlockX, 13 * a_BlockZ, 11 * i) / 17) % 20;
+		
+		// Generate three branches from the origin point:
+		// The tunnels generated depend on X, Y, Z and Branches,
+		// for the same set of numbers it generates the same offsets!
+		// That's why we add a +1 to X in the third line
+		GenerateTunnelsFromPoint(OriginX,     OriginY, OriginZ, a_Noise, 3);
+		GenerateTunnelsFromPoint(OriginX,     OriginY, OriginZ, a_Noise, 2);
+		GenerateTunnelsFromPoint(OriginX + 1, OriginY, OriginZ, a_Noise, 3);
+	}
+}
+
+
+
+
+
+cStructGenWormNestCaves::cCaveSystem::~cCaveSystem()
+{
+	Clear();
+}
+
+
+
+
+
+
+void cStructGenWormNestCaves::cCaveSystem::ProcessChunk(
+	int a_ChunkX, int a_ChunkZ, 
+	cChunkDef::BlockTypes & a_BlockTypes, 
+	cChunkDef::HeightMap & a_HeightMap
+)
+{
+	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)
+	{
+		(*itr)->ProcessChunk(a_ChunkX, a_ChunkZ, a_BlockTypes, a_HeightMap);
+	}  // for itr - m_Tunnels[]
+}
+
+
+
+
+
+#ifdef _DEBUG
+AString cStructGenWormNestCaves::cCaveSystem::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const
+{
+	AString SVG;
+	SVG.reserve(512 * 1024);
+	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)
+	{
+		SVG.append((*itr)->ExportAsSVG(a_Color, a_OffsetX, a_OffsetZ));
+	}  // for itr - m_Tunnels[]
+
+	// Base point highlight:
+	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
+		a_OffsetX + m_BlockX - 5, a_OffsetZ + m_BlockZ, a_OffsetX + m_BlockX + 5, a_OffsetZ + m_BlockZ
+	);
+	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
+		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ - 5, a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ + 5
+	);
+	
+	// A gray line from the base point to the first point of the ravine, for identification:
+	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#cfcfcf;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
+		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ, 
+		a_OffsetX + m_Tunnels.front()->m_Points.front().m_BlockX, 
+		a_OffsetZ + m_Tunnels.front()->m_Points.front().m_BlockZ
+	);
+	
+	// Offset guides:
+	if (a_OffsetX > 0)
+	{
+		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M %d,0 L %d,1024\"/>\n",
+			a_OffsetX, a_OffsetX
+		);
+	}
+	if (a_OffsetZ > 0)
+	{
+		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M 0,%d L 1024,%d\"/>\n",
+			a_OffsetZ, a_OffsetZ
+		);
+	}
+	
+	return SVG;
+}
+#endif  // _DEBUG
+
+
+
+
+
+void cStructGenWormNestCaves::cCaveSystem::Clear(void)
+{
+	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}
+	m_Tunnels.clear();
+}
+
+
+
+
+
+void cStructGenWormNestCaves::cCaveSystem::GenerateTunnelsFromPoint(
+	int a_OriginX, int a_OriginY, int a_OriginZ, 
+	cNoise & a_Noise, int a_NumSegments
+)
+{
+	int DoubleSize = m_Size * 2;
+	int Radius = GetRadius(a_Noise, a_OriginX + a_OriginY, a_OriginY + a_OriginZ, a_OriginZ + a_OriginX);
+	for (int i = a_NumSegments - 1; i >= 0; --i)
+	{
+		int EndX = a_OriginX + (((a_Noise.IntNoise3DInt(a_OriginX, a_OriginY, a_OriginZ + 11 * a_NumSegments) / 7) % DoubleSize) - m_Size) / 2;
+		int EndY = a_OriginY + (((a_Noise.IntNoise3DInt(a_OriginY, 13 * a_NumSegments, a_OriginZ + a_OriginX) / 7) % DoubleSize) - m_Size) / 4;
+		int EndZ = a_OriginZ + (((a_Noise.IntNoise3DInt(a_OriginZ + 17 * a_NumSegments, a_OriginX, a_OriginY) / 7) % DoubleSize) - m_Size) / 2;
+		int EndR = GetRadius(a_Noise, a_OriginX + 7 * i, a_OriginY + 11 * i, a_OriginZ + a_OriginX);
+		m_Tunnels.push_back(new cCaveTunnel(a_OriginX, a_OriginY, a_OriginZ, Radius, EndX, EndY, EndZ, EndR, a_Noise));
+		GenerateTunnelsFromPoint(EndX, EndY, EndZ, a_Noise, i);
+		a_OriginX = EndX;
+		a_OriginY = EndY;
+		a_OriginZ = EndZ;
+		Radius = EndR;
+	}  // for i - a_NumSegments
+}
+
+
+
+
+
+int cStructGenWormNestCaves::cCaveSystem::GetRadius(cNoise & a_Noise, int a_OriginX, int a_OriginY, int a_OriginZ)
+{
+	// Instead of a flat distribution noise function, we need to shape it, so that most caves are smallish and only a few select are large
+	int rnd = a_Noise.IntNoise3DInt(a_OriginX, a_OriginY, a_OriginZ) / 11;
+	/*
+	// Not good enough:
+	// The algorithm of choice: emulate gauss-distribution noise by adding 3 flat noises, then fold it in half using absolute value.
+	// To save on processing, use one random value and extract 3 bytes to be separately added as the gaussian noise
+	int sum = (rnd & 0xff) + ((rnd >> 8) & 0xff) + ((rnd >> 16) & 0xff);
+	// sum is now a gaussian-distribution noise within [0 .. 767], with center at 384.
+	// We want mapping 384 -> 3, 0 -> 19, 768 -> 19, so divide by 24 to get [0 .. 31] with center at 16, then use abs() to fold around the center
+	int res = 3 + abs((sum / 24) - 16);
+	*/
+	
+	// Algorithm of choice: random value in the range of zero to random value - heavily towards zero
+	int res = MIN_RADIUS + (rnd >> 8) % ((rnd % (MAX_RADIUS - MIN_RADIUS)) + 1);
+	return res;
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenWormNestCaves:
+
+cStructGenWormNestCaves::~cStructGenWormNestCaves()
+{
+	ClearCache();
+}
+
+
+
+
+
+void cStructGenWormNestCaves::ClearCache(void)
+{
+	for (cCaveSystems::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - m_Cache[]
+	m_Cache.clear();
+}
+
+
+
+
+
+void cStructGenWormNestCaves::GenStructures(cChunkDesc & a_ChunkDesc)
+{
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cCaveSystems Caves;
+	GetCavesForChunk(ChunkX, ChunkZ, Caves);
+	for (cCaveSystems::const_iterator itr = Caves.begin(); itr != Caves.end(); ++itr)
+	{
+		(*itr)->ProcessChunk(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
+	}  // for itr - Caves[]
+}
+
+
+
+
+
+void cStructGenWormNestCaves::GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cStructGenWormNestCaves::cCaveSystems & a_Caves)
+{
+	int BaseX = a_ChunkX * cChunkDef::Width / m_Grid;
+	int BaseZ = a_ChunkZ * cChunkDef::Width / m_Grid;
+	if (BaseX < 0)
+	{
+		--BaseX;
+	}
+	if (BaseZ < 0)
+	{
+		--BaseZ;
+	}
+	BaseX -= NEIGHBORHOOD_SIZE / 2;
+	BaseZ -= NEIGHBORHOOD_SIZE / 2;
+
+	// Walk the cache, move each cave system that we want into a_Caves:
+	int StartX = BaseX * m_Grid;
+	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_Grid;
+	int StartZ = BaseZ * m_Grid;
+	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_Grid;
+	for (cCaveSystems::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
+	{
+		if (
+			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
+			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
+		)
+		{
+			// want
+			a_Caves.push_back(*itr);
+			itr = m_Cache.erase(itr);
+		}
+		else
+		{
+			// don't want
+			++itr;
+		}
+	}  // for itr - m_Cache[]
+	
+	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
+	{
+		int RealX = (BaseX + x) * m_Grid;
+		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
+		{
+			int RealZ = (BaseZ + z) * m_Grid;
+			bool Found = false;
+			for (cCaveSystems::const_iterator itr = a_Caves.begin(), end = a_Caves.end(); itr != end; ++itr)
+			{
+				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
+				{
+					Found = true;
+					break;
+				}
+			}
+			if (!Found)
+			{
+				a_Caves.push_back(new cCaveSystem(RealX, RealZ, m_MaxOffset, m_Size, m_Noise));
+			}
+		}
+	}
+	
+	// Copy a_Caves into m_Cache to the beginning:
+	cCaveSystems CavesCopy(a_Caves);
+	m_Cache.splice(m_Cache.begin(), CavesCopy, CavesCopy.begin(), CavesCopy.end());
+	
+	// Trim the cache if it's too long:
+	if (m_Cache.size() > 100)
+	{
+		cCaveSystems::iterator itr = m_Cache.begin();
+		std::advance(itr, 100);
+		for (cCaveSystems::iterator end = m_Cache.end(); itr != end; ++itr)
+		{
+			delete *itr;
+		}
+		itr = m_Cache.begin();
+		std::advance(itr, 100);
+		m_Cache.erase(itr, m_Cache.end());
+	}
+	
+	/*
+	// Uncomment this block for debugging the caves' shapes in 2D using an SVG export
+	#ifdef _DEBUG
+	AString SVG;
+	SVG.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1024\" height = \"1024\">\n");
+	SVG.reserve(2 * 1024 * 1024);
+	for (cCaveSystems::const_iterator itr = a_Caves.begin(), end = a_Caves.end(); itr != end; ++itr)
+	{
+		int Color = 0x10 * abs((*itr)->m_BlockX / m_Grid);
+		Color |= 0x1000 * abs((*itr)->m_BlockZ / m_Grid);
+		SVG.append((*itr)->ExportAsSVG(Color, 512, 512));
+	}
+	SVG.append("</svg>\n");
+	
+	AString fnam;
+	Printf(fnam, "wnc\\%03d_%03d.svg", a_ChunkX, a_ChunkZ);
+	cFile File(fnam, cFile::fmWrite);
+	File.Write(SVG.c_str(), SVG.size());
+	#endif  // _DEBUG
+	//*/
+}
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenMarbleCaves:
+
+static float GetMarbleNoise( float x, float y, float z, cNoise & a_Noise )
+{
+	static const float PI_2 = 1.57079633f;
+	float oct1 = (a_Noise.CubicNoise3D(x * 0.1f, y * 0.1f, z * 0.1f )) * 4;
+
+	oct1 = oct1 * oct1 * oct1;
+	if (oct1 < 0.f)  oct1 = PI_2;
+	if (oct1 > PI_2) oct1 = PI_2;
+
+	return oct1;
+}
+
+
+
+
+
+void cStructGenMarbleCaves::GenStructures(cChunkDesc & a_ChunkDesc)
+{
+	cNoise Noise(m_Seed);
+	for (int z = 0; z < 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_ChunkDesc.GetChunkX() * cChunkDef::Width + x);
+			
+			int Top = a_ChunkDesc.GetHeight(x, z);
+			for (int y = 1; y < Top; ++y )
+			{
+				if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_STONE)
+				{
+					continue;
+				}
+
+				const float yy = (float)y;
+				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)
+				{
+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenDualRidgeCaves:
+
+void cStructGenDualRidgeCaves::GenStructures(cChunkDesc & a_ChunkDesc)
+{
+	for (int z = 0; z < cChunkDef::Width; z++) 
+	{
+		const float zz = (float)(a_ChunkDesc.GetChunkZ() * cChunkDef::Width + z) / 10;
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			const float xx = (float)(a_ChunkDesc.GetChunkX() * cChunkDef::Width + x) / 10;
+			
+			int Top = a_ChunkDesc.GetHeight(x, z);
+			for (int y = 1; y <= Top; ++y)
+			{
+				const float yy = (float)y / 10;
+				const float WaveNoise = 1;
+				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)
+				{
+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
diff --git a/source/Generating/Caves.h b/source/Generating/Caves.h
index bb69550a8..70cf6fe8c 100644
--- a/source/Generating/Caves.h
+++ b/source/Generating/Caves.h
@@ -1,102 +1,102 @@
-

-// Caves.h

-

-// Interfaces to the various cave structure generators:

-//   - cStructGenWormNestCaves

-//   - cStructGenMarbleCaves

-//   - cStructGenNetherCaves

-

-

-

-

-

-#pragma once

-

-#include "ComposableGenerator.h"

-#include "../Noise.h"

-

-

-

-

-

-class cStructGenMarbleCaves :

-	public cStructureGen

-{

-public:

-	cStructGenMarbleCaves(int a_Seed) : m_Seed(a_Seed) {}

-	

-protected:

-

-	int m_Seed;

-	

-	// cStructureGen override:

-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

-

-class cStructGenDualRidgeCaves :

-	public cStructureGen

-{

-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:

-	cNoise m_Noise1;

-	cNoise m_Noise2;

-	int    m_Seed;

-	float  m_Threshold;

-	

-	// cStructureGen override:

-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

-

-class cStructGenWormNestCaves :

-	public cStructureGen

-{

-public:

-	cStructGenWormNestCaves(int a_Seed, int a_Size = 64, int a_Grid = 96, int a_MaxOffset = 128) :

-		m_Noise(a_Seed),

-		m_Size(a_Size),

-		m_Grid(a_Grid),

-		m_MaxOffset(a_MaxOffset)

-	{

-	}

-	

-	~cStructGenWormNestCaves();

-	

-protected:

-	class cCaveSystem;  // fwd: Caves.cpp

-	typedef std::list<cCaveSystem *> cCaveSystems;

-

-	cNoise       m_Noise;

-	int          m_Size;  // relative size of the cave systems' caves. Average number of blocks of each initial tunnel

-	int          m_MaxOffset;  // maximum offset of the cave nest origin from the grid cell the nest belongs to

-	int          m_Grid;  // average spacing of the nests

-	cCaveSystems m_Cache;

-	

-	/// Clears everything from the cache

-	void ClearCache(void);

-	

-	/// Returns all caves that *may* intersect the given chunk. All the caves are valid until the next call to this function.

-	void GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cCaveSystems & a_Caves);

-	

-	// cStructGen override:

-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

+
+// Caves.h
+
+// Interfaces to the various cave structure generators:
+//   - cStructGenWormNestCaves
+//   - cStructGenMarbleCaves
+//   - cStructGenNetherCaves
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "../Noise.h"
+
+
+
+
+
+class cStructGenMarbleCaves :
+	public cStructureGen
+{
+public:
+	cStructGenMarbleCaves(int a_Seed) : m_Seed(a_Seed) {}
+	
+protected:
+
+	int m_Seed;
+	
+	// cStructureGen override:
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
+
+class cStructGenDualRidgeCaves :
+	public cStructureGen
+{
+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:
+	cNoise m_Noise1;
+	cNoise m_Noise2;
+	int    m_Seed;
+	float  m_Threshold;
+	
+	// cStructureGen override:
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
+
+class cStructGenWormNestCaves :
+	public cStructureGen
+{
+public:
+	cStructGenWormNestCaves(int a_Seed, int a_Size = 64, int a_Grid = 96, int a_MaxOffset = 128) :
+		m_Noise(a_Seed),
+		m_Size(a_Size),
+		m_Grid(a_Grid),
+		m_MaxOffset(a_MaxOffset)
+	{
+	}
+	
+	~cStructGenWormNestCaves();
+	
+protected:
+	class cCaveSystem;  // fwd: Caves.cpp
+	typedef std::list<cCaveSystem *> cCaveSystems;
+
+	cNoise       m_Noise;
+	int          m_Size;  // relative size of the cave systems' caves. Average number of blocks of each initial tunnel
+	int          m_MaxOffset;  // maximum offset of the cave nest origin from the grid cell the nest belongs to
+	int          m_Grid;  // average spacing of the nests
+	cCaveSystems m_Cache;
+	
+	/// Clears everything from the cache
+	void ClearCache(void);
+	
+	/// Returns all caves that *may* intersect the given chunk. All the caves are valid until the next call to this function.
+	void GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cCaveSystems & a_Caves);
+	
+	// cStructGen override:
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
diff --git a/source/Generating/ChunkDesc.cpp b/source/Generating/ChunkDesc.cpp
index 5c59055f7..dc6c74a3c 100644
--- a/source/Generating/ChunkDesc.cpp
+++ b/source/Generating/ChunkDesc.cpp
@@ -1,578 +1,578 @@
-

-// ChunkDesc.cpp

-

-// Implements the cChunkDesc class representing the chunk description used while generating a chunk. This class is also exported to Lua for HOOK_CHUNK_GENERATING.

-

-#include "Globals.h"

-#include "ChunkDesc.h"

-#include "../BlockArea.h"

-#include "../Cuboid.h"

-#include "../Noise.h"

-

-

-

-

-

-cChunkDesc::cChunkDesc(int a_ChunkX, int a_ChunkZ) :

-	m_ChunkX(a_ChunkX),

-	m_ChunkZ(a_ChunkZ),

-	m_bUseDefaultBiomes(true),

-	m_bUseDefaultHeight(true),

-	m_bUseDefaultComposition(true),

-	m_bUseDefaultStructures(true),

-	m_bUseDefaultFinish(true)

-{

-	m_BlockArea.Create(cChunkDef::Width, cChunkDef::Height, cChunkDef::Width);

-	/*

-	memset(m_BlockTypes, 0, sizeof(cChunkDef::BlockTypes));

-	memset(m_BlockMeta,  0, sizeof(cChunkDef::BlockNibbles));

-	*/

-	memset(m_BiomeMap,   0, sizeof(cChunkDef::BiomeMap));

-	memset(m_HeightMap,  0, sizeof(cChunkDef::HeightMap));

-}

-

-

-

-

-

-cChunkDesc::~cChunkDesc()

-{

-	// Nothing needed yet

-}

-

-

-

-

-

-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)

-{

-	m_BlockArea.Fill(cBlockArea::baTypes | cBlockArea::baMetas, a_BlockType, a_BlockMeta);

-}

-

-

-

-

-

-void cChunkDesc::SetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)

-{

-	m_BlockArea.SetRelBlockTypeMeta(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);

-}

-

-

-

-

-

-void cChunkDesc::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)

-{

-	m_BlockArea.GetRelBlockTypeMeta(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);

-}

-

-

-

-

-

-void cChunkDesc::SetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType)

-{

-	cChunkDef::SetBlock(m_BlockArea.GetBlockTypes(), a_RelX, a_RelY, a_RelZ, a_BlockType);

-}

-

-

-

-

-

-BLOCKTYPE cChunkDesc::GetBlockType(int a_RelX, int a_RelY, int a_RelZ)

-{

-	return cChunkDef::GetBlock(m_BlockArea.GetBlockTypes(), a_RelX, a_RelY, a_RelZ);

-}

-

-

-

-

-

-NIBBLETYPE cChunkDesc::GetBlockMeta(int a_RelX, int a_RelY, int a_RelZ)

-{

-	return m_BlockArea.GetRelBlockMeta(a_RelX, a_RelY, a_RelZ);

-}

-

-

-

-

-

-void cChunkDesc::SetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_BlockMeta)

-{

-	m_BlockArea.SetRelBlockMeta(a_RelX, a_RelY, a_RelZ, a_BlockMeta);

-}

-

-

-

-

-

-void cChunkDesc::SetBiome(int a_RelX, int a_RelZ, int a_BiomeID)

-{

-	cChunkDef::SetBiome(m_BiomeMap, a_RelX, a_RelZ, (EMCSBiome)a_BiomeID);

-}

-

-

-

-

-EMCSBiome cChunkDesc::GetBiome(int a_RelX, int a_RelZ)

-{

-	return cChunkDef::GetBiome(m_BiomeMap, a_RelX, a_RelZ);

-}

-

-

-

-

-

-void cChunkDesc::SetHeight(int a_RelX, int a_RelZ, int a_Height)

-{

-	cChunkDef::SetHeight(m_HeightMap, a_RelX, a_RelZ, a_Height);

-}

-

-

-

-

-

-int cChunkDesc::GetHeight(int a_RelX, int a_RelZ)

-{

-	return cChunkDef::GetHeight(m_HeightMap, a_RelX, a_RelZ);

-}

-

-

-

-

-

-void cChunkDesc::SetUseDefaultBiomes(bool a_bUseDefaultBiomes)

-{

-	m_bUseDefaultBiomes = a_bUseDefaultBiomes;

-}

-

-

-

-

-

-bool cChunkDesc::IsUsingDefaultBiomes(void) const

-{

-	return m_bUseDefaultBiomes;

-}

-

-

-

-

-

-void cChunkDesc::SetUseDefaultHeight(bool a_bUseDefaultHeight)

-{

-	m_bUseDefaultHeight = a_bUseDefaultHeight;

-}

-

-

-

-

-

-bool cChunkDesc::IsUsingDefaultHeight(void) const

-{

-	return m_bUseDefaultHeight;

-}

-

-

-

-

-

-void cChunkDesc::SetUseDefaultComposition(bool a_bUseDefaultComposition)

-{

-	m_bUseDefaultComposition = a_bUseDefaultComposition;

-}

-

-

-

-

-

-bool cChunkDesc::IsUsingDefaultComposition(void) const

-{

-	return m_bUseDefaultComposition;

-}

-

-

-

-

-

-void cChunkDesc::SetUseDefaultStructures(bool a_bUseDefaultStructures)

-{

-	m_bUseDefaultStructures = a_bUseDefaultStructures;

-}

-

-

-

-

-

-bool cChunkDesc::IsUsingDefaultStructures(void) const

-{

-	return m_bUseDefaultStructures;

-}

-

-

-

-

-

-void cChunkDesc::SetUseDefaultFinish(bool a_bUseDefaultFinish)

-{

-	m_bUseDefaultFinish = a_bUseDefaultFinish;

-}

-

-

-

-

-

-bool cChunkDesc::IsUsingDefaultFinish(void) const

-{

-	return m_bUseDefaultFinish;

-}

-

-

-

-

-void cChunkDesc::WriteBlockArea(const cBlockArea & a_BlockArea, int a_RelX, int a_RelY, int a_RelZ, cBlockArea::eMergeStrategy a_MergeStrategy)

-{

-	m_BlockArea.Merge(a_BlockArea, a_RelX, a_RelY, a_RelZ, a_MergeStrategy);

-}

-

-

-

-

-

-void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ)

-{

-	// Normalize the coords:

-	if (a_MinRelX > a_MaxRelX)

-	{

-		std::swap(a_MinRelX, a_MaxRelX);

-	}

-	if (a_MinRelY > a_MaxRelY)

-	{

-		std::swap(a_MinRelY, a_MaxRelY);

-	}

-	if (a_MinRelZ > a_MaxRelZ)

-	{

-		std::swap(a_MinRelZ, a_MaxRelZ);

-	}

-

-	// Include the Max coords:

-	a_MaxRelX += 1;

-	a_MaxRelY += 1;

-	a_MaxRelZ += 1;

-	

-	// Check coords validity:

-	if (a_MinRelX < 0)

-	{

-		LOGWARNING("%s: MinRelX less than zero, adjusting to zero", __FUNCTION__);

-		a_MinRelX = 0;

-	}

-	else if (a_MinRelX >= cChunkDef::Width)

-	{

-		LOGWARNING("%s: MinRelX more than chunk width, adjusting to chunk width", __FUNCTION__);

-		a_MinRelX = cChunkDef::Width - 1;

-	}

-	if (a_MaxRelX < 0)

-	{

-		LOGWARNING("%s: MaxRelX less than zero, adjusting to zero", __FUNCTION__);

-		a_MaxRelX = 0;

-	}

-	else if (a_MinRelX >= cChunkDef::Width)

-	{

-		LOGWARNING("%s: MaxRelX more than chunk width, adjusting to chunk width", __FUNCTION__);

-		a_MaxRelX = cChunkDef::Width - 1;

-	}

-

-	if (a_MinRelY < 0)

-	{

-		LOGWARNING("%s: MinRelY less than zero, adjusting to zero", __FUNCTION__);

-		a_MinRelY = 0;

-	}

-	else if (a_MinRelY >= cChunkDef::Height)

-	{

-		LOGWARNING("%s: MinRelY more than chunk height, adjusting to chunk height", __FUNCTION__);

-		a_MinRelY = cChunkDef::Height - 1;

-	}

-	if (a_MaxRelY < 0)

-	{

-		LOGWARNING("%s: MaxRelY less than zero, adjusting to zero", __FUNCTION__);

-		a_MaxRelY = 0;

-	}

-	else if (a_MinRelY >= cChunkDef::Height)

-	{

-		LOGWARNING("%s: MaxRelY more than chunk height, adjusting to chunk height", __FUNCTION__);

-		a_MaxRelY = cChunkDef::Height - 1;

-	}

-	

-	if (a_MinRelZ < 0)

-	{

-		LOGWARNING("%s: MinRelZ less than zero, adjusting to zero", __FUNCTION__);

-		a_MinRelZ = 0;

-	}

-	else if (a_MinRelZ >= cChunkDef::Width)

-	{

-		LOGWARNING("%s: MinRelZ more than chunk width, adjusting to chunk width", __FUNCTION__);

-		a_MinRelZ = cChunkDef::Width - 1;

-	}

-	if (a_MaxRelZ < 0)

-	{

-		LOGWARNING("%s: MaxRelZ less than zero, adjusting to zero", __FUNCTION__);

-		a_MaxRelZ = 0;

-	}

-	else if (a_MinRelZ >= cChunkDef::Width)

-	{

-		LOGWARNING("%s: MaxRelZ more than chunk width, adjusting to chunk width", __FUNCTION__);

-		a_MaxRelZ = cChunkDef::Width - 1;

-	}

-

-	// Prepare the block area:

-	int SizeX = a_MaxRelX - a_MinRelX;

-	int SizeY = a_MaxRelY - a_MinRelY;

-	int SizeZ = a_MaxRelZ - a_MinRelZ;

-	a_Dest.Clear();

-	a_Dest.m_OriginX = m_ChunkX * cChunkDef::Width + a_MinRelX;

-	a_Dest.m_OriginY = a_MinRelY;

-	a_Dest.m_OriginZ = m_ChunkZ * cChunkDef::Width + a_MinRelZ;

-	a_Dest.SetSize(SizeX, SizeY, SizeZ, cBlockArea::baTypes | cBlockArea::baMetas);

-

-	for (int y = 0; y < SizeY; y++)

-	{

-		int CDY = a_MinRelY + y;

-		for (int z = 0; z < SizeZ; z++)

-		{

-			int CDZ = a_MinRelZ + z;

-			for (int x = 0; x < SizeX; x++)

-			{

-				int CDX = a_MinRelX + x;

-				BLOCKTYPE BlockType;

-				NIBBLETYPE BlockMeta;

-				GetBlockTypeMeta(CDX, CDY, CDZ, BlockType, BlockMeta);

-				a_Dest.SetRelBlockTypeMeta(x, y, z, BlockType, BlockMeta);

-			}  // for x

-		}  // for z

-	}  // for y

-}

-

-

-

-

-

-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;

-}

-

-

-

-

-

-void cChunkDesc::FillRelCuboid(

-	int a_MinX, int a_MaxX,

-	int a_MinY, int a_MaxY,

-	int a_MinZ, int a_MaxZ,

-	BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta

-)

-{

-	int MinX = std::max(a_MinX, 0);

-	int MinY = std::max(a_MinY, 0);

-	int MinZ = std::max(a_MinZ, 0);

-	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);

-	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);

-	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);

-	

-	for (int y = MinY; y <= MaxY; y++)

-	{

-		for (int z = MinZ; z <= MaxZ; z++)

-		{

-			for (int x = MinX; x <= MaxX; x++)

-			{

-				SetBlockTypeMeta(x, y, z, a_BlockType, a_BlockMeta);

-			}

-		}  // for z

-	}  // for y

-}

-

-

-

-

-

-void cChunkDesc::ReplaceRelCuboid(

-	int a_MinX, int a_MaxX,

-	int a_MinY, int a_MaxY,

-	int a_MinZ, int a_MaxZ,

-	BLOCKTYPE a_SrcType, NIBBLETYPE a_SrcMeta,

-	BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta

-)

-{

-	int MinX = std::max(a_MinX, 0);

-	int MinY = std::max(a_MinY, 0);

-	int MinZ = std::max(a_MinZ, 0);

-	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);

-	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);

-	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);

-	

-	for (int y = MinY; y <= MaxY; y++)

-	{

-		for (int z = MinZ; z <= MaxZ; z++)

-		{

-			for (int x = MinX; x <= MaxX; x++)

-			{

-				BLOCKTYPE BlockType;

-				NIBBLETYPE BlockMeta;

-				GetBlockTypeMeta(x, y, z, BlockType, BlockMeta);

-				if ((BlockType == a_SrcType) && (BlockMeta == a_SrcMeta))

-				{

-					SetBlockTypeMeta(x, y, z, a_DstType, a_DstMeta);

-				}

-			}

-		}  // for z

-	}  // for y

-}

-

-

-

-

-

-void cChunkDesc::FloorRelCuboid(

-	int a_MinX, int a_MaxX,

-	int a_MinY, int a_MaxY,

-	int a_MinZ, int a_MaxZ,

-	BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta

-)

-{

-	int MinX = std::max(a_MinX, 0);

-	int MinY = std::max(a_MinY, 0);

-	int MinZ = std::max(a_MinZ, 0);

-	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);

-	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);

-	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);

-	

-	for (int y = MinY; y <= MaxY; y++)

-	{

-		for (int z = MinZ; z <= MaxZ; z++)

-		{

-			for (int x = MinX; x <= MaxX; x++)

-			{

-				switch (GetBlockType(x, y, z))

-				{

-					case E_BLOCK_AIR:

-					case E_BLOCK_WATER:

-					case E_BLOCK_STATIONARY_WATER:

-					{

-						SetBlockTypeMeta(x, y, z, a_DstType, a_DstMeta);

-						break;

-					}

-				}  // switch (GetBlockType)

-			}  // for x

-		}  // for z

-	}  // for y

-}

-

-

-

-

-

-void cChunkDesc::RandomFillRelCuboid(

-	int a_MinX, int a_MaxX,

-	int a_MinY, int a_MaxY,

-	int a_MinZ, int a_MaxZ,

-	BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,

-	int a_RandomSeed, int a_ChanceOutOf10k

-)

-{

-	cNoise Noise(a_RandomSeed);

-	int MinX = std::max(a_MinX, 0);

-	int MinY = std::max(a_MinY, 0);

-	int MinZ = std::max(a_MinZ, 0);

-	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);

-	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);

-	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);

-	

-	for (int y = MinY; y <= MaxY; y++)

-	{

-		for (int z = MinZ; z <= MaxZ; z++)

-		{

-			for (int x = MinX; x <= MaxX; x++)

-			{

-				int rnd = (Noise.IntNoise3DInt(x, y, z) / 7) % 10000;

-				if (rnd <= a_ChanceOutOf10k)

-				{

-					SetBlockTypeMeta(x, y, z, a_BlockType, a_BlockMeta);

-				}

-			}

-		}  // for z

-	}  // for y

-}

-

-

-

-

-

-void cChunkDesc::AddBlockEntity(cBlockEntity * a_BlockEntity)

-{

-	m_BlockEntities.push_back(a_BlockEntity);

-}

-

-

-

-

-

-void cChunkDesc::CompressBlockMetas(cChunkDef::BlockNibbles & a_DestMetas)

-{

-	const NIBBLETYPE * AreaMetas = m_BlockArea.GetBlockMetas();

-	for (int i = 0; i < ARRAYCOUNT(a_DestMetas); i++)

-	{

-		a_DestMetas[i] = AreaMetas[2 * i] | (AreaMetas[2 * i + 1] << 4);

-	}

-}

-

-

-

-

-

-#ifdef _DEBUG

-

-void cChunkDesc::VerifyHeightmap(void)

-{

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

-	{

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

-		{

-			for (int y = cChunkDef::Height - 1; y > 0; y--)

-			{

-				BLOCKTYPE BlockType = GetBlockType(x, y, z);

-				if (BlockType != E_BLOCK_AIR)

-				{

-					int Height = GetHeight(x, z);

-					ASSERT(Height == y);

-					break;

-				}

-			}  // for y

-		}  // for z

-	}  // for x

-}

-

-#endif  // _DEBUG

-

-

-

-

-

+
+// ChunkDesc.cpp
+
+// Implements the cChunkDesc class representing the chunk description used while generating a chunk. This class is also exported to Lua for HOOK_CHUNK_GENERATING.
+
+#include "Globals.h"
+#include "ChunkDesc.h"
+#include "../BlockArea.h"
+#include "../Cuboid.h"
+#include "../Noise.h"
+
+
+
+
+
+cChunkDesc::cChunkDesc(int a_ChunkX, int a_ChunkZ) :
+	m_ChunkX(a_ChunkX),
+	m_ChunkZ(a_ChunkZ),
+	m_bUseDefaultBiomes(true),
+	m_bUseDefaultHeight(true),
+	m_bUseDefaultComposition(true),
+	m_bUseDefaultStructures(true),
+	m_bUseDefaultFinish(true)
+{
+	m_BlockArea.Create(cChunkDef::Width, cChunkDef::Height, cChunkDef::Width);
+	/*
+	memset(m_BlockTypes, 0, sizeof(cChunkDef::BlockTypes));
+	memset(m_BlockMeta,  0, sizeof(cChunkDef::BlockNibbles));
+	*/
+	memset(m_BiomeMap,   0, sizeof(cChunkDef::BiomeMap));
+	memset(m_HeightMap,  0, sizeof(cChunkDef::HeightMap));
+}
+
+
+
+
+
+cChunkDesc::~cChunkDesc()
+{
+	// Nothing needed yet
+}
+
+
+
+
+
+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)
+{
+	m_BlockArea.Fill(cBlockArea::baTypes | cBlockArea::baMetas, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+void cChunkDesc::SetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	m_BlockArea.SetRelBlockTypeMeta(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+void cChunkDesc::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+{
+	m_BlockArea.GetRelBlockTypeMeta(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+void cChunkDesc::SetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType)
+{
+	cChunkDef::SetBlock(m_BlockArea.GetBlockTypes(), a_RelX, a_RelY, a_RelZ, a_BlockType);
+}
+
+
+
+
+
+BLOCKTYPE cChunkDesc::GetBlockType(int a_RelX, int a_RelY, int a_RelZ)
+{
+	return cChunkDef::GetBlock(m_BlockArea.GetBlockTypes(), a_RelX, a_RelY, a_RelZ);
+}
+
+
+
+
+
+NIBBLETYPE cChunkDesc::GetBlockMeta(int a_RelX, int a_RelY, int a_RelZ)
+{
+	return m_BlockArea.GetRelBlockMeta(a_RelX, a_RelY, a_RelZ);
+}
+
+
+
+
+
+void cChunkDesc::SetBlockMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_BlockMeta)
+{
+	m_BlockArea.SetRelBlockMeta(a_RelX, a_RelY, a_RelZ, a_BlockMeta);
+}
+
+
+
+
+
+void cChunkDesc::SetBiome(int a_RelX, int a_RelZ, int a_BiomeID)
+{
+	cChunkDef::SetBiome(m_BiomeMap, a_RelX, a_RelZ, (EMCSBiome)a_BiomeID);
+}
+
+
+
+
+EMCSBiome cChunkDesc::GetBiome(int a_RelX, int a_RelZ)
+{
+	return cChunkDef::GetBiome(m_BiomeMap, a_RelX, a_RelZ);
+}
+
+
+
+
+
+void cChunkDesc::SetHeight(int a_RelX, int a_RelZ, int a_Height)
+{
+	cChunkDef::SetHeight(m_HeightMap, a_RelX, a_RelZ, a_Height);
+}
+
+
+
+
+
+int cChunkDesc::GetHeight(int a_RelX, int a_RelZ)
+{
+	return cChunkDef::GetHeight(m_HeightMap, a_RelX, a_RelZ);
+}
+
+
+
+
+
+void cChunkDesc::SetUseDefaultBiomes(bool a_bUseDefaultBiomes)
+{
+	m_bUseDefaultBiomes = a_bUseDefaultBiomes;
+}
+
+
+
+
+
+bool cChunkDesc::IsUsingDefaultBiomes(void) const
+{
+	return m_bUseDefaultBiomes;
+}
+
+
+
+
+
+void cChunkDesc::SetUseDefaultHeight(bool a_bUseDefaultHeight)
+{
+	m_bUseDefaultHeight = a_bUseDefaultHeight;
+}
+
+
+
+
+
+bool cChunkDesc::IsUsingDefaultHeight(void) const
+{
+	return m_bUseDefaultHeight;
+}
+
+
+
+
+
+void cChunkDesc::SetUseDefaultComposition(bool a_bUseDefaultComposition)
+{
+	m_bUseDefaultComposition = a_bUseDefaultComposition;
+}
+
+
+
+
+
+bool cChunkDesc::IsUsingDefaultComposition(void) const
+{
+	return m_bUseDefaultComposition;
+}
+
+
+
+
+
+void cChunkDesc::SetUseDefaultStructures(bool a_bUseDefaultStructures)
+{
+	m_bUseDefaultStructures = a_bUseDefaultStructures;
+}
+
+
+
+
+
+bool cChunkDesc::IsUsingDefaultStructures(void) const
+{
+	return m_bUseDefaultStructures;
+}
+
+
+
+
+
+void cChunkDesc::SetUseDefaultFinish(bool a_bUseDefaultFinish)
+{
+	m_bUseDefaultFinish = a_bUseDefaultFinish;
+}
+
+
+
+
+
+bool cChunkDesc::IsUsingDefaultFinish(void) const
+{
+	return m_bUseDefaultFinish;
+}
+
+
+
+
+void cChunkDesc::WriteBlockArea(const cBlockArea & a_BlockArea, int a_RelX, int a_RelY, int a_RelZ, cBlockArea::eMergeStrategy a_MergeStrategy)
+{
+	m_BlockArea.Merge(a_BlockArea, a_RelX, a_RelY, a_RelZ, a_MergeStrategy);
+}
+
+
+
+
+
+void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX, int a_MinRelY, int a_MaxRelY, int a_MinRelZ, int a_MaxRelZ)
+{
+	// Normalize the coords:
+	if (a_MinRelX > a_MaxRelX)
+	{
+		std::swap(a_MinRelX, a_MaxRelX);
+	}
+	if (a_MinRelY > a_MaxRelY)
+	{
+		std::swap(a_MinRelY, a_MaxRelY);
+	}
+	if (a_MinRelZ > a_MaxRelZ)
+	{
+		std::swap(a_MinRelZ, a_MaxRelZ);
+	}
+
+	// Include the Max coords:
+	a_MaxRelX += 1;
+	a_MaxRelY += 1;
+	a_MaxRelZ += 1;
+	
+	// Check coords validity:
+	if (a_MinRelX < 0)
+	{
+		LOGWARNING("%s: MinRelX less than zero, adjusting to zero", __FUNCTION__);
+		a_MinRelX = 0;
+	}
+	else if (a_MinRelX >= cChunkDef::Width)
+	{
+		LOGWARNING("%s: MinRelX more than chunk width, adjusting to chunk width", __FUNCTION__);
+		a_MinRelX = cChunkDef::Width - 1;
+	}
+	if (a_MaxRelX < 0)
+	{
+		LOGWARNING("%s: MaxRelX less than zero, adjusting to zero", __FUNCTION__);
+		a_MaxRelX = 0;
+	}
+	else if (a_MinRelX >= cChunkDef::Width)
+	{
+		LOGWARNING("%s: MaxRelX more than chunk width, adjusting to chunk width", __FUNCTION__);
+		a_MaxRelX = cChunkDef::Width - 1;
+	}
+
+	if (a_MinRelY < 0)
+	{
+		LOGWARNING("%s: MinRelY less than zero, adjusting to zero", __FUNCTION__);
+		a_MinRelY = 0;
+	}
+	else if (a_MinRelY >= cChunkDef::Height)
+	{
+		LOGWARNING("%s: MinRelY more than chunk height, adjusting to chunk height", __FUNCTION__);
+		a_MinRelY = cChunkDef::Height - 1;
+	}
+	if (a_MaxRelY < 0)
+	{
+		LOGWARNING("%s: MaxRelY less than zero, adjusting to zero", __FUNCTION__);
+		a_MaxRelY = 0;
+	}
+	else if (a_MinRelY >= cChunkDef::Height)
+	{
+		LOGWARNING("%s: MaxRelY more than chunk height, adjusting to chunk height", __FUNCTION__);
+		a_MaxRelY = cChunkDef::Height - 1;
+	}
+	
+	if (a_MinRelZ < 0)
+	{
+		LOGWARNING("%s: MinRelZ less than zero, adjusting to zero", __FUNCTION__);
+		a_MinRelZ = 0;
+	}
+	else if (a_MinRelZ >= cChunkDef::Width)
+	{
+		LOGWARNING("%s: MinRelZ more than chunk width, adjusting to chunk width", __FUNCTION__);
+		a_MinRelZ = cChunkDef::Width - 1;
+	}
+	if (a_MaxRelZ < 0)
+	{
+		LOGWARNING("%s: MaxRelZ less than zero, adjusting to zero", __FUNCTION__);
+		a_MaxRelZ = 0;
+	}
+	else if (a_MinRelZ >= cChunkDef::Width)
+	{
+		LOGWARNING("%s: MaxRelZ more than chunk width, adjusting to chunk width", __FUNCTION__);
+		a_MaxRelZ = cChunkDef::Width - 1;
+	}
+
+	// Prepare the block area:
+	int SizeX = a_MaxRelX - a_MinRelX;
+	int SizeY = a_MaxRelY - a_MinRelY;
+	int SizeZ = a_MaxRelZ - a_MinRelZ;
+	a_Dest.Clear();
+	a_Dest.m_OriginX = m_ChunkX * cChunkDef::Width + a_MinRelX;
+	a_Dest.m_OriginY = a_MinRelY;
+	a_Dest.m_OriginZ = m_ChunkZ * cChunkDef::Width + a_MinRelZ;
+	a_Dest.SetSize(SizeX, SizeY, SizeZ, cBlockArea::baTypes | cBlockArea::baMetas);
+
+	for (int y = 0; y < SizeY; y++)
+	{
+		int CDY = a_MinRelY + y;
+		for (int z = 0; z < SizeZ; z++)
+		{
+			int CDZ = a_MinRelZ + z;
+			for (int x = 0; x < SizeX; x++)
+			{
+				int CDX = a_MinRelX + x;
+				BLOCKTYPE BlockType;
+				NIBBLETYPE BlockMeta;
+				GetBlockTypeMeta(CDX, CDY, CDZ, BlockType, BlockMeta);
+				a_Dest.SetRelBlockTypeMeta(x, y, z, BlockType, BlockMeta);
+			}  // for x
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+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;
+}
+
+
+
+
+
+void cChunkDesc::FillRelCuboid(
+	int a_MinX, int a_MaxX,
+	int a_MinY, int a_MaxY,
+	int a_MinZ, int a_MaxZ,
+	BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta
+)
+{
+	int MinX = std::max(a_MinX, 0);
+	int MinY = std::max(a_MinY, 0);
+	int MinZ = std::max(a_MinZ, 0);
+	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);
+	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);
+	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);
+	
+	for (int y = MinY; y <= MaxY; y++)
+	{
+		for (int z = MinZ; z <= MaxZ; z++)
+		{
+			for (int x = MinX; x <= MaxX; x++)
+			{
+				SetBlockTypeMeta(x, y, z, a_BlockType, a_BlockMeta);
+			}
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+void cChunkDesc::ReplaceRelCuboid(
+	int a_MinX, int a_MaxX,
+	int a_MinY, int a_MaxY,
+	int a_MinZ, int a_MaxZ,
+	BLOCKTYPE a_SrcType, NIBBLETYPE a_SrcMeta,
+	BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta
+)
+{
+	int MinX = std::max(a_MinX, 0);
+	int MinY = std::max(a_MinY, 0);
+	int MinZ = std::max(a_MinZ, 0);
+	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);
+	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);
+	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);
+	
+	for (int y = MinY; y <= MaxY; y++)
+	{
+		for (int z = MinZ; z <= MaxZ; z++)
+		{
+			for (int x = MinX; x <= MaxX; x++)
+			{
+				BLOCKTYPE BlockType;
+				NIBBLETYPE BlockMeta;
+				GetBlockTypeMeta(x, y, z, BlockType, BlockMeta);
+				if ((BlockType == a_SrcType) && (BlockMeta == a_SrcMeta))
+				{
+					SetBlockTypeMeta(x, y, z, a_DstType, a_DstMeta);
+				}
+			}
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+void cChunkDesc::FloorRelCuboid(
+	int a_MinX, int a_MaxX,
+	int a_MinY, int a_MaxY,
+	int a_MinZ, int a_MaxZ,
+	BLOCKTYPE a_DstType, NIBBLETYPE a_DstMeta
+)
+{
+	int MinX = std::max(a_MinX, 0);
+	int MinY = std::max(a_MinY, 0);
+	int MinZ = std::max(a_MinZ, 0);
+	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);
+	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);
+	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);
+	
+	for (int y = MinY; y <= MaxY; y++)
+	{
+		for (int z = MinZ; z <= MaxZ; z++)
+		{
+			for (int x = MinX; x <= MaxX; x++)
+			{
+				switch (GetBlockType(x, y, z))
+				{
+					case E_BLOCK_AIR:
+					case E_BLOCK_WATER:
+					case E_BLOCK_STATIONARY_WATER:
+					{
+						SetBlockTypeMeta(x, y, z, a_DstType, a_DstMeta);
+						break;
+					}
+				}  // switch (GetBlockType)
+			}  // for x
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+void cChunkDesc::RandomFillRelCuboid(
+	int a_MinX, int a_MaxX,
+	int a_MinY, int a_MaxY,
+	int a_MinZ, int a_MaxZ,
+	BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta,
+	int a_RandomSeed, int a_ChanceOutOf10k
+)
+{
+	cNoise Noise(a_RandomSeed);
+	int MinX = std::max(a_MinX, 0);
+	int MinY = std::max(a_MinY, 0);
+	int MinZ = std::max(a_MinZ, 0);
+	int MaxX = std::min(a_MaxX, cChunkDef::Width - 1);
+	int MaxY = std::min(a_MaxY, cChunkDef::Height - 1);
+	int MaxZ = std::min(a_MaxZ, cChunkDef::Width - 1);
+	
+	for (int y = MinY; y <= MaxY; y++)
+	{
+		for (int z = MinZ; z <= MaxZ; z++)
+		{
+			for (int x = MinX; x <= MaxX; x++)
+			{
+				int rnd = (Noise.IntNoise3DInt(x, y, z) / 7) % 10000;
+				if (rnd <= a_ChanceOutOf10k)
+				{
+					SetBlockTypeMeta(x, y, z, a_BlockType, a_BlockMeta);
+				}
+			}
+		}  // for z
+	}  // for y
+}
+
+
+
+
+
+void cChunkDesc::AddBlockEntity(cBlockEntity * a_BlockEntity)
+{
+	m_BlockEntities.push_back(a_BlockEntity);
+}
+
+
+
+
+
+void cChunkDesc::CompressBlockMetas(cChunkDef::BlockNibbles & a_DestMetas)
+{
+	const NIBBLETYPE * AreaMetas = m_BlockArea.GetBlockMetas();
+	for (int i = 0; i < ARRAYCOUNT(a_DestMetas); i++)
+	{
+		a_DestMetas[i] = AreaMetas[2 * i] | (AreaMetas[2 * i + 1] << 4);
+	}
+}
+
+
+
+
+
+#ifdef _DEBUG
+
+void cChunkDesc::VerifyHeightmap(void)
+{
+	for (int x = 0; x < cChunkDef::Width; x++)
+	{
+		for (int z = 0; z < cChunkDef::Width; z++)
+		{
+			for (int y = cChunkDef::Height - 1; y > 0; y--)
+			{
+				BLOCKTYPE BlockType = GetBlockType(x, y, z);
+				if (BlockType != E_BLOCK_AIR)
+				{
+					int Height = GetHeight(x, z);
+					ASSERT(Height == y);
+					break;
+				}
+			}  // for y
+		}  // for z
+	}  // for x
+}
+
+#endif  // _DEBUG
+
+
+
+
+
diff --git a/source/Generating/ComposableGenerator.cpp b/source/Generating/ComposableGenerator.cpp
index c038712aa..fb31ec7b2 100644
--- a/source/Generating/ComposableGenerator.cpp
+++ b/source/Generating/ComposableGenerator.cpp
@@ -1,524 +1,524 @@
-

-// ComposableGenerator.cpp

-

-// Implements the cComposableGenerator class representing the chunk generator that takes the composition approach to generating chunks

-

-#include "Globals.h"

-

-#include "ComposableGenerator.h"

-#include "../World.h"

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

-#include "../Root.h"

-

-// Individual composed algorithms:

-#include "BioGen.h"

-#include "HeiGen.h"

-#include "CompoGen.h"

-#include "StructGen.h"

-#include "FinishGen.h"

-

-#include "Caves.h"

-#include "DistortedHeightmap.h"

-#include "EndGen.h"

-#include "MineShafts.h"

-#include "Noise3DGenerator.h"

-#include "Ravines.h"

-

-

-

-

-

-

-

-

-

-

-cComposableGenerator::cComposableGenerator(cChunkGenerator & a_ChunkGenerator) :

-	super(a_ChunkGenerator),

-	m_BiomeGen(NULL),

-	m_HeightGen(NULL),

-	m_CompositionGen(NULL),

-	m_UnderlyingBiomeGen(NULL),

-	m_UnderlyingHeightGen(NULL),

-	m_UnderlyingCompositionGen(NULL)

-{

-}

-

-

-

-

-

-cComposableGenerator::~cComposableGenerator()

-{

-	// Delete the generating composition:

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

-	{

-		delete *itr;

-	}

-	m_FinishGens.clear();

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

-	{

-		delete *itr;

-	}

-	m_StructureGens.clear();

-

-	delete m_CompositionGen;

-	m_CompositionGen = NULL;

-	delete m_HeightGen;

-	m_HeightGen = NULL;

-	delete m_BiomeGen;

-	m_BiomeGen = NULL;

-	delete m_UnderlyingCompositionGen;

-	m_UnderlyingCompositionGen = NULL;

-	delete m_UnderlyingHeightGen;

-	m_UnderlyingHeightGen = NULL;

-	delete m_UnderlyingBiomeGen;

-	m_UnderlyingBiomeGen = NULL;

-}

-

-

-

-

-

-void cComposableGenerator::Initialize(cWorld * a_World, cIniFile & a_IniFile)

-{

-	super::Initialize(a_World, a_IniFile);

-	

-	InitBiomeGen(a_IniFile);

-	InitHeightGen(a_IniFile);

-	InitCompositionGen(a_IniFile);

-	InitStructureGens(a_IniFile);

-	InitFinishGens(a_IniFile);

-}

-

-

-

-

-

-void cComposableGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)

-{

-	if (m_BiomeGen != NULL)  // Quick fix for generator deinitializing before the world storage finishes loading

-	{

-		m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);

-	}

-}

-

-

-

-

-

-void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc)

-{

-	if (a_ChunkDesc.IsUsingDefaultBiomes())

-	{

-		m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_ChunkDesc.GetBiomeMap());

-	}

-	

-	if (a_ChunkDesc.IsUsingDefaultHeight())

-	{

-		m_HeightGen->GenHeightMap(a_ChunkX, a_ChunkZ, a_ChunkDesc.GetHeightMap());

-	}

-	

-	if (a_ChunkDesc.IsUsingDefaultComposition())

-	{

-		m_CompositionGen->ComposeTerrain(a_ChunkDesc);

-	}

-

-	if (a_ChunkDesc.IsUsingDefaultStructures())

-	{	

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

-		{

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

-		}   // for itr - m_StructureGens[]

-	}

-	

-	if (a_ChunkDesc.IsUsingDefaultFinish())

-	{

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

-		{

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

-		}  // for itr - m_FinishGens[]

-	}

-}

-

-

-

-

-

-void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)

-{

-	AString BiomeGenName = a_IniFile.GetValueSet("Generator", "BiomeGen", "");

-	if (BiomeGenName.empty())

-	{

-		LOGWARN("[Generator]::BiomeGen value not found in world.ini, using \"MultiStepMap\".");

-		BiomeGenName = "MultiStepMap";

-	}

-	

-	int Seed = m_ChunkGenerator.GetSeed();

-	bool CacheOffByDefault = false;

-	if (NoCaseCompare(BiomeGenName, "constant") == 0)

-	{

-		m_BiomeGen = new cBioGenConstant;

-		CacheOffByDefault = true;  // we're generating faster than a cache would retrieve data :)

-	}

-	else if (NoCaseCompare(BiomeGenName, "checkerboard") == 0)

-	{

-		m_BiomeGen = new cBioGenCheckerboard;

-		CacheOffByDefault = true;  // we're (probably) generating faster than a cache would retrieve data

-	}

-	else if (NoCaseCompare(BiomeGenName, "voronoi") == 0)

-	{

-		m_BiomeGen = new cBioGenVoronoi(Seed);

-	}

-	else if (NoCaseCompare(BiomeGenName, "distortedvoronoi") == 0)

-	{

-		m_BiomeGen = new cBioGenDistortedVoronoi(Seed);

-	}

-	else

-	{

-		if (NoCaseCompare(BiomeGenName, "multistepmap") != 0)

-		{

-			LOGWARNING("Unknown BiomeGen \"%s\", using \"MultiStepMap\" instead.", BiomeGenName.c_str());

-		}

-		m_BiomeGen = new cBioGenMultiStepMap(Seed);

-

-		/*

-		// Performance-testing:

-		LOGINFO("Measuring performance of cBioGenMultiStepMap...");

-		clock_t BeginTick = clock();

-		for (int x = 0; x < 5000; x++)

-		{

-			cChunkDef::BiomeMap Biomes;

-			m_BiomeGen->GenBiomes(x * 5, x * 5, Biomes);

-		}

-		clock_t Duration = clock() - BeginTick;

-		LOGINFO("cBioGenMultiStepMap for 5000 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);

-		//*/

-	}

-	

-	// Add a cache, if requested:

-	int CacheSize = a_IniFile.GetValueSetI("Generator", "BiomeGenCacheSize", CacheOffByDefault ? 0 : 64);

-	if (CacheSize > 0)

-	{

-		if (CacheSize < 4)

-		{

-			LOGWARNING("Biomegen cache size set too low, would hurt performance instead of helping. Increasing from %d to %d", 

-				CacheSize, 4

-			);

-			CacheSize = 4;

-		}

-		LOGINFO("Using a cache for biomegen of size %d.", CacheSize);

-		m_UnderlyingBiomeGen = m_BiomeGen;

-		m_BiomeGen = new cBioGenCache(m_UnderlyingBiomeGen, CacheSize);

-	}

-	m_BiomeGen->Initialize(a_IniFile);

-}

-

-

-

-

-

-void cComposableGenerator::InitHeightGen(cIniFile & a_IniFile)

-{

-	AString HeightGenName = a_IniFile.GetValueSet("Generator", "HeightGen", "");

-	if (HeightGenName.empty())

-	{

-		LOGWARN("[Generator]::HeightGen value not found in world.ini, using \"Biomal\".");

-		HeightGenName = "Biomal";

-	}

-	

-	int Seed = m_ChunkGenerator.GetSeed();

-	bool CacheOffByDefault = false;

-	if (NoCaseCompare(HeightGenName, "flat") == 0)

-	{

-		int Height = a_IniFile.GetValueSetI("Generator", "FlatHeight", 5);

-		m_HeightGen = new cHeiGenFlat(Height);

-		CacheOffByDefault = true;  // We're generating faster than a cache would retrieve data

-	}

-	else if (NoCaseCompare(HeightGenName, "classic") == 0)

-	{

-		// These used to be in terrain.ini, but now they are in world.ini (so that multiple worlds can have different values):

-		float HeightFreq1 = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq1", 0.1);

-		float HeightFreq2 = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq2", 1.0);

-		float HeightFreq3 = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq3", 2.0);

-		float HeightAmp1  = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp1",  1.0);

-		float HeightAmp2  = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp2",  0.5);

-		float HeightAmp3  = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp3",  0.5);

-		m_HeightGen = new cHeiGenClassic(Seed, HeightFreq1, HeightAmp1, HeightFreq2, HeightAmp2, HeightFreq3, HeightAmp3);

-	}

-	else if (NoCaseCompare(HeightGenName, "DistortedHeightmap") == 0)

-	{

-		m_HeightGen = new cDistortedHeightmap(Seed, *m_BiomeGen);

-		((cDistortedHeightmap *)m_HeightGen)->Initialize(a_IniFile);

-	}

-	else if (NoCaseCompare(HeightGenName, "End") == 0)

-	{

-		m_HeightGen = new cEndGen(Seed);

-		((cEndGen *)m_HeightGen)->Initialize(a_IniFile);

-	}

-	else if (NoCaseCompare(HeightGenName, "Noise3D") == 0)

-	{

-		m_HeightGen = new cNoise3DComposable(Seed);

-		((cNoise3DComposable *)m_HeightGen)->Initialize(a_IniFile);

-	}

-	else  // "biomal" or <not found>

-	{

-		if (NoCaseCompare(HeightGenName, "biomal") != 0)

-		{

-			LOGWARN("Unknown HeightGen \"%s\", using \"Biomal\" instead.", HeightGenName.c_str());

-		}

-		m_HeightGen = new cHeiGenBiomal(Seed, *m_BiomeGen);

-

-		/*

-		// Performance-testing:

-		LOGINFO("Measuring performance of cHeiGenBiomal...");

-		clock_t BeginTick = clock();

-		for (int x = 0; x < 500; x++)

-		{

-			cChunkDef::HeightMap Heights;

-			m_HeightGen->GenHeightMap(x * 5, x * 5, Heights);

-		}

-		clock_t Duration = clock() - BeginTick;

-		LOGINFO("HeightGen for 500 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);

-		//*/

-	}

-	

-	// Add a cache, if requested:

-	int CacheSize = a_IniFile.GetValueSetI("Generator", "HeightGenCacheSize", CacheOffByDefault ? 0 : 64);

-	if (CacheSize > 0)

-	{

-		if (CacheSize < 4)

-		{

-			LOGWARNING("Heightgen cache size set too low, would hurt performance instead of helping. Increasing from %d to %d", 

-				CacheSize, 4

-			);

-			CacheSize = 4;

-		}

-		LOGINFO("Using a cache for Heightgen of size %d.", CacheSize);

-		m_UnderlyingHeightGen = m_HeightGen;

-		m_HeightGen = new cHeiGenCache(m_UnderlyingHeightGen, CacheSize);

-	}

-}

-

-

-

-

-

-void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)

-{

-	AString CompoGenName = a_IniFile.GetValueSet("Generator", "CompositionGen", "");

-	if (CompoGenName.empty())

-	{

-		LOGWARN("[Generator]::CompositionGen value not found in world.ini, using \"Biomal\".");

-		CompoGenName = "Biomal";

-	}

-	if (NoCaseCompare(CompoGenName, "sameblock") == 0)

-	{

-		int Block = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "SameBlockType", "stone");

-		bool Bedrocked = (a_IniFile.GetValueSetI("Generator", "SameBlockBedrocked", 1) != 0);

-		m_CompositionGen = new cCompoGenSameBlock((BLOCKTYPE)Block, Bedrocked);

-	}

-	else if (NoCaseCompare(CompoGenName, "debugbiomes") == 0)

-	{

-		m_CompositionGen = new cCompoGenDebugBiomes;

-	}

-	else if (NoCaseCompare(CompoGenName, "classic") == 0)

-	{

-		int SeaLevel    = a_IniFile.GetValueSetI("Generator", "ClassicSeaLevel", 60);

-		int BeachHeight = a_IniFile.GetValueSetI("Generator", "ClassicBeachHeight", 2);

-		int BeachDepth  = a_IniFile.GetValueSetI("Generator", "ClassicBeachDepth", 4);

-		BLOCKTYPE BlockTop         = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockTop",         "grass");

-		BLOCKTYPE BlockMiddle      = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockMiddle",      "dirt");

-		BLOCKTYPE BlockBottom      = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockBottom",      "stone");

-		BLOCKTYPE BlockBeach       = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockBeach",       "sand");

-		BLOCKTYPE BlockBeachBottom = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockBeachBottom", "sandstone");

-		BLOCKTYPE BlockSea         = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockSea",         "stationarywater");

-		m_CompositionGen = new cCompoGenClassic(

-			SeaLevel, BeachHeight, BeachDepth, BlockTop, BlockMiddle, BlockBottom, BlockBeach,

-			BlockBeachBottom, BlockSea

-		);

-	}

-	else if (NoCaseCompare(CompoGenName, "DistortedHeightmap") == 0)

-	{

-		m_CompositionGen = new cDistortedHeightmap(m_ChunkGenerator.GetSeed(), *m_BiomeGen);

-		((cDistortedHeightmap *)m_CompositionGen)->Initialize(a_IniFile);

-	}

-	else if (NoCaseCompare(CompoGenName, "end") == 0)

-	{

-		m_CompositionGen = new cEndGen(m_ChunkGenerator.GetSeed());

-		((cEndGen *)m_CompositionGen)->Initialize(a_IniFile);

-	}

-	else if (NoCaseCompare(CompoGenName, "nether") == 0)

-	{

-		m_CompositionGen = new cCompoGenNether(m_ChunkGenerator.GetSeed());

-	}

-	else if (NoCaseCompare(CompoGenName, "Noise3D") == 0)

-	{

-		m_CompositionGen = new cNoise3DComposable(m_ChunkGenerator.GetSeed());

-		((cNoise3DComposable *)m_CompositionGen)->Initialize(a_IniFile);

-	}

-	else

-	{

-		if (NoCaseCompare(CompoGenName, "biomal") != 0)

-		{

-			LOGWARN("Unknown CompositionGen \"%s\", using \"biomal\" instead.", CompoGenName.c_str());

-		}

-		int SeaLevel = a_IniFile.GetValueSetI("Generator", "BiomalSeaLevel", 62);

-		int Seed = m_ChunkGenerator.GetSeed();

-		m_CompositionGen = new cCompoGenBiomal(Seed, SeaLevel);

-

-		/*

-		// Performance-testing:

-		LOGINFO("Measuring performance of cCompoGenBiomal...");

-		clock_t BeginTick = clock();

-		for (int x = 0; x < 500; x++)

-		{

-			cChunkDesc Desc(200 + x * 8, 200 + x * 8);

-			m_BiomeGen->GenBiomes(Desc.GetChunkX(), Desc.GetChunkZ(), Desc.GetBiomeMap());

-			m_HeightGen->GenHeightMap(Desc.GetChunkX(), Desc.GetChunkZ(), Desc.GetHeightMap());

-			m_CompositionGen->ComposeTerrain(Desc);

-		}

-		clock_t Duration = clock() - BeginTick;

-		LOGINFO("CompositionGen for 500 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);

-		//*/

-	}

-	

-	int CompoGenCacheSize = a_IniFile.GetValueSetI("Generator", "CompositionGenCacheSize", 64);

-	if (CompoGenCacheSize > 1)

-	{

-		m_UnderlyingCompositionGen = m_CompositionGen;

-		m_CompositionGen = new cCompoGenCache(m_UnderlyingCompositionGen, 32);

-	}

-}

-

-

-

-

-

-void cComposableGenerator::InitStructureGens(cIniFile & a_IniFile)

-{

-	AString Structures = a_IniFile.GetValueSet("Generator", "Structures", "Ravines, WormNestCaves, WaterLakes, LavaLakes, OreNests, Trees");

-

-	int Seed = m_ChunkGenerator.GetSeed();

-	AStringVector Str = StringSplitAndTrim(Structures, ",");

-	for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)

-	{

-		if (NoCaseCompare(*itr, "DualRidgeCaves") == 0)

-		{

-			float Threshold = (float)a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3);

-			m_StructureGens.push_back(new cStructGenDualRidgeCaves(Seed, Threshold));

-		}

-		else if (NoCaseCompare(*itr, "DirectOverhangs") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenDirectOverhangs(Seed));

-		}

-		else if (NoCaseCompare(*itr, "DistortedMembraneOverhangs") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenDistortedMembraneOverhangs(Seed));

-		}

-		else if (NoCaseCompare(*itr, "LavaLakes") == 0)

-		{

-			int Probability = a_IniFile.GetValueSetI("Generator", "LavaLakesProbability", 10);

-			m_StructureGens.push_back(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, *m_HeightGen, Probability));

-		}

-		else if (NoCaseCompare(*itr, "MarbleCaves") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenMarbleCaves(Seed));

-		}

-		else if (NoCaseCompare(*itr, "MineShafts") == 0)

-		{

-			int GridSize        = a_IniFile.GetValueSetI("Generator", "MineShaftsGridSize",        512);

-			int MaxSystemSize   = a_IniFile.GetValueSetI("Generator", "MineShaftsMaxSystemSize",   160);

-			int ChanceCorridor  = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCorridor",  600);

-			int ChanceCrossing  = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCrossing",  200);

-			int ChanceStaircase = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceStaircase", 200);

-			m_StructureGens.push_back(new cStructGenMineShafts(

-				Seed, GridSize, MaxSystemSize, 

-				ChanceCorridor, ChanceCrossing, ChanceStaircase

-			));

-		}

-		else if (NoCaseCompare(*itr, "OreNests") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenOreNests(Seed));

-		}

-		else if (NoCaseCompare(*itr, "Ravines") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenRavines(Seed, 128));

-		}

-		else if (NoCaseCompare(*itr, "Trees") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));

-		}

-		else if (NoCaseCompare(*itr, "WaterLakes") == 0)

-		{

-			int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);

-			m_StructureGens.push_back(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, *m_HeightGen, Probability));

-		}

-		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)

-		{

-			m_StructureGens.push_back(new cStructGenWormNestCaves(Seed));

-		}

-		else

-		{

-			LOGWARNING("Unknown structure generator: \"%s\". Ignoring.", itr->c_str());

-		}

-	}  // for itr - Str[]

-}

-

-

-

-

-

-void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)

-{

-	int Seed = m_ChunkGenerator.GetSeed();

-	AString Structures = a_IniFile.GetValueSet("Generator", "Finishers", "SprinkleFoliage,Ice,Snow,Lilypads,BottomLava,DeadBushes,PreSimulator");

-

-	AStringVector Str = StringSplitAndTrim(Structures, ",");

-	for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)

-	{

-		// Finishers, alpha-sorted:

-		if (NoCaseCompare(*itr, "BottomLava") == 0)

-		{

-			int DefaultBottomLavaLevel = (m_World->GetDimension() == dimNether) ? 30 : 10;

-			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);

-			m_FinishGens.push_back(new cFinishGenBottomLava(BottomLavaLevel));

-		}

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

-		{

-			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)

-		{

-			m_FinishGens.push_back(new cFinishGenIce);

-		}

-		else if (NoCaseCompare(*itr, "LavaSprings") == 0)

-		{

-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, *m_World));

-		}

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

-		{

-			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)

-		{

-			m_FinishGens.push_back(new cFinishGenPreSimulator);

-		}

-		else if (NoCaseCompare(*itr, "Snow") == 0)

-		{

-			m_FinishGens.push_back(new cFinishGenSnow);

-		}

-		else if (NoCaseCompare(*itr, "SprinkleFoliage") == 0)

-		{

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

-		}

-		else if (NoCaseCompare(*itr, "WaterSprings") == 0)

-		{

-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, *m_World));

-		}

-	}  // for itr - Str[]

-}

-

-

-

-

+
+// ComposableGenerator.cpp
+
+// Implements the cComposableGenerator class representing the chunk generator that takes the composition approach to generating chunks
+
+#include "Globals.h"
+
+#include "ComposableGenerator.h"
+#include "../World.h"
+#include "../../iniFile/iniFile.h"
+#include "../Root.h"
+
+// Individual composed algorithms:
+#include "BioGen.h"
+#include "HeiGen.h"
+#include "CompoGen.h"
+#include "StructGen.h"
+#include "FinishGen.h"
+
+#include "Caves.h"
+#include "DistortedHeightmap.h"
+#include "EndGen.h"
+#include "MineShafts.h"
+#include "Noise3DGenerator.h"
+#include "Ravines.h"
+
+
+
+
+
+
+
+
+
+
+cComposableGenerator::cComposableGenerator(cChunkGenerator & a_ChunkGenerator) :
+	super(a_ChunkGenerator),
+	m_BiomeGen(NULL),
+	m_HeightGen(NULL),
+	m_CompositionGen(NULL),
+	m_UnderlyingBiomeGen(NULL),
+	m_UnderlyingHeightGen(NULL),
+	m_UnderlyingCompositionGen(NULL)
+{
+}
+
+
+
+
+
+cComposableGenerator::~cComposableGenerator()
+{
+	// Delete the generating composition:
+	for (cFinishGenList::const_iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)
+	{
+		delete *itr;
+	}
+	m_FinishGens.clear();
+	for (cStructureGenList::const_iterator itr = m_StructureGens.begin(); itr != m_StructureGens.end(); ++itr)
+	{
+		delete *itr;
+	}
+	m_StructureGens.clear();
+
+	delete m_CompositionGen;
+	m_CompositionGen = NULL;
+	delete m_HeightGen;
+	m_HeightGen = NULL;
+	delete m_BiomeGen;
+	m_BiomeGen = NULL;
+	delete m_UnderlyingCompositionGen;
+	m_UnderlyingCompositionGen = NULL;
+	delete m_UnderlyingHeightGen;
+	m_UnderlyingHeightGen = NULL;
+	delete m_UnderlyingBiomeGen;
+	m_UnderlyingBiomeGen = NULL;
+}
+
+
+
+
+
+void cComposableGenerator::Initialize(cWorld * a_World, cIniFile & a_IniFile)
+{
+	super::Initialize(a_World, a_IniFile);
+	
+	InitBiomeGen(a_IniFile);
+	InitHeightGen(a_IniFile);
+	InitCompositionGen(a_IniFile);
+	InitStructureGens(a_IniFile);
+	InitFinishGens(a_IniFile);
+}
+
+
+
+
+
+void cComposableGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)
+{
+	if (m_BiomeGen != NULL)  // Quick fix for generator deinitializing before the world storage finishes loading
+	{
+		m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);
+	}
+}
+
+
+
+
+
+void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc)
+{
+	if (a_ChunkDesc.IsUsingDefaultBiomes())
+	{
+		m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_ChunkDesc.GetBiomeMap());
+	}
+	
+	if (a_ChunkDesc.IsUsingDefaultHeight())
+	{
+		m_HeightGen->GenHeightMap(a_ChunkX, a_ChunkZ, a_ChunkDesc.GetHeightMap());
+	}
+	
+	if (a_ChunkDesc.IsUsingDefaultComposition())
+	{
+		m_CompositionGen->ComposeTerrain(a_ChunkDesc);
+	}
+
+	if (a_ChunkDesc.IsUsingDefaultStructures())
+	{	
+		for (cStructureGenList::iterator itr = m_StructureGens.begin(); itr != m_StructureGens.end(); ++itr)
+		{
+			(*itr)->GenStructures(a_ChunkDesc);
+		}   // for itr - m_StructureGens[]
+	}
+	
+	if (a_ChunkDesc.IsUsingDefaultFinish())
+	{
+		for (cFinishGenList::iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)
+		{
+			(*itr)->GenFinish(a_ChunkDesc);
+		}  // for itr - m_FinishGens[]
+	}
+}
+
+
+
+
+
+void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)
+{
+	AString BiomeGenName = a_IniFile.GetValueSet("Generator", "BiomeGen", "");
+	if (BiomeGenName.empty())
+	{
+		LOGWARN("[Generator]::BiomeGen value not found in world.ini, using \"MultiStepMap\".");
+		BiomeGenName = "MultiStepMap";
+	}
+	
+	int Seed = m_ChunkGenerator.GetSeed();
+	bool CacheOffByDefault = false;
+	if (NoCaseCompare(BiomeGenName, "constant") == 0)
+	{
+		m_BiomeGen = new cBioGenConstant;
+		CacheOffByDefault = true;  // we're generating faster than a cache would retrieve data :)
+	}
+	else if (NoCaseCompare(BiomeGenName, "checkerboard") == 0)
+	{
+		m_BiomeGen = new cBioGenCheckerboard;
+		CacheOffByDefault = true;  // we're (probably) generating faster than a cache would retrieve data
+	}
+	else if (NoCaseCompare(BiomeGenName, "voronoi") == 0)
+	{
+		m_BiomeGen = new cBioGenVoronoi(Seed);
+	}
+	else if (NoCaseCompare(BiomeGenName, "distortedvoronoi") == 0)
+	{
+		m_BiomeGen = new cBioGenDistortedVoronoi(Seed);
+	}
+	else
+	{
+		if (NoCaseCompare(BiomeGenName, "multistepmap") != 0)
+		{
+			LOGWARNING("Unknown BiomeGen \"%s\", using \"MultiStepMap\" instead.", BiomeGenName.c_str());
+		}
+		m_BiomeGen = new cBioGenMultiStepMap(Seed);
+
+		/*
+		// Performance-testing:
+		LOGINFO("Measuring performance of cBioGenMultiStepMap...");
+		clock_t BeginTick = clock();
+		for (int x = 0; x < 5000; x++)
+		{
+			cChunkDef::BiomeMap Biomes;
+			m_BiomeGen->GenBiomes(x * 5, x * 5, Biomes);
+		}
+		clock_t Duration = clock() - BeginTick;
+		LOGINFO("cBioGenMultiStepMap for 5000 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);
+		//*/
+	}
+	
+	// Add a cache, if requested:
+	int CacheSize = a_IniFile.GetValueSetI("Generator", "BiomeGenCacheSize", CacheOffByDefault ? 0 : 64);
+	if (CacheSize > 0)
+	{
+		if (CacheSize < 4)
+		{
+			LOGWARNING("Biomegen cache size set too low, would hurt performance instead of helping. Increasing from %d to %d", 
+				CacheSize, 4
+			);
+			CacheSize = 4;
+		}
+		LOGINFO("Using a cache for biomegen of size %d.", CacheSize);
+		m_UnderlyingBiomeGen = m_BiomeGen;
+		m_BiomeGen = new cBioGenCache(m_UnderlyingBiomeGen, CacheSize);
+	}
+	m_BiomeGen->Initialize(a_IniFile);
+}
+
+
+
+
+
+void cComposableGenerator::InitHeightGen(cIniFile & a_IniFile)
+{
+	AString HeightGenName = a_IniFile.GetValueSet("Generator", "HeightGen", "");
+	if (HeightGenName.empty())
+	{
+		LOGWARN("[Generator]::HeightGen value not found in world.ini, using \"Biomal\".");
+		HeightGenName = "Biomal";
+	}
+	
+	int Seed = m_ChunkGenerator.GetSeed();
+	bool CacheOffByDefault = false;
+	if (NoCaseCompare(HeightGenName, "flat") == 0)
+	{
+		int Height = a_IniFile.GetValueSetI("Generator", "FlatHeight", 5);
+		m_HeightGen = new cHeiGenFlat(Height);
+		CacheOffByDefault = true;  // We're generating faster than a cache would retrieve data
+	}
+	else if (NoCaseCompare(HeightGenName, "classic") == 0)
+	{
+		// These used to be in terrain.ini, but now they are in world.ini (so that multiple worlds can have different values):
+		float HeightFreq1 = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq1", 0.1);
+		float HeightFreq2 = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq2", 1.0);
+		float HeightFreq3 = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq3", 2.0);
+		float HeightAmp1  = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp1",  1.0);
+		float HeightAmp2  = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp2",  0.5);
+		float HeightAmp3  = (float)a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp3",  0.5);
+		m_HeightGen = new cHeiGenClassic(Seed, HeightFreq1, HeightAmp1, HeightFreq2, HeightAmp2, HeightFreq3, HeightAmp3);
+	}
+	else if (NoCaseCompare(HeightGenName, "DistortedHeightmap") == 0)
+	{
+		m_HeightGen = new cDistortedHeightmap(Seed, *m_BiomeGen);
+		((cDistortedHeightmap *)m_HeightGen)->Initialize(a_IniFile);
+	}
+	else if (NoCaseCompare(HeightGenName, "End") == 0)
+	{
+		m_HeightGen = new cEndGen(Seed);
+		((cEndGen *)m_HeightGen)->Initialize(a_IniFile);
+	}
+	else if (NoCaseCompare(HeightGenName, "Noise3D") == 0)
+	{
+		m_HeightGen = new cNoise3DComposable(Seed);
+		((cNoise3DComposable *)m_HeightGen)->Initialize(a_IniFile);
+	}
+	else  // "biomal" or <not found>
+	{
+		if (NoCaseCompare(HeightGenName, "biomal") != 0)
+		{
+			LOGWARN("Unknown HeightGen \"%s\", using \"Biomal\" instead.", HeightGenName.c_str());
+		}
+		m_HeightGen = new cHeiGenBiomal(Seed, *m_BiomeGen);
+
+		/*
+		// Performance-testing:
+		LOGINFO("Measuring performance of cHeiGenBiomal...");
+		clock_t BeginTick = clock();
+		for (int x = 0; x < 500; x++)
+		{
+			cChunkDef::HeightMap Heights;
+			m_HeightGen->GenHeightMap(x * 5, x * 5, Heights);
+		}
+		clock_t Duration = clock() - BeginTick;
+		LOGINFO("HeightGen for 500 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);
+		//*/
+	}
+	
+	// Add a cache, if requested:
+	int CacheSize = a_IniFile.GetValueSetI("Generator", "HeightGenCacheSize", CacheOffByDefault ? 0 : 64);
+	if (CacheSize > 0)
+	{
+		if (CacheSize < 4)
+		{
+			LOGWARNING("Heightgen cache size set too low, would hurt performance instead of helping. Increasing from %d to %d", 
+				CacheSize, 4
+			);
+			CacheSize = 4;
+		}
+		LOGINFO("Using a cache for Heightgen of size %d.", CacheSize);
+		m_UnderlyingHeightGen = m_HeightGen;
+		m_HeightGen = new cHeiGenCache(m_UnderlyingHeightGen, CacheSize);
+	}
+}
+
+
+
+
+
+void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
+{
+	AString CompoGenName = a_IniFile.GetValueSet("Generator", "CompositionGen", "");
+	if (CompoGenName.empty())
+	{
+		LOGWARN("[Generator]::CompositionGen value not found in world.ini, using \"Biomal\".");
+		CompoGenName = "Biomal";
+	}
+	if (NoCaseCompare(CompoGenName, "sameblock") == 0)
+	{
+		int Block = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "SameBlockType", "stone");
+		bool Bedrocked = (a_IniFile.GetValueSetI("Generator", "SameBlockBedrocked", 1) != 0);
+		m_CompositionGen = new cCompoGenSameBlock((BLOCKTYPE)Block, Bedrocked);
+	}
+	else if (NoCaseCompare(CompoGenName, "debugbiomes") == 0)
+	{
+		m_CompositionGen = new cCompoGenDebugBiomes;
+	}
+	else if (NoCaseCompare(CompoGenName, "classic") == 0)
+	{
+		int SeaLevel    = a_IniFile.GetValueSetI("Generator", "ClassicSeaLevel", 60);
+		int BeachHeight = a_IniFile.GetValueSetI("Generator", "ClassicBeachHeight", 2);
+		int BeachDepth  = a_IniFile.GetValueSetI("Generator", "ClassicBeachDepth", 4);
+		BLOCKTYPE BlockTop         = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockTop",         "grass");
+		BLOCKTYPE BlockMiddle      = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockMiddle",      "dirt");
+		BLOCKTYPE BlockBottom      = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockBottom",      "stone");
+		BLOCKTYPE BlockBeach       = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockBeach",       "sand");
+		BLOCKTYPE BlockBeachBottom = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockBeachBottom", "sandstone");
+		BLOCKTYPE BlockSea         = m_ChunkGenerator.GetIniBlock(a_IniFile, "Generator", "ClassicBlockSea",         "stationarywater");
+		m_CompositionGen = new cCompoGenClassic(
+			SeaLevel, BeachHeight, BeachDepth, BlockTop, BlockMiddle, BlockBottom, BlockBeach,
+			BlockBeachBottom, BlockSea
+		);
+	}
+	else if (NoCaseCompare(CompoGenName, "DistortedHeightmap") == 0)
+	{
+		m_CompositionGen = new cDistortedHeightmap(m_ChunkGenerator.GetSeed(), *m_BiomeGen);
+		((cDistortedHeightmap *)m_CompositionGen)->Initialize(a_IniFile);
+	}
+	else if (NoCaseCompare(CompoGenName, "end") == 0)
+	{
+		m_CompositionGen = new cEndGen(m_ChunkGenerator.GetSeed());
+		((cEndGen *)m_CompositionGen)->Initialize(a_IniFile);
+	}
+	else if (NoCaseCompare(CompoGenName, "nether") == 0)
+	{
+		m_CompositionGen = new cCompoGenNether(m_ChunkGenerator.GetSeed());
+	}
+	else if (NoCaseCompare(CompoGenName, "Noise3D") == 0)
+	{
+		m_CompositionGen = new cNoise3DComposable(m_ChunkGenerator.GetSeed());
+		((cNoise3DComposable *)m_CompositionGen)->Initialize(a_IniFile);
+	}
+	else
+	{
+		if (NoCaseCompare(CompoGenName, "biomal") != 0)
+		{
+			LOGWARN("Unknown CompositionGen \"%s\", using \"biomal\" instead.", CompoGenName.c_str());
+		}
+		int SeaLevel = a_IniFile.GetValueSetI("Generator", "BiomalSeaLevel", 62);
+		int Seed = m_ChunkGenerator.GetSeed();
+		m_CompositionGen = new cCompoGenBiomal(Seed, SeaLevel);
+
+		/*
+		// Performance-testing:
+		LOGINFO("Measuring performance of cCompoGenBiomal...");
+		clock_t BeginTick = clock();
+		for (int x = 0; x < 500; x++)
+		{
+			cChunkDesc Desc(200 + x * 8, 200 + x * 8);
+			m_BiomeGen->GenBiomes(Desc.GetChunkX(), Desc.GetChunkZ(), Desc.GetBiomeMap());
+			m_HeightGen->GenHeightMap(Desc.GetChunkX(), Desc.GetChunkZ(), Desc.GetHeightMap());
+			m_CompositionGen->ComposeTerrain(Desc);
+		}
+		clock_t Duration = clock() - BeginTick;
+		LOGINFO("CompositionGen for 500 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);
+		//*/
+	}
+	
+	int CompoGenCacheSize = a_IniFile.GetValueSetI("Generator", "CompositionGenCacheSize", 64);
+	if (CompoGenCacheSize > 1)
+	{
+		m_UnderlyingCompositionGen = m_CompositionGen;
+		m_CompositionGen = new cCompoGenCache(m_UnderlyingCompositionGen, 32);
+	}
+}
+
+
+
+
+
+void cComposableGenerator::InitStructureGens(cIniFile & a_IniFile)
+{
+	AString Structures = a_IniFile.GetValueSet("Generator", "Structures", "Ravines, WormNestCaves, WaterLakes, LavaLakes, OreNests, Trees");
+
+	int Seed = m_ChunkGenerator.GetSeed();
+	AStringVector Str = StringSplitAndTrim(Structures, ",");
+	for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)
+	{
+		if (NoCaseCompare(*itr, "DualRidgeCaves") == 0)
+		{
+			float Threshold = (float)a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3);
+			m_StructureGens.push_back(new cStructGenDualRidgeCaves(Seed, Threshold));
+		}
+		else if (NoCaseCompare(*itr, "DirectOverhangs") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenDirectOverhangs(Seed));
+		}
+		else if (NoCaseCompare(*itr, "DistortedMembraneOverhangs") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenDistortedMembraneOverhangs(Seed));
+		}
+		else if (NoCaseCompare(*itr, "LavaLakes") == 0)
+		{
+			int Probability = a_IniFile.GetValueSetI("Generator", "LavaLakesProbability", 10);
+			m_StructureGens.push_back(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, *m_HeightGen, Probability));
+		}
+		else if (NoCaseCompare(*itr, "MarbleCaves") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenMarbleCaves(Seed));
+		}
+		else if (NoCaseCompare(*itr, "MineShafts") == 0)
+		{
+			int GridSize        = a_IniFile.GetValueSetI("Generator", "MineShaftsGridSize",        512);
+			int MaxSystemSize   = a_IniFile.GetValueSetI("Generator", "MineShaftsMaxSystemSize",   160);
+			int ChanceCorridor  = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCorridor",  600);
+			int ChanceCrossing  = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCrossing",  200);
+			int ChanceStaircase = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceStaircase", 200);
+			m_StructureGens.push_back(new cStructGenMineShafts(
+				Seed, GridSize, MaxSystemSize, 
+				ChanceCorridor, ChanceCrossing, ChanceStaircase
+			));
+		}
+		else if (NoCaseCompare(*itr, "OreNests") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenOreNests(Seed));
+		}
+		else if (NoCaseCompare(*itr, "Ravines") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenRavines(Seed, 128));
+		}
+		else if (NoCaseCompare(*itr, "Trees") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));
+		}
+		else if (NoCaseCompare(*itr, "WaterLakes") == 0)
+		{
+			int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);
+			m_StructureGens.push_back(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, *m_HeightGen, Probability));
+		}
+		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)
+		{
+			m_StructureGens.push_back(new cStructGenWormNestCaves(Seed));
+		}
+		else
+		{
+			LOGWARNING("Unknown structure generator: \"%s\". Ignoring.", itr->c_str());
+		}
+	}  // for itr - Str[]
+}
+
+
+
+
+
+void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
+{
+	int Seed = m_ChunkGenerator.GetSeed();
+	AString Structures = a_IniFile.GetValueSet("Generator", "Finishers", "SprinkleFoliage,Ice,Snow,Lilypads,BottomLava,DeadBushes,PreSimulator");
+
+	AStringVector Str = StringSplitAndTrim(Structures, ",");
+	for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)
+	{
+		// Finishers, alpha-sorted:
+		if (NoCaseCompare(*itr, "BottomLava") == 0)
+		{
+			int DefaultBottomLavaLevel = (m_World->GetDimension() == dimNether) ? 30 : 10;
+			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
+			m_FinishGens.push_back(new cFinishGenBottomLava(BottomLavaLevel));
+		}
+		else if (NoCaseCompare(*itr, "DeadBushes") == 0)
+		{
+			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)
+		{
+			m_FinishGens.push_back(new cFinishGenIce);
+		}
+		else if (NoCaseCompare(*itr, "LavaSprings") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, *m_World));
+		}
+		else if (NoCaseCompare(*itr, "Lilypads") == 0)
+		{
+			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)
+		{
+			m_FinishGens.push_back(new cFinishGenPreSimulator);
+		}
+		else if (NoCaseCompare(*itr, "Snow") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenSnow);
+		}
+		else if (NoCaseCompare(*itr, "SprinkleFoliage") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenSprinkleFoliage(Seed));
+		}
+		else if (NoCaseCompare(*itr, "WaterSprings") == 0)
+		{
+			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, *m_World));
+		}
+	}  // for itr - Str[]
+}
+
+
+
+
diff --git a/source/Generating/ComposableGenerator.h b/source/Generating/ComposableGenerator.h
index c32e7181f..1d5c98e5d 100644
--- a/source/Generating/ComposableGenerator.h
+++ b/source/Generating/ComposableGenerator.h
@@ -1,175 +1,175 @@
-

-// ComposableGenerator.h

-

-// Declares the cComposableGenerator class representing the chunk generator that takes the composition approach to generating chunks

-

-/*

-Generating works by composing several algorithms:

-Biome, TerrainHeight, TerrainComposition, Ores, Structures and SmallFoliage

-Each algorithm may be chosen from a pool of available algorithms in the same class and combined with others,

-based on user's preferences in the world.ini.

-See http://forum.mc-server.org/showthread.php?tid=409 for details.

-*/

-

-

-

-

-

-#pragma once

-

-#include "ChunkGenerator.h"

-#include "ChunkDesc.h"

-

-

-

-

-

-// fwd: Noise3DGenerator.h

-class cNoise3DComposable;

-

-// fwd: DistortedHeightmap.h

-class cDistortedHeightmap;

-

-

-

-

-

-/** The interface that a biome generator must implement

-A biome generator takes chunk coords on input and outputs an array of biome indices for that chunk on output.

-The output array is sequenced in the same way as the MapChunk packet's biome data.

-*/

-class cBiomeGen

-{

-public:

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

-	

-	/// Generates biomes for the given chunk

-	virtual void GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) = 0;

-	

-	/// Reads parameters from the ini file, prepares generator for use.

-	virtual void Initialize(cIniFile & a_IniFile) {}

-} ;

-

-

-

-

-

-/** The interface that a terrain height generator must implement

-A terrain height generator takes chunk coords on input and outputs an array of terrain heights for that chunk.

-The output array is sequenced in the same way as the BiomeGen's biome data.

-The generator may request biome information from the underlying BiomeGen, it may even request information for

-other chunks than the one it's currently generating (possibly neighbors - for averaging)

-*/

-class cTerrainHeightGen

-{

-public:

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

-	

-	/// Generates heightmap for the given chunk

-	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) = 0;

-} ;

-

-

-

-

-

-/** The interface that a terrain composition generator must implement

-Terrain composition takes chunk coords on input and outputs the blockdata for that entire chunk, along with

-the list of entities. It is supposed to make use of the underlying TerrainHeightGen and BiomeGen for that purpose,

-but it may request information for other chunks than the one it's currently generating from them.

-*/

-class cTerrainCompositionGen

-{

-public:

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

-	

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

-} ;

-

-

-

-

-

-/** The interface that a structure generator must implement

-Structures are generated after the terrain composition took place. It should modify the blocktype data to account

-for whatever structures the generator is generating.

-Note that ores are considered structures too, at least from the interface point of view.

-Also note that a worldgenerator may contain multiple structure generators, one for each type of structure

-*/

-class cStructureGen

-{

-public:

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

-	

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

-} ;

-

-typedef std::list<cStructureGen *> cStructureGenList;

-

-

-

-

-

-/** The interface that a finisher must implement

-Finisher implements small additions after all structures have been generated.

-*/

-class cFinishGen

-{

-public:

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

-	

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

-} ;

-

-typedef std::list<cFinishGen *> cFinishGenList;

-

-

-

-

-

-class cComposableGenerator :

-	public cChunkGenerator::cGenerator

-{

-	typedef cChunkGenerator::cGenerator super;

-	

-public:

-	cComposableGenerator(cChunkGenerator & a_ChunkGenerator);

-	virtual ~cComposableGenerator();

-	

-	virtual void Initialize(cWorld * a_World, cIniFile & a_IniFile) override;

-	virtual void GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) override;

-	virtual void DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc) override;

-

-protected:

-	// The generation composition:

-	cBiomeGen *              m_BiomeGen;

-	cTerrainHeightGen *      m_HeightGen;

-	cTerrainCompositionGen * m_CompositionGen;

-	cStructureGenList        m_StructureGens;

-	cFinishGenList           m_FinishGens;

-	

-	// Generators underlying the caches:

-	cBiomeGen *              m_UnderlyingBiomeGen;

-	cTerrainHeightGen *      m_UnderlyingHeightGen;

-	cTerrainCompositionGen * m_UnderlyingCompositionGen;

-	

-	

-	/// Reads the biome gen settings from the ini and initializes m_BiomeGen accordingly

-	void InitBiomeGen(cIniFile & a_IniFile);

-	

-	/// Reads the HeightGen settings from the ini and initializes m_HeightGen accordingly

-	void InitHeightGen(cIniFile & a_IniFile);

-	

-	/// Reads the CompositionGen settings from the ini and initializes m_CompositionGen accordingly

-	void InitCompositionGen(cIniFile & a_IniFile);

-	

-	/// Reads the structures to generate from the ini and initializes m_StructureGens accordingly

-	void InitStructureGens(cIniFile & a_IniFile);

-	

-	/// Reads the finishers from the ini and initializes m_FinishGens accordingly

-	void InitFinishGens(cIniFile & a_IniFile);

-} ;

-

-

-

-

+
+// ComposableGenerator.h
+
+// Declares the cComposableGenerator class representing the chunk generator that takes the composition approach to generating chunks
+
+/*
+Generating works by composing several algorithms:
+Biome, TerrainHeight, TerrainComposition, Ores, Structures and SmallFoliage
+Each algorithm may be chosen from a pool of available algorithms in the same class and combined with others,
+based on user's preferences in the world.ini.
+See http://forum.mc-server.org/showthread.php?tid=409 for details.
+*/
+
+
+
+
+
+#pragma once
+
+#include "ChunkGenerator.h"
+#include "ChunkDesc.h"
+
+
+
+
+
+// fwd: Noise3DGenerator.h
+class cNoise3DComposable;
+
+// fwd: DistortedHeightmap.h
+class cDistortedHeightmap;
+
+
+
+
+
+/** The interface that a biome generator must implement
+A biome generator takes chunk coords on input and outputs an array of biome indices for that chunk on output.
+The output array is sequenced in the same way as the MapChunk packet's biome data.
+*/
+class cBiomeGen
+{
+public:
+	virtual ~cBiomeGen() {}  // Force a virtual destructor in descendants
+	
+	/// Generates biomes for the given chunk
+	virtual void GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) = 0;
+	
+	/// Reads parameters from the ini file, prepares generator for use.
+	virtual void Initialize(cIniFile & a_IniFile) {}
+} ;
+
+
+
+
+
+/** The interface that a terrain height generator must implement
+A terrain height generator takes chunk coords on input and outputs an array of terrain heights for that chunk.
+The output array is sequenced in the same way as the BiomeGen's biome data.
+The generator may request biome information from the underlying BiomeGen, it may even request information for
+other chunks than the one it's currently generating (possibly neighbors - for averaging)
+*/
+class cTerrainHeightGen
+{
+public:
+	virtual ~cTerrainHeightGen() {}  // Force a virtual destructor in descendants
+	
+	/// Generates heightmap for the given chunk
+	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) = 0;
+} ;
+
+
+
+
+
+/** The interface that a terrain composition generator must implement
+Terrain composition takes chunk coords on input and outputs the blockdata for that entire chunk, along with
+the list of entities. It is supposed to make use of the underlying TerrainHeightGen and BiomeGen for that purpose,
+but it may request information for other chunks than the one it's currently generating from them.
+*/
+class cTerrainCompositionGen
+{
+public:
+	virtual ~cTerrainCompositionGen() {}  // Force a virtual destructor in descendants
+	
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) = 0;
+} ;
+
+
+
+
+
+/** The interface that a structure generator must implement
+Structures are generated after the terrain composition took place. It should modify the blocktype data to account
+for whatever structures the generator is generating.
+Note that ores are considered structures too, at least from the interface point of view.
+Also note that a worldgenerator may contain multiple structure generators, one for each type of structure
+*/
+class cStructureGen
+{
+public:
+	virtual ~cStructureGen() {}  // Force a virtual destructor in descendants
+	
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) = 0;
+} ;
+
+typedef std::list<cStructureGen *> cStructureGenList;
+
+
+
+
+
+/** The interface that a finisher must implement
+Finisher implements small additions after all structures have been generated.
+*/
+class cFinishGen
+{
+public:
+	virtual ~cFinishGen() {}  // Force a virtual destructor in descendants
+	
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) = 0;
+} ;
+
+typedef std::list<cFinishGen *> cFinishGenList;
+
+
+
+
+
+class cComposableGenerator :
+	public cChunkGenerator::cGenerator
+{
+	typedef cChunkGenerator::cGenerator super;
+	
+public:
+	cComposableGenerator(cChunkGenerator & a_ChunkGenerator);
+	virtual ~cComposableGenerator();
+	
+	virtual void Initialize(cWorld * a_World, cIniFile & a_IniFile) override;
+	virtual void GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) override;
+	virtual void DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc) override;
+
+protected:
+	// The generation composition:
+	cBiomeGen *              m_BiomeGen;
+	cTerrainHeightGen *      m_HeightGen;
+	cTerrainCompositionGen * m_CompositionGen;
+	cStructureGenList        m_StructureGens;
+	cFinishGenList           m_FinishGens;
+	
+	// Generators underlying the caches:
+	cBiomeGen *              m_UnderlyingBiomeGen;
+	cTerrainHeightGen *      m_UnderlyingHeightGen;
+	cTerrainCompositionGen * m_UnderlyingCompositionGen;
+	
+	
+	/// Reads the biome gen settings from the ini and initializes m_BiomeGen accordingly
+	void InitBiomeGen(cIniFile & a_IniFile);
+	
+	/// Reads the HeightGen settings from the ini and initializes m_HeightGen accordingly
+	void InitHeightGen(cIniFile & a_IniFile);
+	
+	/// Reads the CompositionGen settings from the ini and initializes m_CompositionGen accordingly
+	void InitCompositionGen(cIniFile & a_IniFile);
+	
+	/// Reads the structures to generate from the ini and initializes m_StructureGens accordingly
+	void InitStructureGens(cIniFile & a_IniFile);
+	
+	/// Reads the finishers from the ini and initializes m_FinishGens accordingly
+	void InitFinishGens(cIniFile & a_IniFile);
+} ;
+
+
+
+
diff --git a/source/Generating/DistortedHeightmap.cpp b/source/Generating/DistortedHeightmap.cpp
index 5efc27895..6ac4d61d5 100644
--- a/source/Generating/DistortedHeightmap.cpp
+++ b/source/Generating/DistortedHeightmap.cpp
@@ -1,419 +1,419 @@
-

-// DistortedHeightmap.cpp

-

-// Implements the cDistortedHeightmap class representing the height and composition generator capable of overhangs

-

-#include "Globals.h"

-

-#include "DistortedHeightmap.h"

-#include "../OSSupport/File.h"

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

-#include "../LinearUpscale.h"

-

-

-

-

-

-/** This table assigns a relative maximum overhang size in each direction to biomes.

-Both numbers indicate a number which will multiply the noise value for each coord;

-this means that you can have different-sized overhangs in each direction.

-Usually you'd want to keep both numbers the same.

-The numbers are "relative", not absolute maximum; overhangs of a slightly larger size are possible

-due to the way that noise is calculated.

-*/

-const cDistortedHeightmap::sGenParam cDistortedHeightmap::m_GenParam[biNumBiomes] =

-{

-	/* Biome              |   AmpX | AmpZ */

-	/* biOcean            */ { 1.5f,  1.5f},

-	/* biPlains           */ { 0.5f,  0.5f},

-	/* biDesert           */ { 0.5f,  0.5f},

-	/* biExtremeHills     */ {16.0f, 16.0f},

-	/* biForest           */ { 3.0f,  3.0f},

-	/* biTaiga            */ { 1.5f,  1.5f},

-	

-	/* biSwampland        */ { 0.0f,  0.0f},

-	/* biRiver            */ { 0.0f,  0.0f},

-	/* biNether           */ { 0.0f,  0.0f},  // Unused, but must be here due to indexing

-	/* biSky              */ { 0.0f,  0.0f},  // Unused, but must be here due to indexing

-	/* biFrozenOcean      */ { 0.0f,  0.0f},

-	/* biFrozenRiver      */ { 0.0f,  0.0f},

-	/* biIcePlains        */ { 0.0f,  0.0f},

-	/* biIceMountains     */ { 8.0f,  8.0f},

-	/* biMushroomIsland   */ { 4.0f,  4.0f},

-	/* biMushroomShore    */ { 0.0f,  0.0f},

-	/* biBeach            */ { 0.0f,  0.0f},

-	/* biDesertHills      */ { 5.0f,  5.0f},

-	/* biForestHills      */ { 6.0f,  6.0f},

-	/* biTaigaHills       */ { 8.0f,  8.0f},

-	/* biExtremeHillsEdge */ { 7.0f,  7.0f},

-	/* biJungle           */ { 0.0f,  0.0f},

-	/* biJungleHills      */ { 8.0f,  8.0f},

-} ;

-

-

-

-

-

-cDistortedHeightmap::cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen) :

-	m_NoiseDistortX(a_Seed + 1000),

-	m_NoiseDistortZ(a_Seed + 2000),

-	m_OceanFloorSelect(a_Seed + 3000),

-	m_BiomeGen(a_BiomeGen),

-	m_UnderlyingHeiGen(a_Seed, a_BiomeGen),

-	m_HeightGen(&m_UnderlyingHeiGen, 64)

-{

-	m_NoiseDistortX.AddOctave((NOISE_DATATYPE)1,    (NOISE_DATATYPE)0.5);

-	m_NoiseDistortX.AddOctave((NOISE_DATATYPE)0.5,  (NOISE_DATATYPE)1);

-	m_NoiseDistortX.AddOctave((NOISE_DATATYPE)0.25, (NOISE_DATATYPE)2);

-

-	m_NoiseDistortZ.AddOctave((NOISE_DATATYPE)1,    (NOISE_DATATYPE)0.5);

-	m_NoiseDistortZ.AddOctave((NOISE_DATATYPE)0.5,  (NOISE_DATATYPE)1);

-	m_NoiseDistortZ.AddOctave((NOISE_DATATYPE)0.25, (NOISE_DATATYPE)2);

-}

-

-

-

-

-

-void cDistortedHeightmap::Initialize(cIniFile & a_IniFile)

-{

-	// Read the params from the INI file:

-	m_SeaLevel   =                 a_IniFile.GetValueSetI("Generator", "DistortedHeightmapSeaLevel",   62);

-	m_FrequencyX = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "DistortedHeightmapFrequencyX", 10);

-	m_FrequencyY = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "DistortedHeightmapFrequencyY", 10);

-	m_FrequencyZ = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "DistortedHeightmapFrequencyZ", 10);

-}

-

-

-

-

-

-void cDistortedHeightmap::PrepareState(int a_ChunkX, int a_ChunkZ)

-{

-	if ((m_CurChunkX == a_ChunkX) && (m_CurChunkZ == a_ChunkZ))

-	{

-		return;

-	}

-	m_CurChunkX = a_ChunkX;

-	m_CurChunkZ = a_ChunkZ;

-	

-	

-	m_HeightGen.GenHeightMap(a_ChunkX, a_ChunkZ, m_CurChunkHeights);

-	UpdateDistortAmps();

-	GenerateHeightArray();

-}

-

-

-

-

-

-void cDistortedHeightmap::GenerateHeightArray(void)

-{

-	// Generate distortion noise:

-	NOISE_DATATYPE DistortNoiseX[DIM_X * DIM_Y * DIM_Z];

-	NOISE_DATATYPE DistortNoiseZ[DIM_X * DIM_Y * DIM_Z];

-	NOISE_DATATYPE Workspace[DIM_X * DIM_Y * DIM_Z];

-	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(m_CurChunkX * cChunkDef::Width)) / m_FrequencyX;

-	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((m_CurChunkX + 1) * cChunkDef::Width - 1)) / m_FrequencyX;

-	NOISE_DATATYPE StartY = 0;

-	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)(257)) / m_FrequencyY;

-	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(m_CurChunkZ * cChunkDef::Width)) / m_FrequencyZ;

-	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((m_CurChunkZ + 1) * cChunkDef::Width - 1)) / m_FrequencyZ;

-	

-	m_NoiseDistortX.Generate3D(DistortNoiseX, DIM_X, DIM_Y, DIM_Z, StartX, EndX, StartY, EndY, StartZ, EndZ, Workspace);

-	m_NoiseDistortZ.Generate3D(DistortNoiseZ, DIM_X, DIM_Y, DIM_Z, StartX, EndX, StartY, EndY, StartZ, EndZ, Workspace);

-

-	// The distorted heightmap, before linear upscaling

-	NOISE_DATATYPE DistHei[DIM_X * DIM_Y * DIM_Z];

-	

-	// Distort the heightmap using the distortion:

-	for (int z = 0; z < DIM_Z; z++)

-	{

-		int AmpIdx = z * DIM_X;

-		for (int y = 0; y < DIM_Y; y++)

-		{

-			int NoiseArrayIdx = z * DIM_X * DIM_Y + y * DIM_X;

-			for (int x = 0; x < DIM_X; x++)

-			{

-				NOISE_DATATYPE DistX = DistortNoiseX[NoiseArrayIdx + x] * m_DistortAmpX[AmpIdx + x];

-				NOISE_DATATYPE DistZ = DistortNoiseZ[NoiseArrayIdx + x] * m_DistortAmpZ[AmpIdx + x];

-				DistX += (NOISE_DATATYPE)(m_CurChunkX * cChunkDef::Width + x * INTERPOL_X);

-				DistZ += (NOISE_DATATYPE)(m_CurChunkZ * cChunkDef::Width + z * INTERPOL_Z);

-				// Adding 0.5 helps alleviate the interpolation artifacts

-				DistHei[NoiseArrayIdx + x] = (NOISE_DATATYPE)GetHeightmapAt(DistX, DistZ) + (NOISE_DATATYPE)0.5;

-			}

-		}

-	}

-	

-	// Upscale the distorted heightmap into full dimensions:

-	LinearUpscale3DArray(

-		DistHei, DIM_X, DIM_Y, DIM_Z,

-		m_DistortedHeightmap, INTERPOL_X, INTERPOL_Y, INTERPOL_Z

-	);

-

-	// DEBUG: Debug3DNoise(m_DistortedHeightmap, 17, 257, 17, Printf("DistortedHeightmap_%d_%d", m_CurChunkX, m_CurChunkZ));

-}

-

-

-

-

-

-void cDistortedHeightmap::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)

-{

-	PrepareState(a_ChunkX, a_ChunkZ);

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

-	{

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

-		{

-			int NoiseArrayIdx = x + 17 * 257 * z;

-			cChunkDef::SetHeight(a_HeightMap, x, z, m_SeaLevel - 1);

-			for (int y = cChunkDef::Height - 1; y > m_SeaLevel - 1; y--)

-			{

-				int HeightMapHeight = (int)m_DistortedHeightmap[NoiseArrayIdx + 17 * y];

-				if (y < HeightMapHeight)

-				{

-					cChunkDef::SetHeight(a_HeightMap, x, z, y);

-					break;

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-void cDistortedHeightmap::ComposeTerrain(cChunkDesc & a_ChunkDesc)

-{

-	// Frequencies for the ocean floor selecting noise:

-	NOISE_DATATYPE FrequencyX = 3;

-	NOISE_DATATYPE FrequencyZ = 3;

-

-	// Prepare the internal state for generating this chunk:

-	PrepareState(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());

-	

-	// Compose:

-	a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);

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

-	{

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

-		{

-			int NoiseArrayIdx = x + 17 * 257 * z;

-			int LastAir = a_ChunkDesc.GetHeight(x, z) + 1;

-			bool HasHadWater = false;

-			for (int y = LastAir - 1; y > 0; y--)

-			{

-				int HeightMapHeight = (int)m_DistortedHeightmap[NoiseArrayIdx + 17 * y];

-

-				if (y >= HeightMapHeight)

-				{

-					// "air" part

-					LastAir = y;

-					if (y < m_SeaLevel)

-					{

-						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STATIONARY_WATER);

-						HasHadWater = true;

-					}

-					continue;

-				}

-				// "ground" part:

-				if (y < LastAir - 4)

-				{

-					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STONE);

-					continue;

-				}

-				if (HasHadWater)

-				{

-					// Decide between clay, sand and dirt

-					NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(m_CurChunkX * cChunkDef::Width + x)) / FrequencyX;

-					NOISE_DATATYPE NoiseY = ((NOISE_DATATYPE)(m_CurChunkZ * cChunkDef::Width + z)) / FrequencyZ;

-					NOISE_DATATYPE Val = m_OceanFloorSelect.CubicNoise2D(NoiseX, NoiseY);

-					if (Val < -0.95)

-					{

-						// Clay:

-						switch (LastAir - y)

-						{

-							case 0:

-							case 1:

-							{

-								a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_CLAY);

-								break;

-							}

-							case 2:

-							case 3:

-							{

-								a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SAND);

-								break;

-							}

-							case 4:

-							{

-								a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SANDSTONE);

-								break;

-							}

-						}  // switch (floor depth)

-					}

-					else if (Val < 0)

-					{

-						a_ChunkDesc.SetBlockType(x, y, z, (y < LastAir - 3) ? E_BLOCK_SANDSTONE : E_BLOCK_SAND);

-					}

-					else

-					{

-						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_DIRT);

-					}

-				}

-				else

-				{

-					switch (a_ChunkDesc.GetBiome(x, z))

-					{

-						case biOcean:

-						case biPlains:

-						case biExtremeHills:

-						case biForest:

-						case biTaiga:

-						case biSwampland:

-						case biRiver:

-						case biFrozenOcean:

-						case biFrozenRiver:

-						case biIcePlains:

-						case biIceMountains:

-						case biForestHills:

-						case biTaigaHills:

-						case biExtremeHillsEdge:

-						case biJungle:

-						case biJungleHills:

-						{

-							a_ChunkDesc.SetBlockType(x, y, z, (y == LastAir - 1) ? E_BLOCK_GRASS : E_BLOCK_DIRT);

-							break;

-						}

-						case biDesertHills:

-						case biDesert:

-						case biBeach:

-						{

-							a_ChunkDesc.SetBlockType(x, y, z, (y < LastAir - 3) ? E_BLOCK_SANDSTONE : E_BLOCK_SAND);

-							break;

-						}

-						case biMushroomIsland:

-						case biMushroomShore:

-						{

-							a_ChunkDesc.SetBlockType(x, y, z, (y == LastAir - 1) ? E_BLOCK_MYCELIUM : E_BLOCK_DIRT);

-							break;

-						}

-					}

-				}

-			}  // for y

-			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-int cDistortedHeightmap::GetHeightmapAt(NOISE_DATATYPE a_X, NOISE_DATATYPE a_Z)

-{

-	int ChunkX = (int)floor(a_X / (NOISE_DATATYPE)16);

-	int ChunkZ = (int)floor(a_Z / (NOISE_DATATYPE)16);

-	int RelX = (int)(a_X - (NOISE_DATATYPE)ChunkX * cChunkDef::Width);

-	int RelZ = (int)(a_Z - (NOISE_DATATYPE)ChunkZ * cChunkDef::Width);

-

-	// If we're withing the same chunk, return the pre-cached heightmap:

-	if ((ChunkX == m_CurChunkX) && (ChunkZ == m_CurChunkZ))

-	{

-		return cChunkDef::GetHeight(m_CurChunkHeights, RelX, RelZ);

-	}

-	

-	// Ask the cache:

-	HEIGHTTYPE res = 0;

-	if (m_HeightGen.GetHeightAt(ChunkX, ChunkZ, RelX, RelZ, res))

-	{

-		// The height was in the cache

-		return res;

-	}

-	

-	// The height is not in the cache, generate full heightmap and get it there:

-	cChunkDef::HeightMap Heightmap;

-	m_HeightGen.GenHeightMap(ChunkX, ChunkZ, Heightmap);

-	return cChunkDef::GetHeight(Heightmap, RelX, RelZ);

-}

-

-

-

-

-

-void cDistortedHeightmap::UpdateDistortAmps(void)

-{

-	BiomeNeighbors Biomes;

-	for (int z = -1; z <= 1; z++)

-	{

-		for (int x = -1; x <= 1; x++)

-		{

-			m_BiomeGen.GenBiomes(m_CurChunkX + x, m_CurChunkZ + z, Biomes[x + 1][z + 1]);

-		}  // for x

-	}  // for z

-

-	for (int z = 0; z < DIM_Z; z++)

-	{

-		for (int x = 0; x < DIM_Z; x++)

-		{

-			GetDistortAmpsAt(Biomes, x * INTERPOL_X, z * INTERPOL_Z, m_DistortAmpX[x + DIM_X * z], m_DistortAmpZ[x + DIM_X * z]);

-		}

-	}

-}	

-

-

-

-

-

-void cDistortedHeightmap::GetDistortAmpsAt(BiomeNeighbors & a_Neighbors, int a_RelX, int a_RelZ, NOISE_DATATYPE & a_DistortAmpX, NOISE_DATATYPE & a_DistortAmpZ)

-{

-	// Sum up how many biomes of each type there are in the neighborhood:

-	int BiomeCounts[biNumBiomes];

-	memset(BiomeCounts, 0, sizeof(BiomeCounts));

-	int Sum = 0;

-	for (int z = -8; z <= 8; z++)

-	{

-		int FinalZ = a_RelZ + z + cChunkDef::Width;

-		int IdxZ = FinalZ / cChunkDef::Width;

-		int ModZ = FinalZ % cChunkDef::Width;

-		int WeightZ = 9 - abs(z);

-		for (int x = -8; x <= 8; x++)

-		{

-			int FinalX = a_RelX + x + cChunkDef::Width;

-			int IdxX = FinalX / cChunkDef::Width;

-			int ModX = FinalX % cChunkDef::Width;

-			EMCSBiome Biome = cChunkDef::GetBiome(a_Neighbors[IdxX][IdxZ], ModX, ModZ);

-			if ((Biome < 0) || (Biome >= ARRAYCOUNT(BiomeCounts)))

-			{

-				continue;

-			}

-			int WeightX = 9 - abs(x);

-			BiomeCounts[Biome] += WeightX + WeightZ;

-			Sum += WeightX + WeightZ;

-		}  // for x

-	}  // for z

-

-	if (Sum <= 0)

-	{

-		// No known biome around? Weird. Return a bogus value:

-		ASSERT(!"cHeiGenBiomal: Biome sum failed, no known biome around");

-		a_DistortAmpX = 16;

-		a_DistortAmpZ = 16;

-	}

-

-	// For each biome type that has a nonzero count, calc its amps and add it:

-	NOISE_DATATYPE AmpX = 0;

-	NOISE_DATATYPE AmpZ = 0;

-	for (int i = 0; i < ARRAYCOUNT(BiomeCounts); i++)

-	{

-		AmpX += BiomeCounts[i] * m_GenParam[i].m_DistortAmpX;

-		AmpZ += BiomeCounts[i] * m_GenParam[i].m_DistortAmpZ;

-	}

-	a_DistortAmpX = AmpX / Sum;

-	a_DistortAmpZ = AmpZ / Sum;

-}

-

-

-

-

+
+// DistortedHeightmap.cpp
+
+// Implements the cDistortedHeightmap class representing the height and composition generator capable of overhangs
+
+#include "Globals.h"
+
+#include "DistortedHeightmap.h"
+#include "../OSSupport/File.h"
+#include "../../iniFile/iniFile.h"
+#include "../LinearUpscale.h"
+
+
+
+
+
+/** This table assigns a relative maximum overhang size in each direction to biomes.
+Both numbers indicate a number which will multiply the noise value for each coord;
+this means that you can have different-sized overhangs in each direction.
+Usually you'd want to keep both numbers the same.
+The numbers are "relative", not absolute maximum; overhangs of a slightly larger size are possible
+due to the way that noise is calculated.
+*/
+const cDistortedHeightmap::sGenParam cDistortedHeightmap::m_GenParam[biNumBiomes] =
+{
+	/* Biome              |   AmpX | AmpZ */
+	/* biOcean            */ { 1.5f,  1.5f},
+	/* biPlains           */ { 0.5f,  0.5f},
+	/* biDesert           */ { 0.5f,  0.5f},
+	/* biExtremeHills     */ {16.0f, 16.0f},
+	/* biForest           */ { 3.0f,  3.0f},
+	/* biTaiga            */ { 1.5f,  1.5f},
+	
+	/* biSwampland        */ { 0.0f,  0.0f},
+	/* biRiver            */ { 0.0f,  0.0f},
+	/* biNether           */ { 0.0f,  0.0f},  // Unused, but must be here due to indexing
+	/* biSky              */ { 0.0f,  0.0f},  // Unused, but must be here due to indexing
+	/* biFrozenOcean      */ { 0.0f,  0.0f},
+	/* biFrozenRiver      */ { 0.0f,  0.0f},
+	/* biIcePlains        */ { 0.0f,  0.0f},
+	/* biIceMountains     */ { 8.0f,  8.0f},
+	/* biMushroomIsland   */ { 4.0f,  4.0f},
+	/* biMushroomShore    */ { 0.0f,  0.0f},
+	/* biBeach            */ { 0.0f,  0.0f},
+	/* biDesertHills      */ { 5.0f,  5.0f},
+	/* biForestHills      */ { 6.0f,  6.0f},
+	/* biTaigaHills       */ { 8.0f,  8.0f},
+	/* biExtremeHillsEdge */ { 7.0f,  7.0f},
+	/* biJungle           */ { 0.0f,  0.0f},
+	/* biJungleHills      */ { 8.0f,  8.0f},
+} ;
+
+
+
+
+
+cDistortedHeightmap::cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen) :
+	m_NoiseDistortX(a_Seed + 1000),
+	m_NoiseDistortZ(a_Seed + 2000),
+	m_OceanFloorSelect(a_Seed + 3000),
+	m_BiomeGen(a_BiomeGen),
+	m_UnderlyingHeiGen(a_Seed, a_BiomeGen),
+	m_HeightGen(&m_UnderlyingHeiGen, 64)
+{
+	m_NoiseDistortX.AddOctave((NOISE_DATATYPE)1,    (NOISE_DATATYPE)0.5);
+	m_NoiseDistortX.AddOctave((NOISE_DATATYPE)0.5,  (NOISE_DATATYPE)1);
+	m_NoiseDistortX.AddOctave((NOISE_DATATYPE)0.25, (NOISE_DATATYPE)2);
+
+	m_NoiseDistortZ.AddOctave((NOISE_DATATYPE)1,    (NOISE_DATATYPE)0.5);
+	m_NoiseDistortZ.AddOctave((NOISE_DATATYPE)0.5,  (NOISE_DATATYPE)1);
+	m_NoiseDistortZ.AddOctave((NOISE_DATATYPE)0.25, (NOISE_DATATYPE)2);
+}
+
+
+
+
+
+void cDistortedHeightmap::Initialize(cIniFile & a_IniFile)
+{
+	// Read the params from the INI file:
+	m_SeaLevel   =                 a_IniFile.GetValueSetI("Generator", "DistortedHeightmapSeaLevel",   62);
+	m_FrequencyX = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "DistortedHeightmapFrequencyX", 10);
+	m_FrequencyY = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "DistortedHeightmapFrequencyY", 10);
+	m_FrequencyZ = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "DistortedHeightmapFrequencyZ", 10);
+}
+
+
+
+
+
+void cDistortedHeightmap::PrepareState(int a_ChunkX, int a_ChunkZ)
+{
+	if ((m_CurChunkX == a_ChunkX) && (m_CurChunkZ == a_ChunkZ))
+	{
+		return;
+	}
+	m_CurChunkX = a_ChunkX;
+	m_CurChunkZ = a_ChunkZ;
+	
+	
+	m_HeightGen.GenHeightMap(a_ChunkX, a_ChunkZ, m_CurChunkHeights);
+	UpdateDistortAmps();
+	GenerateHeightArray();
+}
+
+
+
+
+
+void cDistortedHeightmap::GenerateHeightArray(void)
+{
+	// Generate distortion noise:
+	NOISE_DATATYPE DistortNoiseX[DIM_X * DIM_Y * DIM_Z];
+	NOISE_DATATYPE DistortNoiseZ[DIM_X * DIM_Y * DIM_Z];
+	NOISE_DATATYPE Workspace[DIM_X * DIM_Y * DIM_Z];
+	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(m_CurChunkX * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((m_CurChunkX + 1) * cChunkDef::Width - 1)) / m_FrequencyX;
+	NOISE_DATATYPE StartY = 0;
+	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)(257)) / m_FrequencyY;
+	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(m_CurChunkZ * cChunkDef::Width)) / m_FrequencyZ;
+	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((m_CurChunkZ + 1) * cChunkDef::Width - 1)) / m_FrequencyZ;
+	
+	m_NoiseDistortX.Generate3D(DistortNoiseX, DIM_X, DIM_Y, DIM_Z, StartX, EndX, StartY, EndY, StartZ, EndZ, Workspace);
+	m_NoiseDistortZ.Generate3D(DistortNoiseZ, DIM_X, DIM_Y, DIM_Z, StartX, EndX, StartY, EndY, StartZ, EndZ, Workspace);
+
+	// The distorted heightmap, before linear upscaling
+	NOISE_DATATYPE DistHei[DIM_X * DIM_Y * DIM_Z];
+	
+	// Distort the heightmap using the distortion:
+	for (int z = 0; z < DIM_Z; z++)
+	{
+		int AmpIdx = z * DIM_X;
+		for (int y = 0; y < DIM_Y; y++)
+		{
+			int NoiseArrayIdx = z * DIM_X * DIM_Y + y * DIM_X;
+			for (int x = 0; x < DIM_X; x++)
+			{
+				NOISE_DATATYPE DistX = DistortNoiseX[NoiseArrayIdx + x] * m_DistortAmpX[AmpIdx + x];
+				NOISE_DATATYPE DistZ = DistortNoiseZ[NoiseArrayIdx + x] * m_DistortAmpZ[AmpIdx + x];
+				DistX += (NOISE_DATATYPE)(m_CurChunkX * cChunkDef::Width + x * INTERPOL_X);
+				DistZ += (NOISE_DATATYPE)(m_CurChunkZ * cChunkDef::Width + z * INTERPOL_Z);
+				// Adding 0.5 helps alleviate the interpolation artifacts
+				DistHei[NoiseArrayIdx + x] = (NOISE_DATATYPE)GetHeightmapAt(DistX, DistZ) + (NOISE_DATATYPE)0.5;
+			}
+		}
+	}
+	
+	// Upscale the distorted heightmap into full dimensions:
+	LinearUpscale3DArray(
+		DistHei, DIM_X, DIM_Y, DIM_Z,
+		m_DistortedHeightmap, INTERPOL_X, INTERPOL_Y, INTERPOL_Z
+	);
+
+	// DEBUG: Debug3DNoise(m_DistortedHeightmap, 17, 257, 17, Printf("DistortedHeightmap_%d_%d", m_CurChunkX, m_CurChunkZ));
+}
+
+
+
+
+
+void cDistortedHeightmap::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)
+{
+	PrepareState(a_ChunkX, a_ChunkZ);
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			int NoiseArrayIdx = x + 17 * 257 * z;
+			cChunkDef::SetHeight(a_HeightMap, x, z, m_SeaLevel - 1);
+			for (int y = cChunkDef::Height - 1; y > m_SeaLevel - 1; y--)
+			{
+				int HeightMapHeight = (int)m_DistortedHeightmap[NoiseArrayIdx + 17 * y];
+				if (y < HeightMapHeight)
+				{
+					cChunkDef::SetHeight(a_HeightMap, x, z, y);
+					break;
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+void cDistortedHeightmap::ComposeTerrain(cChunkDesc & a_ChunkDesc)
+{
+	// Frequencies for the ocean floor selecting noise:
+	NOISE_DATATYPE FrequencyX = 3;
+	NOISE_DATATYPE FrequencyZ = 3;
+
+	// Prepare the internal state for generating this chunk:
+	PrepareState(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());
+	
+	// Compose:
+	a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			int NoiseArrayIdx = x + 17 * 257 * z;
+			int LastAir = a_ChunkDesc.GetHeight(x, z) + 1;
+			bool HasHadWater = false;
+			for (int y = LastAir - 1; y > 0; y--)
+			{
+				int HeightMapHeight = (int)m_DistortedHeightmap[NoiseArrayIdx + 17 * y];
+
+				if (y >= HeightMapHeight)
+				{
+					// "air" part
+					LastAir = y;
+					if (y < m_SeaLevel)
+					{
+						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STATIONARY_WATER);
+						HasHadWater = true;
+					}
+					continue;
+				}
+				// "ground" part:
+				if (y < LastAir - 4)
+				{
+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STONE);
+					continue;
+				}
+				if (HasHadWater)
+				{
+					// Decide between clay, sand and dirt
+					NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(m_CurChunkX * cChunkDef::Width + x)) / FrequencyX;
+					NOISE_DATATYPE NoiseY = ((NOISE_DATATYPE)(m_CurChunkZ * cChunkDef::Width + z)) / FrequencyZ;
+					NOISE_DATATYPE Val = m_OceanFloorSelect.CubicNoise2D(NoiseX, NoiseY);
+					if (Val < -0.95)
+					{
+						// Clay:
+						switch (LastAir - y)
+						{
+							case 0:
+							case 1:
+							{
+								a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_CLAY);
+								break;
+							}
+							case 2:
+							case 3:
+							{
+								a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SAND);
+								break;
+							}
+							case 4:
+							{
+								a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SANDSTONE);
+								break;
+							}
+						}  // switch (floor depth)
+					}
+					else if (Val < 0)
+					{
+						a_ChunkDesc.SetBlockType(x, y, z, (y < LastAir - 3) ? E_BLOCK_SANDSTONE : E_BLOCK_SAND);
+					}
+					else
+					{
+						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_DIRT);
+					}
+				}
+				else
+				{
+					switch (a_ChunkDesc.GetBiome(x, z))
+					{
+						case biOcean:
+						case biPlains:
+						case biExtremeHills:
+						case biForest:
+						case biTaiga:
+						case biSwampland:
+						case biRiver:
+						case biFrozenOcean:
+						case biFrozenRiver:
+						case biIcePlains:
+						case biIceMountains:
+						case biForestHills:
+						case biTaigaHills:
+						case biExtremeHillsEdge:
+						case biJungle:
+						case biJungleHills:
+						{
+							a_ChunkDesc.SetBlockType(x, y, z, (y == LastAir - 1) ? E_BLOCK_GRASS : E_BLOCK_DIRT);
+							break;
+						}
+						case biDesertHills:
+						case biDesert:
+						case biBeach:
+						{
+							a_ChunkDesc.SetBlockType(x, y, z, (y < LastAir - 3) ? E_BLOCK_SANDSTONE : E_BLOCK_SAND);
+							break;
+						}
+						case biMushroomIsland:
+						case biMushroomShore:
+						{
+							a_ChunkDesc.SetBlockType(x, y, z, (y == LastAir - 1) ? E_BLOCK_MYCELIUM : E_BLOCK_DIRT);
+							break;
+						}
+					}
+				}
+			}  // for y
+			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+int cDistortedHeightmap::GetHeightmapAt(NOISE_DATATYPE a_X, NOISE_DATATYPE a_Z)
+{
+	int ChunkX = (int)floor(a_X / (NOISE_DATATYPE)16);
+	int ChunkZ = (int)floor(a_Z / (NOISE_DATATYPE)16);
+	int RelX = (int)(a_X - (NOISE_DATATYPE)ChunkX * cChunkDef::Width);
+	int RelZ = (int)(a_Z - (NOISE_DATATYPE)ChunkZ * cChunkDef::Width);
+
+	// If we're withing the same chunk, return the pre-cached heightmap:
+	if ((ChunkX == m_CurChunkX) && (ChunkZ == m_CurChunkZ))
+	{
+		return cChunkDef::GetHeight(m_CurChunkHeights, RelX, RelZ);
+	}
+	
+	// Ask the cache:
+	HEIGHTTYPE res = 0;
+	if (m_HeightGen.GetHeightAt(ChunkX, ChunkZ, RelX, RelZ, res))
+	{
+		// The height was in the cache
+		return res;
+	}
+	
+	// The height is not in the cache, generate full heightmap and get it there:
+	cChunkDef::HeightMap Heightmap;
+	m_HeightGen.GenHeightMap(ChunkX, ChunkZ, Heightmap);
+	return cChunkDef::GetHeight(Heightmap, RelX, RelZ);
+}
+
+
+
+
+
+void cDistortedHeightmap::UpdateDistortAmps(void)
+{
+	BiomeNeighbors Biomes;
+	for (int z = -1; z <= 1; z++)
+	{
+		for (int x = -1; x <= 1; x++)
+		{
+			m_BiomeGen.GenBiomes(m_CurChunkX + x, m_CurChunkZ + z, Biomes[x + 1][z + 1]);
+		}  // for x
+	}  // for z
+
+	for (int z = 0; z < DIM_Z; z++)
+	{
+		for (int x = 0; x < DIM_Z; x++)
+		{
+			GetDistortAmpsAt(Biomes, x * INTERPOL_X, z * INTERPOL_Z, m_DistortAmpX[x + DIM_X * z], m_DistortAmpZ[x + DIM_X * z]);
+		}
+	}
+}	
+
+
+
+
+
+void cDistortedHeightmap::GetDistortAmpsAt(BiomeNeighbors & a_Neighbors, int a_RelX, int a_RelZ, NOISE_DATATYPE & a_DistortAmpX, NOISE_DATATYPE & a_DistortAmpZ)
+{
+	// Sum up how many biomes of each type there are in the neighborhood:
+	int BiomeCounts[biNumBiomes];
+	memset(BiomeCounts, 0, sizeof(BiomeCounts));
+	int Sum = 0;
+	for (int z = -8; z <= 8; z++)
+	{
+		int FinalZ = a_RelZ + z + cChunkDef::Width;
+		int IdxZ = FinalZ / cChunkDef::Width;
+		int ModZ = FinalZ % cChunkDef::Width;
+		int WeightZ = 9 - abs(z);
+		for (int x = -8; x <= 8; x++)
+		{
+			int FinalX = a_RelX + x + cChunkDef::Width;
+			int IdxX = FinalX / cChunkDef::Width;
+			int ModX = FinalX % cChunkDef::Width;
+			EMCSBiome Biome = cChunkDef::GetBiome(a_Neighbors[IdxX][IdxZ], ModX, ModZ);
+			if ((Biome < 0) || (Biome >= ARRAYCOUNT(BiomeCounts)))
+			{
+				continue;
+			}
+			int WeightX = 9 - abs(x);
+			BiomeCounts[Biome] += WeightX + WeightZ;
+			Sum += WeightX + WeightZ;
+		}  // for x
+	}  // for z
+
+	if (Sum <= 0)
+	{
+		// No known biome around? Weird. Return a bogus value:
+		ASSERT(!"cHeiGenBiomal: Biome sum failed, no known biome around");
+		a_DistortAmpX = 16;
+		a_DistortAmpZ = 16;
+	}
+
+	// For each biome type that has a nonzero count, calc its amps and add it:
+	NOISE_DATATYPE AmpX = 0;
+	NOISE_DATATYPE AmpZ = 0;
+	for (int i = 0; i < ARRAYCOUNT(BiomeCounts); i++)
+	{
+		AmpX += BiomeCounts[i] * m_GenParam[i].m_DistortAmpX;
+		AmpZ += BiomeCounts[i] * m_GenParam[i].m_DistortAmpZ;
+	}
+	a_DistortAmpX = AmpX / Sum;
+	a_DistortAmpZ = AmpZ / Sum;
+}
+
+
+
+
diff --git a/source/Generating/DistortedHeightmap.h b/source/Generating/DistortedHeightmap.h
index 41a781b84..b2b235e61 100644
--- a/source/Generating/DistortedHeightmap.h
+++ b/source/Generating/DistortedHeightmap.h
@@ -1,102 +1,102 @@
-

-// DistortedHeightmap.h

-

-// Declares the cDistortedHeightmap class representing the height and composition generator capable of overhangs

-

-

-

-

-

-#pragma once

-

-#include "ComposableGenerator.h"

-#include "HeiGen.h"

-#include "../Noise.h"

-

-

-

-

-

-#define NOISE_SIZE_Y (257 + 32)

-

-

-

-

-

-class cDistortedHeightmap :

-	public cTerrainHeightGen,

-	public cTerrainCompositionGen

-{

-public:

-	cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen);

-	

-	void Initialize(cIniFile & a_IniFile);

-	

-protected:

-	typedef cChunkDef::BiomeMap BiomeNeighbors[3][3];

-

-	// Linear upscaling step sizes, must be divisors of cChunkDef::Width and cChunkDef::Height, respectively:

-	static const int INTERPOL_X = 8;

-	static const int INTERPOL_Y = 4;

-	static const int INTERPOL_Z = 8;

-

-	// Linear upscaling buffer dimensions, calculated from the step sizes:

-	static const int DIM_X = 1 +  (17 / INTERPOL_X);

-	static const int DIM_Y = 1 + (257 / INTERPOL_Y);

-	static const int DIM_Z = 1 +  (17 / INTERPOL_Z);

-

-	cPerlinNoise m_NoiseDistortX;

-	cPerlinNoise m_NoiseDistortZ;

-	cNoise       m_OceanFloorSelect;  ///< Used for selecting between dirt and sand on the ocean floor

-

-	int m_SeaLevel;

-	NOISE_DATATYPE m_FrequencyX;

-	NOISE_DATATYPE m_FrequencyY;

-	NOISE_DATATYPE m_FrequencyZ;

-

-	int m_CurChunkX;

-	int m_CurChunkZ;

-	NOISE_DATATYPE m_DistortedHeightmap[17 * 257 * 17];

-

-	cBiomeGen &   m_BiomeGen;

-	cHeiGenBiomal m_UnderlyingHeiGen;  // This generator provides us with base heightmap (before distortion)

-	cHeiGenCache  m_HeightGen;         // Cache above m_UnderlyingHeiGen

-	

-	/// Heightmap for the current chunk, before distortion (from m_HeightGen). Used for optimization.

-	cChunkDef::HeightMap m_CurChunkHeights;

-	

-	// Per-biome terrain generator parameters:

-	struct sGenParam

-	{

-		NOISE_DATATYPE m_DistortAmpX;

-		NOISE_DATATYPE m_DistortAmpZ;

-	} ;

-	static const sGenParam m_GenParam[biNumBiomes];

-	

-	// Distortion amplitudes for each direction, before linear upscaling

-	NOISE_DATATYPE m_DistortAmpX[DIM_X * DIM_Z];

-	NOISE_DATATYPE m_DistortAmpZ[DIM_X * DIM_Z];

-	

-

-	/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise arrays, heightmap)

-	void PrepareState(int a_ChunkX, int a_ChunkZ);

-	

-	/// Generates the m_DistortedHeightmap array for the current chunk

-	void GenerateHeightArray(void);

-	

-	/// Calculates the heightmap value (before distortion) at the specified (floating-point) coords

-	int GetHeightmapAt(NOISE_DATATYPE a_X, NOISE_DATATYPE a_Z);

-	

-	/// Updates m_DistortAmpX/Z[] based on m_CurChunkX and m_CurChunkZ

-	void UpdateDistortAmps(void);

-	

-	/// Calculates the X and Z distortion amplitudes based on the neighbors' biomes

-	void GetDistortAmpsAt(BiomeNeighbors & a_Neighbors, int a_RelX, int a_RelZ, NOISE_DATATYPE & a_DistortAmpX, NOISE_DATATYPE & a_DistortAmpZ);

-	

-	

-	// cTerrainHeightGen overrides:

-	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;

-

-	// cTerrainCompositionGen overrides:

-	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;

-} ;

+
+// DistortedHeightmap.h
+
+// Declares the cDistortedHeightmap class representing the height and composition generator capable of overhangs
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "HeiGen.h"
+#include "../Noise.h"
+
+
+
+
+
+#define NOISE_SIZE_Y (257 + 32)
+
+
+
+
+
+class cDistortedHeightmap :
+	public cTerrainHeightGen,
+	public cTerrainCompositionGen
+{
+public:
+	cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen);
+	
+	void Initialize(cIniFile & a_IniFile);
+	
+protected:
+	typedef cChunkDef::BiomeMap BiomeNeighbors[3][3];
+
+	// Linear upscaling step sizes, must be divisors of cChunkDef::Width and cChunkDef::Height, respectively:
+	static const int INTERPOL_X = 8;
+	static const int INTERPOL_Y = 4;
+	static const int INTERPOL_Z = 8;
+
+	// Linear upscaling buffer dimensions, calculated from the step sizes:
+	static const int DIM_X = 1 +  (17 / INTERPOL_X);
+	static const int DIM_Y = 1 + (257 / INTERPOL_Y);
+	static const int DIM_Z = 1 +  (17 / INTERPOL_Z);
+
+	cPerlinNoise m_NoiseDistortX;
+	cPerlinNoise m_NoiseDistortZ;
+	cNoise       m_OceanFloorSelect;  ///< Used for selecting between dirt and sand on the ocean floor
+
+	int m_SeaLevel;
+	NOISE_DATATYPE m_FrequencyX;
+	NOISE_DATATYPE m_FrequencyY;
+	NOISE_DATATYPE m_FrequencyZ;
+
+	int m_CurChunkX;
+	int m_CurChunkZ;
+	NOISE_DATATYPE m_DistortedHeightmap[17 * 257 * 17];
+
+	cBiomeGen &   m_BiomeGen;
+	cHeiGenBiomal m_UnderlyingHeiGen;  // This generator provides us with base heightmap (before distortion)
+	cHeiGenCache  m_HeightGen;         // Cache above m_UnderlyingHeiGen
+	
+	/// Heightmap for the current chunk, before distortion (from m_HeightGen). Used for optimization.
+	cChunkDef::HeightMap m_CurChunkHeights;
+	
+	// Per-biome terrain generator parameters:
+	struct sGenParam
+	{
+		NOISE_DATATYPE m_DistortAmpX;
+		NOISE_DATATYPE m_DistortAmpZ;
+	} ;
+	static const sGenParam m_GenParam[biNumBiomes];
+	
+	// Distortion amplitudes for each direction, before linear upscaling
+	NOISE_DATATYPE m_DistortAmpX[DIM_X * DIM_Z];
+	NOISE_DATATYPE m_DistortAmpZ[DIM_X * DIM_Z];
+	
+
+	/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise arrays, heightmap)
+	void PrepareState(int a_ChunkX, int a_ChunkZ);
+	
+	/// Generates the m_DistortedHeightmap array for the current chunk
+	void GenerateHeightArray(void);
+	
+	/// Calculates the heightmap value (before distortion) at the specified (floating-point) coords
+	int GetHeightmapAt(NOISE_DATATYPE a_X, NOISE_DATATYPE a_Z);
+	
+	/// Updates m_DistortAmpX/Z[] based on m_CurChunkX and m_CurChunkZ
+	void UpdateDistortAmps(void);
+	
+	/// Calculates the X and Z distortion amplitudes based on the neighbors' biomes
+	void GetDistortAmpsAt(BiomeNeighbors & a_Neighbors, int a_RelX, int a_RelZ, NOISE_DATATYPE & a_DistortAmpX, NOISE_DATATYPE & a_DistortAmpZ);
+	
+	
+	// cTerrainHeightGen overrides:
+	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;
+
+	// cTerrainCompositionGen overrides:
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
+} ;
diff --git a/source/Generating/EndGen.cpp b/source/Generating/EndGen.cpp
index 30fa457db..3eba5c47b 100644
--- a/source/Generating/EndGen.cpp
+++ b/source/Generating/EndGen.cpp
@@ -1,217 +1,217 @@
-

-// EndGen.cpp

-

-// Implements the cEndGen class representing the generator for the End, both as a HeightGen and CompositionGen

-

-#include "Globals.h"

-#include "EndGen.h"

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

-#include "../LinearUpscale.h"

-

-

-

-

-

-enum

-{

-	// Interpolation cell size:

-	INTERPOL_X = 4,

-	INTERPOL_Y = 4,

-	INTERPOL_Z = 4,

-	

-	// Size of chunk data, downscaled before interpolation:

-	DIM_X = 16  / INTERPOL_X + 1,

-	DIM_Y = 256 / INTERPOL_Y + 1,

-	DIM_Z = 16  / INTERPOL_Z + 1,

-} ;

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cEndGen:

-

-cEndGen::cEndGen(int a_Seed) :

-	m_Seed(a_Seed),

-	m_IslandSizeX(256),

-	m_IslandSizeY(96),

-	m_IslandSizeZ(256),

-	m_FrequencyX(80),

-	m_FrequencyY(80),

-	m_FrequencyZ(80)

-{

-	m_Perlin.AddOctave(1, 1);

-	m_Perlin.AddOctave(2, 0.5);

-	m_Perlin.AddOctave(4, 0.25);

-}

-

-

-

-

-

-void cEndGen::Initialize(cIniFile & a_IniFile)

-{

-	m_IslandSizeX = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeX", m_IslandSizeX);

-	m_IslandSizeY = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeY", m_IslandSizeY);

-	m_IslandSizeZ = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeZ", m_IslandSizeZ);

-

-	m_FrequencyX = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyX", m_FrequencyX);

-	m_FrequencyY = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyY", m_FrequencyY);

-	m_FrequencyZ = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyZ", m_FrequencyZ);

-	

-	// Recalculate the min and max chunk coords of the island

-	m_MaxChunkX = (m_IslandSizeX + cChunkDef::Width - 1) / cChunkDef::Width;

-	m_MinChunkX = -m_MaxChunkX;

-	m_MaxChunkZ = (m_IslandSizeZ + cChunkDef::Width - 1) / cChunkDef::Width;

-	m_MinChunkZ = -m_MaxChunkZ;

-}

-

-

-

-

-

-/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array)

-void cEndGen::PrepareState(int a_ChunkX, int a_ChunkZ)

-{

-	ASSERT(!IsChunkOutsideRange(a_ChunkX, a_ChunkZ));  // Should be filtered before calling this function

-	

-	if ((m_LastChunkX == a_ChunkX) && (m_LastChunkZ == a_ChunkZ))

-	{

-		return;

-	}

-	

-	m_LastChunkX = a_ChunkX;

-	m_LastChunkZ = a_ChunkZ;

-	

-	GenerateNoiseArray();

-}

-

-

-

-

-

-/// Generates the m_NoiseArray array for the current chunk

-void cEndGen::GenerateNoiseArray(void)

-{

-	NOISE_DATATYPE NoiseData[DIM_X * DIM_Y * DIM_Z];  // [x + DIM_X * z + DIM_X * DIM_Z * y]

-	NOISE_DATATYPE Workspace[DIM_X * DIM_Y * DIM_Z];  // [x + DIM_X * z + DIM_X * DIM_Z * y]

-	

-	// Generate the downscaled noise:

-	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(m_LastChunkX       * cChunkDef::Width)) / m_FrequencyX;

-	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((m_LastChunkX + 1) * cChunkDef::Width)) / m_FrequencyX;

-	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(m_LastChunkZ       * cChunkDef::Width)) / m_FrequencyZ;

-	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((m_LastChunkZ + 1) * cChunkDef::Width)) / m_FrequencyZ;

-	NOISE_DATATYPE StartY = 0;

-	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)257) / m_FrequencyY;

-	m_Perlin.Generate3D(NoiseData, DIM_X, DIM_Z, DIM_Y, StartX, EndX, StartZ, EndZ, StartY, EndY, Workspace);

-	

-	// Add distance:

-	int idx = 0;

-	for (int y = 0; y < DIM_Y; y++)

-	{

-		NOISE_DATATYPE ValY = (NOISE_DATATYPE)(2 * INTERPOL_Y * y - m_IslandSizeY) / m_IslandSizeY;

-		ValY = ValY * ValY;

-		for (int z = 0; z < DIM_Z; z++)

-		{

-			NOISE_DATATYPE ValZ = (NOISE_DATATYPE)(m_LastChunkZ * cChunkDef::Width + (z * cChunkDef::Width / (DIM_Z - 1))) / m_IslandSizeZ;

-			ValZ = ValZ * ValZ;

-			for (int x = 0; x < DIM_X; x++)

-			{

-				// NOISE_DATATYPE ValX = StartX + (EndX - StartX) * x / (DIM_X - 1);

-				NOISE_DATATYPE ValX = (NOISE_DATATYPE)(m_LastChunkX * cChunkDef::Width + (x * cChunkDef::Width / (DIM_X - 1))) / m_IslandSizeX;

-				ValX = ValX * ValX;

-				NoiseData[idx++] += ValX + ValZ + ValY;

-			}  // for x

-		}  // for z

-	}  // for y

-	

-	// Upscale into real chunk size:

-	LinearUpscale3DArray(NoiseData, DIM_X, DIM_Z, DIM_Y, m_NoiseArray, INTERPOL_X, INTERPOL_Z, INTERPOL_Y);

-}

-

-

-

-

-	

-/// Returns true if the chunk is outside of the island's dimensions

-bool cEndGen::IsChunkOutsideRange(int a_ChunkX, int a_ChunkZ)

-{

-	return (

-		(a_ChunkX < m_MinChunkX) || (a_ChunkX > m_MaxChunkX) ||

-		(a_ChunkZ < m_MinChunkZ) || (a_ChunkZ > m_MaxChunkZ)

-	);		

-}

-

-

-

-

-

-void cEndGen::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)

-{

-	if (IsChunkOutsideRange(a_ChunkX, a_ChunkZ))

-	{

-		for (int i = 0; i < ARRAYCOUNT(a_HeightMap); i++)

-		{

-			a_HeightMap[i] = 0;

-		}

-		return;

-	}

-	

-	PrepareState(a_ChunkX, a_ChunkZ);

-	

-	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);

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

-	{

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

-		{

-			cChunkDef::SetHeight(a_HeightMap, x, z, MaxY);

-			for (int y = MaxY; y > 0; y--)

-			{

-				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)

-				{

-					cChunkDef::SetHeight(a_HeightMap, x, z, y);

-					break;

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-void cEndGen::ComposeTerrain(cChunkDesc & a_ChunkDesc)

-{

-	if (IsChunkOutsideRange(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ()))

-	{

-		a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);

-		return;

-	}

-	

-	PrepareState(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());

-	

-	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);

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

-	{

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

-		{

-			for (int y = MaxY; y > 0; y--)

-			{

-				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_END_STONE, 0);

-				}

-				else

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_AIR, 0);

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

+
+// EndGen.cpp
+
+// Implements the cEndGen class representing the generator for the End, both as a HeightGen and CompositionGen
+
+#include "Globals.h"
+#include "EndGen.h"
+#include "../../iniFile/iniFile.h"
+#include "../LinearUpscale.h"
+
+
+
+
+
+enum
+{
+	// Interpolation cell size:
+	INTERPOL_X = 4,
+	INTERPOL_Y = 4,
+	INTERPOL_Z = 4,
+	
+	// Size of chunk data, downscaled before interpolation:
+	DIM_X = 16  / INTERPOL_X + 1,
+	DIM_Y = 256 / INTERPOL_Y + 1,
+	DIM_Z = 16  / INTERPOL_Z + 1,
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cEndGen:
+
+cEndGen::cEndGen(int a_Seed) :
+	m_Seed(a_Seed),
+	m_IslandSizeX(256),
+	m_IslandSizeY(96),
+	m_IslandSizeZ(256),
+	m_FrequencyX(80),
+	m_FrequencyY(80),
+	m_FrequencyZ(80)
+{
+	m_Perlin.AddOctave(1, 1);
+	m_Perlin.AddOctave(2, 0.5);
+	m_Perlin.AddOctave(4, 0.25);
+}
+
+
+
+
+
+void cEndGen::Initialize(cIniFile & a_IniFile)
+{
+	m_IslandSizeX = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeX", m_IslandSizeX);
+	m_IslandSizeY = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeY", m_IslandSizeY);
+	m_IslandSizeZ = a_IniFile.GetValueSetI("Generator", "EndGenIslandSizeZ", m_IslandSizeZ);
+
+	m_FrequencyX = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyX", m_FrequencyX);
+	m_FrequencyY = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyY", m_FrequencyY);
+	m_FrequencyZ = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "EndGenFrequencyZ", m_FrequencyZ);
+	
+	// Recalculate the min and max chunk coords of the island
+	m_MaxChunkX = (m_IslandSizeX + cChunkDef::Width - 1) / cChunkDef::Width;
+	m_MinChunkX = -m_MaxChunkX;
+	m_MaxChunkZ = (m_IslandSizeZ + cChunkDef::Width - 1) / cChunkDef::Width;
+	m_MinChunkZ = -m_MaxChunkZ;
+}
+
+
+
+
+
+/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array)
+void cEndGen::PrepareState(int a_ChunkX, int a_ChunkZ)
+{
+	ASSERT(!IsChunkOutsideRange(a_ChunkX, a_ChunkZ));  // Should be filtered before calling this function
+	
+	if ((m_LastChunkX == a_ChunkX) && (m_LastChunkZ == a_ChunkZ))
+	{
+		return;
+	}
+	
+	m_LastChunkX = a_ChunkX;
+	m_LastChunkZ = a_ChunkZ;
+	
+	GenerateNoiseArray();
+}
+
+
+
+
+
+/// Generates the m_NoiseArray array for the current chunk
+void cEndGen::GenerateNoiseArray(void)
+{
+	NOISE_DATATYPE NoiseData[DIM_X * DIM_Y * DIM_Z];  // [x + DIM_X * z + DIM_X * DIM_Z * y]
+	NOISE_DATATYPE Workspace[DIM_X * DIM_Y * DIM_Z];  // [x + DIM_X * z + DIM_X * DIM_Z * y]
+	
+	// Generate the downscaled noise:
+	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(m_LastChunkX       * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((m_LastChunkX + 1) * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(m_LastChunkZ       * cChunkDef::Width)) / m_FrequencyZ;
+	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((m_LastChunkZ + 1) * cChunkDef::Width)) / m_FrequencyZ;
+	NOISE_DATATYPE StartY = 0;
+	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)257) / m_FrequencyY;
+	m_Perlin.Generate3D(NoiseData, DIM_X, DIM_Z, DIM_Y, StartX, EndX, StartZ, EndZ, StartY, EndY, Workspace);
+	
+	// Add distance:
+	int idx = 0;
+	for (int y = 0; y < DIM_Y; y++)
+	{
+		NOISE_DATATYPE ValY = (NOISE_DATATYPE)(2 * INTERPOL_Y * y - m_IslandSizeY) / m_IslandSizeY;
+		ValY = ValY * ValY;
+		for (int z = 0; z < DIM_Z; z++)
+		{
+			NOISE_DATATYPE ValZ = (NOISE_DATATYPE)(m_LastChunkZ * cChunkDef::Width + (z * cChunkDef::Width / (DIM_Z - 1))) / m_IslandSizeZ;
+			ValZ = ValZ * ValZ;
+			for (int x = 0; x < DIM_X; x++)
+			{
+				// NOISE_DATATYPE ValX = StartX + (EndX - StartX) * x / (DIM_X - 1);
+				NOISE_DATATYPE ValX = (NOISE_DATATYPE)(m_LastChunkX * cChunkDef::Width + (x * cChunkDef::Width / (DIM_X - 1))) / m_IslandSizeX;
+				ValX = ValX * ValX;
+				NoiseData[idx++] += ValX + ValZ + ValY;
+			}  // for x
+		}  // for z
+	}  // for y
+	
+	// Upscale into real chunk size:
+	LinearUpscale3DArray(NoiseData, DIM_X, DIM_Z, DIM_Y, m_NoiseArray, INTERPOL_X, INTERPOL_Z, INTERPOL_Y);
+}
+
+
+
+
+	
+/// Returns true if the chunk is outside of the island's dimensions
+bool cEndGen::IsChunkOutsideRange(int a_ChunkX, int a_ChunkZ)
+{
+	return (
+		(a_ChunkX < m_MinChunkX) || (a_ChunkX > m_MaxChunkX) ||
+		(a_ChunkZ < m_MinChunkZ) || (a_ChunkZ > m_MaxChunkZ)
+	);		
+}
+
+
+
+
+
+void cEndGen::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)
+{
+	if (IsChunkOutsideRange(a_ChunkX, a_ChunkZ))
+	{
+		for (int i = 0; i < ARRAYCOUNT(a_HeightMap); i++)
+		{
+			a_HeightMap[i] = 0;
+		}
+		return;
+	}
+	
+	PrepareState(a_ChunkX, a_ChunkZ);
+	
+	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			cChunkDef::SetHeight(a_HeightMap, x, z, MaxY);
+			for (int y = MaxY; y > 0; y--)
+			{
+				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)
+				{
+					cChunkDef::SetHeight(a_HeightMap, x, z, y);
+					break;
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+void cEndGen::ComposeTerrain(cChunkDesc & a_ChunkDesc)
+{
+	if (IsChunkOutsideRange(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ()))
+	{
+		a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);
+		return;
+	}
+	
+	PrepareState(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());
+	
+	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			for (int y = MaxY; y > 0; y--)
+			{
+				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_END_STONE, 0);
+				}
+				else
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_AIR, 0);
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
diff --git a/source/Generating/EndGen.h b/source/Generating/EndGen.h
index cd316ed67..4904a0e3d 100644
--- a/source/Generating/EndGen.h
+++ b/source/Generating/EndGen.h
@@ -1,69 +1,69 @@
-

-// EndGen.h

-

-// Declares the cEndGen class representing the generator for the End, both as a HeightGen and CompositionGen

-

-

-

-

-

-#pragma once

-

-#include "ComposableGenerator.h"

-#include "../Noise.h"

-

-

-

-

-

-class cEndGen :

-	public cTerrainHeightGen,

-	public cTerrainCompositionGen

-{

-public:

-	cEndGen(int a_Seed);

-	

-	void Initialize(cIniFile & a_IniFile);

-	

-protected:

-

-	/// Seed for the noise

-	int m_Seed;

-	

-	/// The Perlin noise used for generating

-	cPerlinNoise m_Perlin;

-

-	// XYZ size of the "island", in blocks:

-	int m_IslandSizeX;

-	int m_IslandSizeY;

-	int m_IslandSizeZ;

-	

-	// XYZ Frequencies of the noise functions:

-	NOISE_DATATYPE m_FrequencyX;

-	NOISE_DATATYPE m_FrequencyY;

-	NOISE_DATATYPE m_FrequencyZ;

-	

-	// Minimum and maximum chunk coords for chunks inside the island area. Chunks outside won't get calculated at all

-	int m_MinChunkX, m_MaxChunkX;

-	int m_MinChunkZ, m_MaxChunkZ;

-	

-	// Noise array for the last chunk (in the noise range)

-	int m_LastChunkX;

-	int m_LastChunkZ;

-	NOISE_DATATYPE m_NoiseArray[17 * 17 * 257];  // x + 17 * z + 17 * 17 * y

-	

-	/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array)

-	void PrepareState(int a_ChunkX, int a_ChunkZ);

-	

-	/// Generates the m_NoiseArray array for the current chunk

-	void GenerateNoiseArray(void);

-	

-	/// Returns true if the chunk is outside of the island's dimensions

-	bool IsChunkOutsideRange(int a_ChunkX, int a_ChunkZ);

-		

-	// cTerrainHeightGen overrides:

-	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;

-

-	// cTerrainCompositionGen overrides:

-	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;

-} ;

+
+// EndGen.h
+
+// Declares the cEndGen class representing the generator for the End, both as a HeightGen and CompositionGen
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "../Noise.h"
+
+
+
+
+
+class cEndGen :
+	public cTerrainHeightGen,
+	public cTerrainCompositionGen
+{
+public:
+	cEndGen(int a_Seed);
+	
+	void Initialize(cIniFile & a_IniFile);
+	
+protected:
+
+	/// Seed for the noise
+	int m_Seed;
+	
+	/// The Perlin noise used for generating
+	cPerlinNoise m_Perlin;
+
+	// XYZ size of the "island", in blocks:
+	int m_IslandSizeX;
+	int m_IslandSizeY;
+	int m_IslandSizeZ;
+	
+	// XYZ Frequencies of the noise functions:
+	NOISE_DATATYPE m_FrequencyX;
+	NOISE_DATATYPE m_FrequencyY;
+	NOISE_DATATYPE m_FrequencyZ;
+	
+	// Minimum and maximum chunk coords for chunks inside the island area. Chunks outside won't get calculated at all
+	int m_MinChunkX, m_MaxChunkX;
+	int m_MinChunkZ, m_MaxChunkZ;
+	
+	// Noise array for the last chunk (in the noise range)
+	int m_LastChunkX;
+	int m_LastChunkZ;
+	NOISE_DATATYPE m_NoiseArray[17 * 17 * 257];  // x + 17 * z + 17 * 17 * y
+	
+	/// Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array)
+	void PrepareState(int a_ChunkX, int a_ChunkZ);
+	
+	/// Generates the m_NoiseArray array for the current chunk
+	void GenerateNoiseArray(void);
+	
+	/// Returns true if the chunk is outside of the island's dimensions
+	bool IsChunkOutsideRange(int a_ChunkX, int a_ChunkZ);
+		
+	// cTerrainHeightGen overrides:
+	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;
+
+	// cTerrainCompositionGen overrides:
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
+} ;
diff --git a/source/Generating/MineShafts.cpp b/source/Generating/MineShafts.cpp
index 0f7f78e19..3131b5429 100644
--- a/source/Generating/MineShafts.cpp
+++ b/source/Generating/MineShafts.cpp
@@ -1,1423 +1,1423 @@
-

-// MineShafts.cpp

-

-// Implements the cStructGenMineShafts class representing the structure generator for abandoned mineshafts

-

-/*

-Algorithm:

-The cStructGenMineShafts::cMineShaftSystem class is the main controller, which knows what mineshaft

-classes there are and their random weights. It gets asked to produce a new class everytime a connection is to be made.

-The cMineShaft class is a base class for each mineshaft structure.

-Each cMineShaft descendant knows how large it is, how to imprint itself into the chunk data and where to connect to

-other descendants. Its PivotPoint is always a walkable column. Its Direction determines in which direction the structure

-is facing.

-

-The generation starts with the central dirt room, from there corridors, crossings and staircases are added

-in a depth-first processing. Each of the descendants will branch randomly, if not beyond the allowed recursion level

-*/

-

-#include "Globals.h"

-#include "MineShafts.h"

-#include "../Cuboid.h"

-#include "../BlockEntities/ChestEntity.h"

-

-

-

-

-

-static const int NEIGHBORHOOD_SIZE = 3;

-

-

-

-

-

-class cMineShaft abstract

-{

-public:

-	enum eKind

-	{

-		mskDirtRoom,

-		mskCorridor,

-		mskCrossing,

-		mskStaircase,

-	} ;

-	

-	

-	enum eDirection

-	{

-		dirXP,

-		dirZP,

-		dirXM,

-		dirZM,

-	} ;

-	

-	

-	cStructGenMineShafts::cMineShaftSystem & m_ParentSystem;

-	eKind   m_Kind;

-	cCuboid m_BoundingBox;

-

-

-	cMineShaft(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, eKind a_Kind) :

-		m_ParentSystem(a_ParentSystem),

-		m_Kind(a_Kind)

-	{

-	}

-	

-	cMineShaft(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, eKind a_Kind, const cCuboid & a_BoundingBox) :

-		m_ParentSystem(a_ParentSystem),

-		m_Kind(a_Kind),

-		m_BoundingBox(a_BoundingBox)

-	{

-	}

-	

-	/// Returns true if this mineshaft intersects the specified cuboid

-	bool DoesIntersect(const cCuboid & a_Other)

-	{

-		return m_BoundingBox.DoesIntersect(a_Other);

-	}

-	

-	/** If recursion level is not too large, appends more branches to the parent system,

-	using exit points specific to this class.

-	*/

-	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) = 0;

-	

-	/// Imprints this shape into the specified chunk's data

-	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) = 0;

-} ;

-

-typedef std::vector<cMineShaft *> cMineShafts;

-

-

-

-

-

-class cMineShaftDirtRoom :

-	public cMineShaft

-{

-	typedef cMineShaft super;

-	

-public:

-	cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise);

-	

-	// cMineShaft overrides:

-	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;

-	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

-

-class cMineShaftCorridor :

-	public cMineShaft

-{

-	typedef cMineShaft super;

-	

-public:

-	/** Creates a new Corridor attached to the specified pivot point and direction.

-	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.

-	May return NULL if cannot fit.

-	*/

-	static cMineShaft * CreateAndFit(

-		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-		int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,

-		cNoise & a_Noise

-	);

-	

-protected:

-	static const int MAX_SEGMENTS = 5;

-	

-	int        m_NumSegments;

-	eDirection m_Direction;

-	bool       m_HasFullBeam[MAX_SEGMENTS];  ///< If true, segment at that index has a full beam support (planks in the top center block)

-	int        m_ChestPosition;              ///< If <0, no chest; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on m_Direction

-	int        m_SpawnerPosition;            ///< If <0, no spawner; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on m_Direction

-	bool       m_HasTracks;                  ///< If true, random tracks will be placed on the floor

-	

-	cMineShaftCorridor(

-		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-		const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,

-		cNoise & a_Noise

-	);

-	

-	// cMineShaft overrides:

-	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;

-	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;

-

-	/// Places a chest, if the corridor has one

-	void PlaceChest(cChunkDesc & a_ChunkDesc);

-	

-	/// If this corridor has tracks, places them randomly

-	void PlaceTracks(cChunkDesc & a_ChunkDesc);

-	

-	/// If this corridor has a spawner, places the spawner

-	void PlaceSpawner(cChunkDesc & a_ChunkDesc);

-	

-	/// Randomly places torches around the central beam block

-	void PlaceTorches(cChunkDesc & a_ChunkDesc);

-} ;

-

-

-

-

-

-class cMineShaftCrossing :

-	public cMineShaft

-{

-	typedef cMineShaft super;

-	

-public:

-	/** Creates a new Crossing attached to the specified pivot point and direction.

-	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.

-	May return NULL if cannot fit.

-	*/

-	static cMineShaft * CreateAndFit(

-		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-		int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,

-		cNoise & a_Noise

-	);

-	

-protected:

-	cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox);

-	

-	// cMineShaft overrides:

-	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;

-	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

-

-class cMineShaftStaircase :

-	public cMineShaft

-{

-	typedef cMineShaft super;

-	

-public:

-	enum eSlope

-	{

-		sUp,

-		sDown,

-	} ;

-	

-	/** Creates a new Staircase attached to the specified pivot point and direction.

-	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.

-	May return NULL if cannot fit.

-	*/

-	static cMineShaft * CreateAndFit(

-		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-		int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,

-		cNoise & a_Noise

-	);

-	

-protected:

-	eDirection m_Direction;

-	eSlope     m_Slope;

-	

-	

-	cMineShaftStaircase(

-		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-		const cCuboid & a_BoundingBox,

-		eDirection a_Direction,

-		eSlope a_Slope

-	);

-

-	// cMineShaft overrides:

-	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;

-	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

-

-class cStructGenMineShafts::cMineShaftSystem

-{

-public:

-	int         m_BlockX, m_BlockZ;    ///< The pivot point on which the system is generated

-	int         m_GridSize;            ///< Maximum offset of the dirtroom from grid center, * 2, in each direction

-	int         m_MaxRecursion;        ///< Maximum recursion level (initialized from cStructGenMineShafts::m_MaxRecursion)

-	int         m_ProbLevelCorridor;   ///< Probability level of a branch object being the corridor

-	int         m_ProbLevelCrossing;   ///< Probability level of a branch object being the crossing, minus Corridor

-	int         m_ProbLevelStaircase;  ///< Probability level of a branch object being the staircase, minus Crossing

-	int         m_ChanceChest;         ///< Chance [0 .. 250] that a corridor has a chest in it

-	int         m_ChanceSpawner;       ///< Chance [0 .. 250] that a corridor has a spawner in it

-	int         m_ChanceTorch;         ///< Chance [0 .. 10k] for a torch appearing attached to a corridor's beam

-	cMineShafts m_MineShafts;          ///< List of cMineShaft descendants that comprise this system

-	cCuboid     m_BoundingBox;         ///< Bounding box into which all of the components need to fit

-

-	/// Creates and generates the entire system

-	cMineShaftSystem(

-		int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,

-		int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase

-	);

-

-	~cMineShaftSystem();

-

-	/// Carves the system into the chunk data

-	void ProcessChunk(cChunkDesc & a_Chunk);

-	

-	/** Creates new cMineShaft descendant connected at the specified point, heading the specified direction,

-	if it fits, appends it to the list and calls its AppendBranches()

-	*/

-	void AppendBranch(

-		int a_BlockX, int a_BlockY, int a_BlockZ,

-		cMineShaft::eDirection a_Direction, cNoise & a_Noise,

-		int a_RecursionLevel

-	);

-	

-	/// Returns true if none of the objects in m_MineShafts intersect with the specified bounding box and the bounding box is valid

-	bool CanAppend(const cCuboid & a_BoundingBox);

-} ;

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenMineShafts::cMineShaftSystem:

-

-cStructGenMineShafts::cMineShaftSystem::cMineShaftSystem(

-	int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,

-	int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase

-) :

-	m_BlockX(a_BlockX),

-	m_BlockZ(a_BlockZ),

-	m_GridSize(a_GridSize),

-	m_MaxRecursion(8),  // TODO: settable

-	m_ProbLevelCorridor(a_ProbLevelCorridor),

-	m_ProbLevelCrossing(a_ProbLevelCrossing),

-	m_ProbLevelStaircase(a_ProbLevelStaircase + 1),

-	m_ChanceChest(12),  // TODO: settable

-	m_ChanceSpawner(12),  // TODO: settable

-	m_ChanceTorch(1000)  // TODO: settable

-{

-	m_MineShafts.reserve(100);

-	

-	cMineShaft * Start = new cMineShaftDirtRoom(*this, a_Noise);

-	m_MineShafts.push_back(Start);

-

-	m_BoundingBox.Assign(

-		Start->m_BoundingBox.p1.x - a_MaxSystemSize / 2, 2,  Start->m_BoundingBox.p1.z - a_MaxSystemSize / 2,

-		Start->m_BoundingBox.p2.x + a_MaxSystemSize / 2, 50, Start->m_BoundingBox.p2.z + a_MaxSystemSize / 2

-	);

-	

-	Start->AppendBranches(0, a_Noise);

-	

-	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)

-	{

-		ASSERT((*itr)->m_BoundingBox.IsSorted());

-	}  // for itr - m_MineShafts[]

-}

-

-

-

-

-

-cStructGenMineShafts::cMineShaftSystem::~cMineShaftSystem()

-{

-	for (cMineShafts::iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)

-	{

-		delete *itr;

-	}  // for itr - m_MineShafts[]

-	m_MineShafts.clear();

-}

-

-

-

-

-

-void cStructGenMineShafts::cMineShaftSystem::ProcessChunk(cChunkDesc & a_Chunk)

-{

-	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)

-	{

-		(*itr)->ProcessChunk(a_Chunk);

-	}  // for itr - m_MineShafts[]

-}

-

-

-

-

-

-void cStructGenMineShafts::cMineShaftSystem::AppendBranch(

-	int a_PivotX, int a_PivotY, int a_PivotZ, 

-	cMineShaft::eDirection a_Direction, cNoise & a_Noise,

-	int a_RecursionLevel

-)

-{

-	if (a_RecursionLevel > m_MaxRecursion)

-	{

-		return;

-	}

-	

-	cMineShaft * Next = NULL;

-	int rnd = (a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_RecursionLevel * 16, a_PivotZ) / 13) % m_ProbLevelStaircase;

-	if (rnd < m_ProbLevelCorridor)

-	{

-		Next = cMineShaftCorridor::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);

-	}

-	else if (rnd < m_ProbLevelCrossing)

-	{

-		Next = cMineShaftCrossing::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);

-	}

-	else

-	{

-		Next = cMineShaftStaircase::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);

-	}

-	if (Next == NULL)

-	{

-		return;

-	}

-	m_MineShafts.push_back(Next);

-	Next->AppendBranches(a_RecursionLevel + 1, a_Noise);

-}

-

-

-

-

-

-bool cStructGenMineShafts::cMineShaftSystem::CanAppend(const cCuboid & a_BoundingBox)

-{

-	if (!a_BoundingBox.IsCompletelyInside(m_BoundingBox))

-	{

-		// Too far away, or too low / too high

-		return false;

-	}

-		

-	// Check intersections:

-	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)

-	{

-		if ((*itr)->DoesIntersect(a_BoundingBox))

-		{

-			return false;

-		}

-	}  // for itr - m_MineShafts[]

-	return true;

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cMineShaftDirtRoom:

-

-cMineShaftDirtRoom::cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise) :

-	super(a_Parent, mskDirtRoom)

-{

-	// Make the room of random size, min 10 x 4 x 10; max 18 x 12 x 18:

-	int rnd = a_Noise.IntNoise3DInt(a_Parent.m_BlockX, 0, a_Parent.m_BlockZ) / 7;

-	int OfsX = (rnd % a_Parent.m_GridSize) - a_Parent.m_GridSize / 2;

-	rnd >>= 12;

-	int OfsZ = (rnd % a_Parent.m_GridSize) - a_Parent.m_GridSize / 2;

-	rnd = a_Noise.IntNoise3DInt(a_Parent.m_BlockX, 1000, a_Parent.m_BlockZ) / 11;

-	m_BoundingBox.p1.x = a_Parent.m_BlockX + OfsX;

-	m_BoundingBox.p2.x = m_BoundingBox.p1.x + 10 + (rnd % 8);

-	rnd >>= 4;

-	m_BoundingBox.p1.z = a_Parent.m_BlockZ + OfsZ;

-	m_BoundingBox.p2.z = m_BoundingBox.p1.z + 10 + (rnd % 8);

-	rnd >>= 4;

-	m_BoundingBox.p1.y = 20;

-	m_BoundingBox.p2.y = 24 + rnd % 8;

-}

-

-

-

-

-

-void cMineShaftDirtRoom::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)

-{

-	int Height = m_BoundingBox.DifY() - 3;

-	for (int x = m_BoundingBox.p1.x + 1; x < m_BoundingBox.p2.x; x += 4)

-	{

-		int rnd = a_Noise.IntNoise3DInt(x, a_RecursionLevel, m_BoundingBox.p1.z) / 7;

-		m_ParentSystem.AppendBranch(x, m_BoundingBox.p1.y + (rnd % Height), m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);

-		rnd >>= 4;

-		m_ParentSystem.AppendBranch(x, m_BoundingBox.p1.y + (rnd % Height), m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);

-	}

-	

-	for (int z = m_BoundingBox.p1.z + 1; z < m_BoundingBox.p2.z; z += 4)

-	{

-		int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, a_RecursionLevel, z) / 13;

-		m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, m_BoundingBox.p1.y + (rnd % Height), z, dirXM, a_Noise, a_RecursionLevel);

-		rnd >>= 4;

-		m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, m_BoundingBox.p1.y + (rnd % Height), z, dirXP, a_Noise, a_RecursionLevel);

-	}

-}

-

-

-

-

-

-void cMineShaftDirtRoom::ProcessChunk(cChunkDesc & a_ChunkDesc)

-{

-	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-	if (

-		(m_BoundingBox.p1.x > BlockX + cChunkDef::Width) ||

-		(m_BoundingBox.p1.z > BlockZ + cChunkDef::Width) ||

-		(m_BoundingBox.p2.x < BlockX) ||

-		(m_BoundingBox.p2.z < BlockZ)

-	)

-	{

-		// Early bailout - cannot intersect this chunk

-		return;

-	}

-	

-	// Chunk-relative coords of the boundaries:

-	int MinX = std::max(BlockX, m_BoundingBox.p1.x) - BlockX;

-	int MaxX = std::min(BlockX + cChunkDef::Width, m_BoundingBox.p2.x + 1) - BlockX;

-	int MinZ = std::max(BlockZ, m_BoundingBox.p1.z) - BlockZ;

-	int MaxZ = std::min(BlockZ + cChunkDef::Width, m_BoundingBox.p2.z + 1) - BlockZ;

-	

-	// Carve the room out:

-	for (int z = MinZ; z < MaxZ; z++)

-	{

-		for (int x = MinX; x < MaxX; x++)

-		{

-			for (int y = m_BoundingBox.p1.y + 1; y < m_BoundingBox.p2.y; y++)

-			{

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

-			}

-			if (a_ChunkDesc.GetBlockType(x, m_BoundingBox.p1.y, z) != E_BLOCK_AIR)

-			{

-				a_ChunkDesc.SetBlockType(x, m_BoundingBox.p1.y, z, E_BLOCK_DIRT);

-			}

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cMineShaftCorridor:

-

-cMineShaftCorridor::cMineShaftCorridor(

-	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-	const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,

-	cNoise & a_Noise

-) :

-	super(a_ParentSystem, mskCorridor, a_BoundingBox),

-	m_NumSegments(a_NumSegments),

-	m_Direction(a_Direction),

-	m_ChestPosition(-1),

-	m_SpawnerPosition(-1)

-{

-	int rnd = a_Noise.IntNoise3DInt(a_BoundingBox.p1.x, a_BoundingBox.p1.y, a_BoundingBox.p1.z) / 7;

-	for (int i = 0; i < a_NumSegments; i++)

-	{

-		m_HasFullBeam[i] = (rnd % 4) < 3;  // 75 % chance of full beam

-		rnd >>= 2;

-	}

-	m_HasTracks = ((rnd % 4) < 2);  // 50 % chance of tracks

-	

-	rnd = a_Noise.IntNoise3DInt(a_BoundingBox.p1.z, a_BoundingBox.p1.x, a_BoundingBox.p1.y) / 7;

-	int ChestCheck = rnd % 250;

-	rnd >>= 8;

-	int SpawnerCheck = rnd % 250;

-	rnd >>= 8;

-	if (ChestCheck < a_ParentSystem.m_ChanceChest)

-	{

-		m_ChestPosition = rnd % (a_NumSegments * 5);

-	}

-	if ((a_NumSegments < 4) && (SpawnerCheck < a_ParentSystem.m_ChanceSpawner))

-	{

-		m_SpawnerPosition = rnd % (a_NumSegments * 5);

-	}

-}

-

-

-

-

-

-cMineShaft * cMineShaftCorridor::CreateAndFit(

-	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-	int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,

-	cNoise & a_Noise

-)

-{

-	cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);

-	BoundingBox.p2.y += 3;

-	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;

-	int NumSegments = 2 + (rnd) % (MAX_SEGMENTS - 1);  // 2 .. MAX_SEGMENTS

-	switch (a_Direction)

-	{

-		case dirXP: BoundingBox.p2.x += NumSegments * 5 - 1; BoundingBox.p1.z -= 1; BoundingBox.p2.z += 1; break;

-		case dirXM: BoundingBox.p1.x -= NumSegments * 5 - 1; BoundingBox.p1.z -= 1; BoundingBox.p2.z += 1; break;

-		case dirZP: BoundingBox.p2.z += NumSegments * 5 - 1; BoundingBox.p1.x -= 1; BoundingBox.p2.x += 1; break;

-		case dirZM: BoundingBox.p1.z -= NumSegments * 5 - 1; BoundingBox.p1.x -= 1; BoundingBox.p2.x += 1; break;

-	}

-	if (!a_ParentSystem.CanAppend(BoundingBox))

-	{

-		return NULL;

-	}

-	return new cMineShaftCorridor(a_ParentSystem, BoundingBox, NumSegments, a_Direction, a_Noise);

-}

-

-

-

-

-

-void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)

-{

-	int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 7;

-	// Prefer the same height, but allow for up to one block height displacement:

-	int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;

-	switch (m_Direction)

-	{

-		case dirXM:

-		{

-			m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel);

-			for (int i = m_NumSegments; i >= 0; i--)

-			{

-				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;

-				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;

-				rnd >>= 6;

-				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);

-			}

-			break;

-		}

-

-		case dirXP:

-		{

-			m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel);

-			for (int i = m_NumSegments; i >= 0; i--)

-			{

-				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;

-				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;

-				rnd >>= 6;

-				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);

-			}

-			break;

-		}

-		

-		case dirZM:

-		{

-			m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);

-			for (int i = m_NumSegments; i >= 0; i--)

-			{

-				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;

-				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;

-				rnd >>= 6;

-				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + Ofs, dirXM, a_Noise, a_RecursionLevel);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + Ofs, dirXP, a_Noise, a_RecursionLevel);

-			}

-			break;

-		}

-

-		case dirZP:

-		{

-			m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);

-			for (int i = m_NumSegments; i >= 0; i--)

-			{

-				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;

-				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;

-				rnd >>= 6;

-				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + Ofs, dirXM, a_Noise, a_RecursionLevel);

-				m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + Ofs, dirXP, a_Noise, a_RecursionLevel);

-			}

-			break;

-		}

-	}  // switch (m_Direction)

-}

-

-

-

-

-

-void cMineShaftCorridor::ProcessChunk(cChunkDesc & a_ChunkDesc)

-{

-	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-	cCuboid RelBoundingBox(m_BoundingBox);

-	RelBoundingBox.Move(-BlockX, 0, -BlockZ);

-	RelBoundingBox.p1.y += 1;

-	RelBoundingBox.p2.y -= 1;

-	cCuboid Top(RelBoundingBox);

-	Top.p2.y += 1;

-	Top.p1.y = Top.p2.y;

-	a_ChunkDesc.FillRelCuboid(RelBoundingBox, E_BLOCK_AIR, 0);

-	a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_AIR, 0, BlockX ^ BlockZ + BlockX, 8000);

-	if (m_SpawnerPosition >= 0)

-	{

-		// Cobwebs around the spider spawner

-		a_ChunkDesc.RandomFillRelCuboid(RelBoundingBox, E_BLOCK_COBWEB, 0, BlockX ^ BlockZ + BlockZ, 8000);

-		a_ChunkDesc.RandomFillRelCuboid(Top,            E_BLOCK_COBWEB, 0, BlockX ^ BlockZ + BlockX, 5000);

-	}

-	a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_COBWEB, 0, BlockX ^ BlockZ + BlockX + 10, 500);

-	RelBoundingBox.p1.y = m_BoundingBox.p1.y;

-	RelBoundingBox.p2.y = m_BoundingBox.p1.y;

-	a_ChunkDesc.FloorRelCuboid(RelBoundingBox, E_BLOCK_PLANKS, 0);

-	switch (m_Direction)

-	{

-		case dirXM:

-		case dirXP:

-		{

-			int y1 = m_BoundingBox.p1.y + 1;

-			int y2 = m_BoundingBox.p1.y + 2;

-			int y3 = m_BoundingBox.p1.y + 3;

-			int z1 = m_BoundingBox.p1.z - BlockZ;

-			int z2 = m_BoundingBox.p2.z - BlockZ;

-			for (int i = 0; i < m_NumSegments; i++)

-			{

-				int x = m_BoundingBox.p1.x + i * 5 + 2 - BlockX;

-				if ((x < 0) || (x >= cChunkDef::Width))

-				{

-					continue;

-				}

-				if ((z1 >= 0) && (z1 < cChunkDef::Width))

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x, y1, z1, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x, y2, z1, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x, y3, z1, E_BLOCK_PLANKS, 0);

-				}

-				if ((z2 >= 0) && (z2 < cChunkDef::Width))

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x, y1, z2, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x, y2, z2, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x, y3, z2, E_BLOCK_PLANKS, 0);

-				}

-				if ((z1 >= -1) && (z1 < cChunkDef::Width - 1) && m_HasFullBeam[i])

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x, y3, z1 + 1, E_BLOCK_PLANKS, 0);

-				}

-			}  // for i - NumSegments

-			break;

-		}

-		

-		case dirZM:

-		case dirZP:

-		{

-			int y1 = m_BoundingBox.p1.y + 1;

-			int y2 = m_BoundingBox.p1.y + 2;

-			int y3 = m_BoundingBox.p1.y + 3;

-			int x1 = m_BoundingBox.p1.x - BlockX;

-			int x2 = m_BoundingBox.p2.x - BlockX;

-			for (int i = 0; i < m_NumSegments; i++)

-			{

-				int z = m_BoundingBox.p1.z + i * 5 + 2 - BlockZ;

-				if ((z < 0) || (z >= cChunkDef::Width))

-				{

-					continue;

-				}

-				if ((x1 >= 0) && (x1 < cChunkDef::Width))

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x1, y1, z, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x1, y2, z, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x1, y3, z, E_BLOCK_PLANKS, 0);

-				}

-				if ((x2 >= 0) && (x2 < cChunkDef::Width))

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x2, y1, z, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x2, y2, z, E_BLOCK_FENCE, 0);

-					a_ChunkDesc.SetBlockTypeMeta(x2, y3, z, E_BLOCK_PLANKS, 0);

-				}

-				if ((x1 >= -1) && (x1 < cChunkDef::Width - 1) && m_HasFullBeam[i])

-				{

-					a_ChunkDesc.SetBlockTypeMeta(x1 + 1, y3, z, E_BLOCK_PLANKS, 0);

-				}

-			}  // for i - NumSegments

-			break;

-		}  // case dirZ?

-	}  // for i

-	

-	PlaceChest(a_ChunkDesc);

-	PlaceTracks(a_ChunkDesc);

-	PlaceSpawner(a_ChunkDesc); // (must be after Tracks!)

-	PlaceTorches(a_ChunkDesc);

-}

-

-

-

-

-

-void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)

-{

-	static const cLootProbab LootProbab[] =

-	{

-		// Item,                          MinAmount, MaxAmount, Weight

-		{ cItem(E_ITEM_IRON),             1,         5,         10 },

-		{ cItem(E_ITEM_GOLD),             1,         3,          5 },

-		{ cItem(E_ITEM_REDSTONE_DUST),    4,         9,          5 },

-		{ cItem(E_ITEM_DIAMOND),          1,         2,          3 },

-		{ cItem(E_ITEM_DYE, 1, 4),        4,         9,          5 },  // lapis lazuli dye

-		{ cItem(E_ITEM_COAL),             3,         8,         10 },

-		{ cItem(E_ITEM_BREAD),            1,         3,         15 },

-		{ cItem(E_ITEM_IRON_PICKAXE),     1,         1,          1 },

-		{ cItem(E_BLOCK_MINECART_TRACKS), 4,         8,          1 },

-		{ cItem(E_ITEM_MELON_SEEDS),      2,         4,         10 },

-		{ cItem(E_ITEM_PUMPKIN_SEEDS),    2,         4,         10 },

-	} ;

-

-	if (m_ChestPosition < 0)

-	{

-		return;

-	}

-	

-	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-	int x, z;

-	NIBBLETYPE Meta = 0;

-	switch (m_Direction)

-	{

-		case dirXM:

-		case dirXP:

-		{

-			x = m_BoundingBox.p1.x + m_ChestPosition - BlockX;

-			z = m_BoundingBox.p1.z - BlockZ;

-			Meta = E_META_CHEST_FACING_ZP;

-			break;

-		}

-		

-		case dirZM:

-		case dirZP:

-		{

-			x = m_BoundingBox.p1.x - BlockX;

-			z = m_BoundingBox.p1.z + m_ChestPosition - BlockZ;

-			Meta = E_META_CHEST_FACING_XP;

-			break;

-		}

-	}  // switch (Dir)

-

-	if (

-		(x >= 0) && (x < cChunkDef::Width) &&

-		(z >= 0) && (z < cChunkDef::Width)

-	)

-	{

-		a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p1.y + 1, z, E_BLOCK_CHEST, Meta);

-		cChestEntity * ChestEntity = new cChestEntity(BlockX + x, m_BoundingBox.p1.y + 1, BlockZ + z);

-		cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());

-		int NumSlots = 3 + ((Noise.IntNoise3DInt(x, m_BoundingBox.p1.y, z) / 11) % 4);

-		int Seed = Noise.IntNoise2DInt(x, z);

-		ChestEntity->GetContents().GenerateRandomLootWithBooks(LootProbab, ARRAYCOUNT(LootProbab), NumSlots, Seed);

-		a_ChunkDesc.AddBlockEntity(ChestEntity);

-	}

-}

-

-

-

-

-

-void cMineShaftCorridor::PlaceTracks(cChunkDesc & a_ChunkDesc)

-{

-	if (!m_HasTracks)

-	{

-		return;

-	}

-	cCuboid Box(m_BoundingBox);

-	Box.Move(-a_ChunkDesc.GetChunkX() * cChunkDef::Width, 1, -a_ChunkDesc.GetChunkZ() * cChunkDef::Width);

-	Box.p2.y = Box.p1.y;

-	Box.p1.x += 1;

-	Box.p2.x -= 1;

-	Box.p1.z += 1;

-	Box.p2.z -= 1;

-	NIBBLETYPE Meta = 0;

-	switch (m_Direction)

-	{

-		case dirXM:

-		case dirXP:

-		{

-			Meta = E_META_TRACKS_X;

-			break;

-		}

-		

-		case dirZM:

-		case dirZP:

-		{

-			Meta = E_META_TRACKS_Z;

-			break;

-		}

-	}  // switch (direction)

-	a_ChunkDesc.RandomFillRelCuboid(Box, E_BLOCK_MINECART_TRACKS, Meta, a_ChunkDesc.GetChunkX() + a_ChunkDesc.GetChunkZ(), 6000);

-}

-

-

-

-

-

-void cMineShaftCorridor::PlaceSpawner(cChunkDesc & a_ChunkDesc)

-{

-	if (m_SpawnerPosition < 0)

-	{

-		// No spawner in this corridor

-		return;

-	}

-	int SpawnerRelX = m_BoundingBox.p1.x + 1 - a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-	int SpawnerRelZ = m_BoundingBox.p1.z + 1 - a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-	switch (m_Direction)

-	{

-		case dirXM:

-		case dirXP:

-		{

-			SpawnerRelX += m_SpawnerPosition - 1;

-			break;

-		}

-		case dirZM:

-		case dirZP:

-		{

-			SpawnerRelZ += m_SpawnerPosition - 1;

-			break;

-		}

-	}

-	if (

-		(SpawnerRelX >= 0) && (SpawnerRelX < cChunkDef::Width) &&

-		(SpawnerRelZ >= 0) && (SpawnerRelZ < cChunkDef::Width)

-	)

-	{

-		a_ChunkDesc.SetBlockTypeMeta(SpawnerRelX, m_BoundingBox.p1.y + 1, SpawnerRelZ, E_BLOCK_MOB_SPAWNER, 0);

-		// TODO: The spawner needs its accompanying cMobSpawnerEntity, when implemented

-	}

-}

-

-

-

-

-

-void cMineShaftCorridor::PlaceTorches(cChunkDesc & a_ChunkDesc)

-{

-	cNoise Noise(m_BoundingBox.p1.x);

-	switch (m_Direction)

-	{

-		case dirXM:

-		case dirXP:

-		{

-			int z = m_BoundingBox.p1.z + 1 - a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-			if ((z < 0) || (z >= cChunkDef::Width))

-			{

-				return;

-			}

-			int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-			for (int i = 0; i < m_NumSegments; i++)

-			{

-				if (!m_HasFullBeam[i])

-				{

-					continue;

-				}

-				int x = m_BoundingBox.p1.x + i * 5 + 1 - BlockX;

-				if ((x >= 0) && (x < cChunkDef::Width))

-				{

-					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)

-					{

-						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_XP);

-					}

-				}

-				x += 2;

-				if ((x >= 0) && (x < cChunkDef::Width))

-				{

-					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)

-					{

-						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_XM);

-					}

-				}

-			}  // for i

-			break;

-		}

-		

-		case dirZM:

-		case dirZP:

-		{

-			int x = m_BoundingBox.p1.x + 1 - a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-			if ((x < 0) || (x >= cChunkDef::Width))

-			{

-				return;

-			}

-			int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-			for (int i = 0; i < m_NumSegments; i++)

-			{

-				if (!m_HasFullBeam[i])

-				{

-					continue;

-				}

-				int z = m_BoundingBox.p1.z + i * 5 + 1 - BlockZ;

-				if ((z >= 0) && (z < cChunkDef::Width))

-				{

-					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)

-					{

-						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_ZP);

-					}

-				}

-				z += 2;

-				if ((z >= 0) && (z < cChunkDef::Width))

-				{

-					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)

-					{

-						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_ZM);

-					}

-				}

-			}  // for i

-			break;

-		}

-	}  // switch (direction)

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cMineShaftCrossing:

-

-cMineShaftCrossing::cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox) :

-	super(a_ParentSystem, mskCrossing, a_BoundingBox)

-{

-}

-

-

-

-

-

-cMineShaft * cMineShaftCrossing::CreateAndFit(

-	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-	int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,

-	cNoise & a_Noise

-)

-{

-	cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);

-	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;

-	BoundingBox.p2.y += 3;

-	if ((rnd % 4) < 2)

-	{

-		// 2-level crossing:

-		BoundingBox.p2.y += 4;

-		rnd >>= 2;

-		if ((rnd % 4) < 2)

-		{

-			// This is the higher level:

-			BoundingBox.p1.y -= 4;

-			BoundingBox.p2.y -= 4;

-		}

-	}

-	rnd >>= 2;

-	switch (a_Direction)

-	{

-		case dirXP: BoundingBox.p2.x += 4; BoundingBox.p1.z -= 2; BoundingBox.p2.z += 2; break;

-		case dirXM: BoundingBox.p1.x -= 4; BoundingBox.p1.z -= 2; BoundingBox.p2.z += 2; break;

-		case dirZP: BoundingBox.p2.z += 4; BoundingBox.p1.x -= 2; BoundingBox.p2.x += 2; break;

-		case dirZM: BoundingBox.p1.z -= 4; BoundingBox.p1.x -= 2; BoundingBox.p2.x += 2; break;

-	}

-	if (!a_ParentSystem.CanAppend(BoundingBox))

-	{

-		return NULL;

-	}

-	return new cMineShaftCrossing(a_ParentSystem, BoundingBox);

-}

-

-

-

-

-

-void cMineShaftCrossing::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)

-{

-	struct

-	{

-		int x, y, z;

-		eDirection dir;

-	} Exits[] =

-	{

-		// Bottom level:

-		{-1, 1,  2, dirXM},

-		{ 2, 1, -1, dirZM},

-		{ 5, 1,  2, dirXP},

-		{ 2, 1,  5, dirZP},

-		// Top level:

-		{-1, 5,  2, dirXM},

-		{ 2, 5, -1, dirZM},

-		{ 5, 5,  2, dirXP},

-		{ 2, 5,  5, dirZP},

-	} ;

-	for (int i = 0; i < ARRAYCOUNT(Exits); i++)

-	{

-		if (m_BoundingBox.p1.y + Exits[i].y >= m_BoundingBox.p2.y)

-		{

-			// This exit is not available (two-level exit on a one-level crossing)

-			continue;

-		}

-		

-		int Height = m_BoundingBox.p1.y + Exits[i].y;

-		m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Exits[i].x, Height, m_BoundingBox.p1.z + Exits[i].z, Exits[i].dir, a_Noise, a_RecursionLevel);

-	}  // for i

-}

-

-

-

-

-

-void cMineShaftCrossing::ProcessChunk(cChunkDesc & a_ChunkDesc)

-{

-	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-	cCuboid box(m_BoundingBox);

-	box.Move(-BlockX, 0, -BlockZ);

-	if ((box.p2.x < 0) || (box.p2.z < 0) || (box.p1.x >= cChunkDef::Width) || (box.p1.z > cChunkDef::Width))

-	{

-		// Does not intersect this chunk

-		return;

-	}

-	int Floor = box.p1.y + 1;

-	int Ceil = box.p2.y;

-

-	// The supports:

-	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p1.x + 1, Floor, Ceil, box.p1.z + 1, box.p1.z + 1, E_BLOCK_PLANKS, 0);

-	a_ChunkDesc.FillRelCuboid(box.p2.x - 1, box.p2.x - 1, Floor, Ceil, box.p1.z + 1, box.p1.z + 1, E_BLOCK_PLANKS, 0);

-	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p1.x + 1, Floor, Ceil, box.p2.z - 1, box.p2.z - 1, E_BLOCK_PLANKS, 0);

-	a_ChunkDesc.FillRelCuboid(box.p2.x - 1, box.p2.x - 1, Floor, Ceil, box.p2.z - 1, box.p2.z - 1, E_BLOCK_PLANKS, 0);

-

-	// The air in between:

-	a_ChunkDesc.FillRelCuboid(box.p1.x + 2, box.p1.x + 2, Floor, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);

-	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Ceil, box.p1.z + 2, box.p1.z + 2, E_BLOCK_AIR, 0);

-

-	// The air on the edges:

-	int Mid = Floor + 2;

-	a_ChunkDesc.FillRelCuboid(box.p1.x,     box.p1.x,     Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);

-	a_ChunkDesc.FillRelCuboid(box.p2.x,     box.p2.x,     Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);

-	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p1.z,     box.p1.z,     E_BLOCK_AIR, 0);

-	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p2.z,     box.p2.z,     E_BLOCK_AIR, 0);

-	Mid += 2;

-	if (Mid < Ceil)

-	{

-		a_ChunkDesc.FillRelCuboid(box.p1.x,     box.p1.x,     Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);

-		a_ChunkDesc.FillRelCuboid(box.p2.x,     box.p2.x,     Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);

-		a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p1.z,     box.p1.z,     E_BLOCK_AIR, 0);

-		a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p2.z,     box.p2.z,     E_BLOCK_AIR, 0);

-	}

-	

-	// The floor, if needed:

-	box.p2.y = box.p1.y;

-	a_ChunkDesc.FloorRelCuboid(box, E_BLOCK_PLANKS, 0);

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cMineShaftStaircase:

-

-cMineShaftStaircase::cMineShaftStaircase(

-	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-	const cCuboid & a_BoundingBox,

-	eDirection a_Direction,

-	eSlope a_Slope

-) :

-	super(a_ParentSystem, mskStaircase, a_BoundingBox),

-	m_Direction(a_Direction),

-	m_Slope(a_Slope)

-{

-}

-

-

-

-

-

-cMineShaft * cMineShaftStaircase::CreateAndFit(

-	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,

-	int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,

-	cNoise & a_Noise

-)

-{

-	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;

-	cCuboid Box;

-	switch (a_Direction)

-	{

-		case dirXM:

-		{

-			Box.Assign(a_PivotX - 7, a_PivotY - 1, a_PivotZ - 1, a_PivotX, a_PivotY + 6, a_PivotZ + 1);

-			break;

-		}

-		case dirXP:

-		{

-			Box.Assign(a_PivotX, a_PivotY - 1, a_PivotZ - 1, a_PivotX + 7, a_PivotY + 6, a_PivotZ + 1);

-			break;

-		}

-		case dirZM:

-		{

-			Box.Assign(a_PivotX - 1, a_PivotY - 1, a_PivotZ - 7, a_PivotX + 1, a_PivotY + 6, a_PivotZ);

-			break;

-		}

-		case dirZP:

-		{

-			Box.Assign(a_PivotX - 1, a_PivotY - 1, a_PivotZ, a_PivotX + 1, a_PivotY + 6, a_PivotZ + 7);

-			break;

-		}

-	}

-	eSlope Slope = sUp;

-	if ((rnd % 4) < 2)  // 50 %

-	{

-		Slope = sDown;

-		Box.Move(0, -4, 0);

-	}

-	if (!a_ParentSystem.CanAppend(Box))

-	{

-		return NULL;

-	}

-	return new cMineShaftStaircase(a_ParentSystem, Box, a_Direction, Slope);

-}

-

-

-

-

-

-void cMineShaftStaircase::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)

-{

-	int Height = m_BoundingBox.p1.y + ((m_Slope == sDown) ? 1 : 5);

-	switch (m_Direction)

-	{

-		case dirXM: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel); break;

-		case dirXP: m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel); break;

-		case dirZM: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel); break;

-		case dirZP: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel); break;

-	}

-}

-

-

-

-

-

-void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)

-{

-	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;

-	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;

-	cCuboid RelB(m_BoundingBox);

-	RelB.Move(-BlockX, 0, -BlockZ);

-	if (

-		(RelB.p1.x >= cChunkDef::Width) ||

-		(RelB.p1.z >= cChunkDef::Width) ||

-		(RelB.p2.x < 0) ||

-		(RelB.p2.z < 0)

-	)

-	{

-		// No intersection between this staircase and this chunk

-		return;

-	}

-	

-	int SFloor = RelB.p1.y + ((m_Slope == sDown) ? 5 : 1);

-	int DFloor = RelB.p1.y + ((m_Slope == sDown) ? 1 : 5);

-	int Add = (m_Slope == sDown) ? -1 : 1;

-	int InitAdd = (m_Slope == sDown) ? -1 : 0;

-	cCuboid Box;

-	switch (m_Direction)

-	{

-		case dirXM:

-		{

-			a_ChunkDesc.FillRelCuboid (RelB.p2.x - 1, RelB.p2.x,     SFloor,     SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);

-			a_ChunkDesc.FillRelCuboid (RelB.p1.x,     RelB.p1.x + 1, DFloor,     DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p2.x - 1, RelB.p2.x,     SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p1.x,     RelB.p1.x + 1, DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);

-			Box.Assign(RelB.p2.x - 2, SFloor + InitAdd, RelB.p1.z, RelB.p2.x - 2, SFloor + 3 + InitAdd, RelB.p2.z);

-			for (int i = 0; i < 4; i++)

-			{

-				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);

-				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);

-				Box.Move(-1, Add, 0);

-			}

-			break;

-		}

-		

-		case dirXP:

-		{

-			a_ChunkDesc.FillRelCuboid (RelB.p1.x,     RelB.p1.x + 1, SFloor,     SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);

-			a_ChunkDesc.FillRelCuboid (RelB.p2.x - 1, RelB.p2.x,     DFloor,     DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p1.x,     RelB.p1.x + 1, SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p2.x - 1, RelB.p2.x,     DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);

-			Box.Assign(RelB.p1.x + 2, SFloor + InitAdd, RelB.p1.z, RelB.p1.x + 2, SFloor + 3 + InitAdd, RelB.p2.z);

-			for (int i = 0; i < 4; i++)

-			{

-				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);

-				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);

-				Box.Move(1, Add, 0);

-			}

-			break;

-		}

-

-		case dirZM:

-		{

-			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, SFloor,     SFloor + 2, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_AIR, 0);

-			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, DFloor,     DFloor + 2, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_AIR, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_PLANKS, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_PLANKS, 0);

-			Box.Assign(RelB.p1.x, SFloor + InitAdd, RelB.p2.z - 2, RelB.p2.x, SFloor + 3 + InitAdd, RelB.p2.z - 2);

-			for (int i = 0; i < 4; i++)

-			{

-				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);

-				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);

-				Box.Move(0, Add, -1);

-			}

-			break;

-		}

-		

-		case dirZP:

-		{

-			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, SFloor,     SFloor + 2, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_AIR, 0);

-			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, DFloor,     DFloor + 2, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_AIR, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_PLANKS, 0);

-			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_PLANKS, 0);

-			Box.Assign(RelB.p1.x, SFloor + InitAdd, RelB.p1.z + 2, RelB.p2.x, SFloor + 3 + InitAdd, RelB.p1.z + 2);

-			for (int i = 0; i < 4; i++)

-			{

-				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);

-				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);

-				Box.Move(0, Add, 1);

-			}

-			break;

-		}

-		

-	}  // switch (m_Direction)

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenMineShafts:

-

-cStructGenMineShafts::cStructGenMineShafts(

-	int a_Seed, int a_GridSize, int a_MaxSystemSize,

-	int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase

-) :

-	m_Noise(a_Seed),

-	m_GridSize(a_GridSize),

-	m_MaxSystemSize(a_MaxSystemSize),

-	m_ProbLevelCorridor(std::max(0, a_ChanceCorridor)),

-	m_ProbLevelCrossing(std::max(0, a_ChanceCorridor + a_ChanceCrossing)),

-	m_ProbLevelStaircase(std::max(0, a_ChanceCorridor + a_ChanceCrossing + a_ChanceStaircase))

-{

-}

-

-

-

-

-

-cStructGenMineShafts::~cStructGenMineShafts()

-{

-	ClearCache();

-}

-

-

-

-

-

-void cStructGenMineShafts::ClearCache(void)

-{

-	for (cMineShaftSystems::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)

-	{

-		delete *itr;

-	}  // for itr - m_Cache[]

-	m_Cache.clear();

-}

-

-

-

-

-

-void cStructGenMineShafts::GetMineShaftSystemsForChunk(

-	int a_ChunkX, int a_ChunkZ,

-	cStructGenMineShafts::cMineShaftSystems & a_MineShafts

-)

-{

-	int BaseX = a_ChunkX * cChunkDef::Width / m_GridSize;

-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_GridSize;

-	if (BaseX < 0)

-	{

-		--BaseX;

-	}

-	if (BaseZ < 0)

-	{

-		--BaseZ;

-	}

-	BaseX -= NEIGHBORHOOD_SIZE / 2;

-	BaseZ -= NEIGHBORHOOD_SIZE / 2;

-

-	// Walk the cache, move each cave system that we want into a_Caves:

-	int StartX = BaseX * m_GridSize;

-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_GridSize;

-	int StartZ = BaseZ * m_GridSize;

-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_GridSize;

-	for (cMineShaftSystems::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)

-	{

-		if (

-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&

-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)

-		)

-		{

-			// want

-			a_MineShafts.push_back(*itr);

-			itr = m_Cache.erase(itr);

-		}

-		else

-		{

-			// don't want

-			++itr;

-		}

-	}  // for itr - m_Cache[]

-	

-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)

-	{

-		int RealX = (BaseX + x) * m_GridSize;

-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)

-		{

-			int RealZ = (BaseZ + z) * m_GridSize;

-			bool Found = false;

-			for (cMineShaftSystems::const_iterator itr = a_MineShafts.begin(), end = a_MineShafts.end(); itr != end; ++itr)

-			{

-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))

-				{

-					Found = true;

-					break;

-				}

-			}  // for itr - a_Mineshafts

-			if (!Found)

-			{

-				a_MineShafts.push_back(new cMineShaftSystem(RealX, RealZ, m_GridSize, m_MaxSystemSize, m_Noise, m_ProbLevelCorridor, m_ProbLevelCrossing, m_ProbLevelStaircase));

-			}

-		}  // for z

-	}  // for x

-	

-	// Copy a_MineShafts into m_Cache to the beginning:

-	cMineShaftSystems MineShaftsCopy(a_MineShafts);

-	m_Cache.splice(m_Cache.begin(), MineShaftsCopy, MineShaftsCopy.begin(), MineShaftsCopy.end());

-	

-	// Trim the cache if it's too long:

-	if (m_Cache.size() > 100)

-	{

-		cMineShaftSystems::iterator itr = m_Cache.begin();

-		std::advance(itr, 100);

-		for (cMineShaftSystems::iterator end = m_Cache.end(); itr != end; ++itr)

-		{

-			delete *itr;

-		}

-		itr = m_Cache.begin();

-		std::advance(itr, 100);

-		m_Cache.erase(itr, m_Cache.end());

-	}

-}

-

-

-

-

-

-

-void cStructGenMineShafts::GenStructures(cChunkDesc & a_ChunkDesc)

-{

-	int ChunkX = a_ChunkDesc.GetChunkX();

-	int ChunkZ = a_ChunkDesc.GetChunkZ();

-	cMineShaftSystems MineShafts;

-	GetMineShaftSystemsForChunk(ChunkX, ChunkZ, MineShafts);

-	for (cMineShaftSystems::const_iterator itr = MineShafts.begin(); itr != MineShafts.end(); ++itr)

-	{

-		(*itr)->ProcessChunk(a_ChunkDesc);

-	}  // for itr - MineShafts[]

-}

-

-

-

-

+
+// MineShafts.cpp
+
+// Implements the cStructGenMineShafts class representing the structure generator for abandoned mineshafts
+
+/*
+Algorithm:
+The cStructGenMineShafts::cMineShaftSystem class is the main controller, which knows what mineshaft
+classes there are and their random weights. It gets asked to produce a new class everytime a connection is to be made.
+The cMineShaft class is a base class for each mineshaft structure.
+Each cMineShaft descendant knows how large it is, how to imprint itself into the chunk data and where to connect to
+other descendants. Its PivotPoint is always a walkable column. Its Direction determines in which direction the structure
+is facing.
+
+The generation starts with the central dirt room, from there corridors, crossings and staircases are added
+in a depth-first processing. Each of the descendants will branch randomly, if not beyond the allowed recursion level
+*/
+
+#include "Globals.h"
+#include "MineShafts.h"
+#include "../Cuboid.h"
+#include "../BlockEntities/ChestEntity.h"
+
+
+
+
+
+static const int NEIGHBORHOOD_SIZE = 3;
+
+
+
+
+
+class cMineShaft abstract
+{
+public:
+	enum eKind
+	{
+		mskDirtRoom,
+		mskCorridor,
+		mskCrossing,
+		mskStaircase,
+	} ;
+	
+	
+	enum eDirection
+	{
+		dirXP,
+		dirZP,
+		dirXM,
+		dirZM,
+	} ;
+	
+	
+	cStructGenMineShafts::cMineShaftSystem & m_ParentSystem;
+	eKind   m_Kind;
+	cCuboid m_BoundingBox;
+
+
+	cMineShaft(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, eKind a_Kind) :
+		m_ParentSystem(a_ParentSystem),
+		m_Kind(a_Kind)
+	{
+	}
+	
+	cMineShaft(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, eKind a_Kind, const cCuboid & a_BoundingBox) :
+		m_ParentSystem(a_ParentSystem),
+		m_Kind(a_Kind),
+		m_BoundingBox(a_BoundingBox)
+	{
+	}
+	
+	/// Returns true if this mineshaft intersects the specified cuboid
+	bool DoesIntersect(const cCuboid & a_Other)
+	{
+		return m_BoundingBox.DoesIntersect(a_Other);
+	}
+	
+	/** If recursion level is not too large, appends more branches to the parent system,
+	using exit points specific to this class.
+	*/
+	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) = 0;
+	
+	/// Imprints this shape into the specified chunk's data
+	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) = 0;
+} ;
+
+typedef std::vector<cMineShaft *> cMineShafts;
+
+
+
+
+
+class cMineShaftDirtRoom :
+	public cMineShaft
+{
+	typedef cMineShaft super;
+	
+public:
+	cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise);
+	
+	// cMineShaft overrides:
+	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
+	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
+
+class cMineShaftCorridor :
+	public cMineShaft
+{
+	typedef cMineShaft super;
+	
+public:
+	/** Creates a new Corridor attached to the specified pivot point and direction.
+	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
+	May return NULL if cannot fit.
+	*/
+	static cMineShaft * CreateAndFit(
+		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+		int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+		cNoise & a_Noise
+	);
+	
+protected:
+	static const int MAX_SEGMENTS = 5;
+	
+	int        m_NumSegments;
+	eDirection m_Direction;
+	bool       m_HasFullBeam[MAX_SEGMENTS];  ///< If true, segment at that index has a full beam support (planks in the top center block)
+	int        m_ChestPosition;              ///< If <0, no chest; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on m_Direction
+	int        m_SpawnerPosition;            ///< If <0, no spawner; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on m_Direction
+	bool       m_HasTracks;                  ///< If true, random tracks will be placed on the floor
+	
+	cMineShaftCorridor(
+		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+		const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,
+		cNoise & a_Noise
+	);
+	
+	// cMineShaft overrides:
+	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
+	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
+
+	/// Places a chest, if the corridor has one
+	void PlaceChest(cChunkDesc & a_ChunkDesc);
+	
+	/// If this corridor has tracks, places them randomly
+	void PlaceTracks(cChunkDesc & a_ChunkDesc);
+	
+	/// If this corridor has a spawner, places the spawner
+	void PlaceSpawner(cChunkDesc & a_ChunkDesc);
+	
+	/// Randomly places torches around the central beam block
+	void PlaceTorches(cChunkDesc & a_ChunkDesc);
+} ;
+
+
+
+
+
+class cMineShaftCrossing :
+	public cMineShaft
+{
+	typedef cMineShaft super;
+	
+public:
+	/** Creates a new Crossing attached to the specified pivot point and direction.
+	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
+	May return NULL if cannot fit.
+	*/
+	static cMineShaft * CreateAndFit(
+		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+		int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+		cNoise & a_Noise
+	);
+	
+protected:
+	cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox);
+	
+	// cMineShaft overrides:
+	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
+	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
+
+class cMineShaftStaircase :
+	public cMineShaft
+{
+	typedef cMineShaft super;
+	
+public:
+	enum eSlope
+	{
+		sUp,
+		sDown,
+	} ;
+	
+	/** Creates a new Staircase attached to the specified pivot point and direction.
+	Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
+	May return NULL if cannot fit.
+	*/
+	static cMineShaft * CreateAndFit(
+		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+		int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+		cNoise & a_Noise
+	);
+	
+protected:
+	eDirection m_Direction;
+	eSlope     m_Slope;
+	
+	
+	cMineShaftStaircase(
+		cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+		const cCuboid & a_BoundingBox,
+		eDirection a_Direction,
+		eSlope a_Slope
+	);
+
+	// cMineShaft overrides:
+	virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
+	virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
+
+class cStructGenMineShafts::cMineShaftSystem
+{
+public:
+	int         m_BlockX, m_BlockZ;    ///< The pivot point on which the system is generated
+	int         m_GridSize;            ///< Maximum offset of the dirtroom from grid center, * 2, in each direction
+	int         m_MaxRecursion;        ///< Maximum recursion level (initialized from cStructGenMineShafts::m_MaxRecursion)
+	int         m_ProbLevelCorridor;   ///< Probability level of a branch object being the corridor
+	int         m_ProbLevelCrossing;   ///< Probability level of a branch object being the crossing, minus Corridor
+	int         m_ProbLevelStaircase;  ///< Probability level of a branch object being the staircase, minus Crossing
+	int         m_ChanceChest;         ///< Chance [0 .. 250] that a corridor has a chest in it
+	int         m_ChanceSpawner;       ///< Chance [0 .. 250] that a corridor has a spawner in it
+	int         m_ChanceTorch;         ///< Chance [0 .. 10k] for a torch appearing attached to a corridor's beam
+	cMineShafts m_MineShafts;          ///< List of cMineShaft descendants that comprise this system
+	cCuboid     m_BoundingBox;         ///< Bounding box into which all of the components need to fit
+
+	/// Creates and generates the entire system
+	cMineShaftSystem(
+		int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
+		int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
+	);
+
+	~cMineShaftSystem();
+
+	/// Carves the system into the chunk data
+	void ProcessChunk(cChunkDesc & a_Chunk);
+	
+	/** Creates new cMineShaft descendant connected at the specified point, heading the specified direction,
+	if it fits, appends it to the list and calls its AppendBranches()
+	*/
+	void AppendBranch(
+		int a_BlockX, int a_BlockY, int a_BlockZ,
+		cMineShaft::eDirection a_Direction, cNoise & a_Noise,
+		int a_RecursionLevel
+	);
+	
+	/// Returns true if none of the objects in m_MineShafts intersect with the specified bounding box and the bounding box is valid
+	bool CanAppend(const cCuboid & a_BoundingBox);
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenMineShafts::cMineShaftSystem:
+
+cStructGenMineShafts::cMineShaftSystem::cMineShaftSystem(
+	int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
+	int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
+) :
+	m_BlockX(a_BlockX),
+	m_BlockZ(a_BlockZ),
+	m_GridSize(a_GridSize),
+	m_MaxRecursion(8),  // TODO: settable
+	m_ProbLevelCorridor(a_ProbLevelCorridor),
+	m_ProbLevelCrossing(a_ProbLevelCrossing),
+	m_ProbLevelStaircase(a_ProbLevelStaircase + 1),
+	m_ChanceChest(12),  // TODO: settable
+	m_ChanceSpawner(12),  // TODO: settable
+	m_ChanceTorch(1000)  // TODO: settable
+{
+	m_MineShafts.reserve(100);
+	
+	cMineShaft * Start = new cMineShaftDirtRoom(*this, a_Noise);
+	m_MineShafts.push_back(Start);
+
+	m_BoundingBox.Assign(
+		Start->m_BoundingBox.p1.x - a_MaxSystemSize / 2, 2,  Start->m_BoundingBox.p1.z - a_MaxSystemSize / 2,
+		Start->m_BoundingBox.p2.x + a_MaxSystemSize / 2, 50, Start->m_BoundingBox.p2.z + a_MaxSystemSize / 2
+	);
+	
+	Start->AppendBranches(0, a_Noise);
+	
+	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)
+	{
+		ASSERT((*itr)->m_BoundingBox.IsSorted());
+	}  // for itr - m_MineShafts[]
+}
+
+
+
+
+
+cStructGenMineShafts::cMineShaftSystem::~cMineShaftSystem()
+{
+	for (cMineShafts::iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - m_MineShafts[]
+	m_MineShafts.clear();
+}
+
+
+
+
+
+void cStructGenMineShafts::cMineShaftSystem::ProcessChunk(cChunkDesc & a_Chunk)
+{
+	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)
+	{
+		(*itr)->ProcessChunk(a_Chunk);
+	}  // for itr - m_MineShafts[]
+}
+
+
+
+
+
+void cStructGenMineShafts::cMineShaftSystem::AppendBranch(
+	int a_PivotX, int a_PivotY, int a_PivotZ, 
+	cMineShaft::eDirection a_Direction, cNoise & a_Noise,
+	int a_RecursionLevel
+)
+{
+	if (a_RecursionLevel > m_MaxRecursion)
+	{
+		return;
+	}
+	
+	cMineShaft * Next = NULL;
+	int rnd = (a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_RecursionLevel * 16, a_PivotZ) / 13) % m_ProbLevelStaircase;
+	if (rnd < m_ProbLevelCorridor)
+	{
+		Next = cMineShaftCorridor::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);
+	}
+	else if (rnd < m_ProbLevelCrossing)
+	{
+		Next = cMineShaftCrossing::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);
+	}
+	else
+	{
+		Next = cMineShaftStaircase::CreateAndFit(*this, a_PivotX, a_PivotY, a_PivotZ, a_Direction, a_Noise);
+	}
+	if (Next == NULL)
+	{
+		return;
+	}
+	m_MineShafts.push_back(Next);
+	Next->AppendBranches(a_RecursionLevel + 1, a_Noise);
+}
+
+
+
+
+
+bool cStructGenMineShafts::cMineShaftSystem::CanAppend(const cCuboid & a_BoundingBox)
+{
+	if (!a_BoundingBox.IsCompletelyInside(m_BoundingBox))
+	{
+		// Too far away, or too low / too high
+		return false;
+	}
+		
+	// Check intersections:
+	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)
+	{
+		if ((*itr)->DoesIntersect(a_BoundingBox))
+		{
+			return false;
+		}
+	}  // for itr - m_MineShafts[]
+	return true;
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cMineShaftDirtRoom:
+
+cMineShaftDirtRoom::cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise) :
+	super(a_Parent, mskDirtRoom)
+{
+	// Make the room of random size, min 10 x 4 x 10; max 18 x 12 x 18:
+	int rnd = a_Noise.IntNoise3DInt(a_Parent.m_BlockX, 0, a_Parent.m_BlockZ) / 7;
+	int OfsX = (rnd % a_Parent.m_GridSize) - a_Parent.m_GridSize / 2;
+	rnd >>= 12;
+	int OfsZ = (rnd % a_Parent.m_GridSize) - a_Parent.m_GridSize / 2;
+	rnd = a_Noise.IntNoise3DInt(a_Parent.m_BlockX, 1000, a_Parent.m_BlockZ) / 11;
+	m_BoundingBox.p1.x = a_Parent.m_BlockX + OfsX;
+	m_BoundingBox.p2.x = m_BoundingBox.p1.x + 10 + (rnd % 8);
+	rnd >>= 4;
+	m_BoundingBox.p1.z = a_Parent.m_BlockZ + OfsZ;
+	m_BoundingBox.p2.z = m_BoundingBox.p1.z + 10 + (rnd % 8);
+	rnd >>= 4;
+	m_BoundingBox.p1.y = 20;
+	m_BoundingBox.p2.y = 24 + rnd % 8;
+}
+
+
+
+
+
+void cMineShaftDirtRoom::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
+{
+	int Height = m_BoundingBox.DifY() - 3;
+	for (int x = m_BoundingBox.p1.x + 1; x < m_BoundingBox.p2.x; x += 4)
+	{
+		int rnd = a_Noise.IntNoise3DInt(x, a_RecursionLevel, m_BoundingBox.p1.z) / 7;
+		m_ParentSystem.AppendBranch(x, m_BoundingBox.p1.y + (rnd % Height), m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+		rnd >>= 4;
+		m_ParentSystem.AppendBranch(x, m_BoundingBox.p1.y + (rnd % Height), m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+	}
+	
+	for (int z = m_BoundingBox.p1.z + 1; z < m_BoundingBox.p2.z; z += 4)
+	{
+		int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, a_RecursionLevel, z) / 13;
+		m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, m_BoundingBox.p1.y + (rnd % Height), z, dirXM, a_Noise, a_RecursionLevel);
+		rnd >>= 4;
+		m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, m_BoundingBox.p1.y + (rnd % Height), z, dirXP, a_Noise, a_RecursionLevel);
+	}
+}
+
+
+
+
+
+void cMineShaftDirtRoom::ProcessChunk(cChunkDesc & a_ChunkDesc)
+{
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	if (
+		(m_BoundingBox.p1.x > BlockX + cChunkDef::Width) ||
+		(m_BoundingBox.p1.z > BlockZ + cChunkDef::Width) ||
+		(m_BoundingBox.p2.x < BlockX) ||
+		(m_BoundingBox.p2.z < BlockZ)
+	)
+	{
+		// Early bailout - cannot intersect this chunk
+		return;
+	}
+	
+	// Chunk-relative coords of the boundaries:
+	int MinX = std::max(BlockX, m_BoundingBox.p1.x) - BlockX;
+	int MaxX = std::min(BlockX + cChunkDef::Width, m_BoundingBox.p2.x + 1) - BlockX;
+	int MinZ = std::max(BlockZ, m_BoundingBox.p1.z) - BlockZ;
+	int MaxZ = std::min(BlockZ + cChunkDef::Width, m_BoundingBox.p2.z + 1) - BlockZ;
+	
+	// Carve the room out:
+	for (int z = MinZ; z < MaxZ; z++)
+	{
+		for (int x = MinX; x < MaxX; x++)
+		{
+			for (int y = m_BoundingBox.p1.y + 1; y < m_BoundingBox.p2.y; y++)
+			{
+				a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);
+			}
+			if (a_ChunkDesc.GetBlockType(x, m_BoundingBox.p1.y, z) != E_BLOCK_AIR)
+			{
+				a_ChunkDesc.SetBlockType(x, m_BoundingBox.p1.y, z, E_BLOCK_DIRT);
+			}
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cMineShaftCorridor:
+
+cMineShaftCorridor::cMineShaftCorridor(
+	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+	const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,
+	cNoise & a_Noise
+) :
+	super(a_ParentSystem, mskCorridor, a_BoundingBox),
+	m_NumSegments(a_NumSegments),
+	m_Direction(a_Direction),
+	m_ChestPosition(-1),
+	m_SpawnerPosition(-1)
+{
+	int rnd = a_Noise.IntNoise3DInt(a_BoundingBox.p1.x, a_BoundingBox.p1.y, a_BoundingBox.p1.z) / 7;
+	for (int i = 0; i < a_NumSegments; i++)
+	{
+		m_HasFullBeam[i] = (rnd % 4) < 3;  // 75 % chance of full beam
+		rnd >>= 2;
+	}
+	m_HasTracks = ((rnd % 4) < 2);  // 50 % chance of tracks
+	
+	rnd = a_Noise.IntNoise3DInt(a_BoundingBox.p1.z, a_BoundingBox.p1.x, a_BoundingBox.p1.y) / 7;
+	int ChestCheck = rnd % 250;
+	rnd >>= 8;
+	int SpawnerCheck = rnd % 250;
+	rnd >>= 8;
+	if (ChestCheck < a_ParentSystem.m_ChanceChest)
+	{
+		m_ChestPosition = rnd % (a_NumSegments * 5);
+	}
+	if ((a_NumSegments < 4) && (SpawnerCheck < a_ParentSystem.m_ChanceSpawner))
+	{
+		m_SpawnerPosition = rnd % (a_NumSegments * 5);
+	}
+}
+
+
+
+
+
+cMineShaft * cMineShaftCorridor::CreateAndFit(
+	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+	int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+	cNoise & a_Noise
+)
+{
+	cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
+	BoundingBox.p2.y += 3;
+	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
+	int NumSegments = 2 + (rnd) % (MAX_SEGMENTS - 1);  // 2 .. MAX_SEGMENTS
+	switch (a_Direction)
+	{
+		case dirXP: BoundingBox.p2.x += NumSegments * 5 - 1; BoundingBox.p1.z -= 1; BoundingBox.p2.z += 1; break;
+		case dirXM: BoundingBox.p1.x -= NumSegments * 5 - 1; BoundingBox.p1.z -= 1; BoundingBox.p2.z += 1; break;
+		case dirZP: BoundingBox.p2.z += NumSegments * 5 - 1; BoundingBox.p1.x -= 1; BoundingBox.p2.x += 1; break;
+		case dirZM: BoundingBox.p1.z -= NumSegments * 5 - 1; BoundingBox.p1.x -= 1; BoundingBox.p2.x += 1; break;
+	}
+	if (!a_ParentSystem.CanAppend(BoundingBox))
+	{
+		return NULL;
+	}
+	return new cMineShaftCorridor(a_ParentSystem, BoundingBox, NumSegments, a_Direction, a_Noise);
+}
+
+
+
+
+
+void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
+{
+	int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 7;
+	// Prefer the same height, but allow for up to one block height displacement:
+	int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
+	switch (m_Direction)
+	{
+		case dirXM:
+		{
+			m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel);
+			for (int i = m_NumSegments; i >= 0; i--)
+			{
+				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
+				rnd >>= 6;
+				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+			}
+			break;
+		}
+
+		case dirXP:
+		{
+			m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel);
+			for (int i = m_NumSegments; i >= 0; i--)
+			{
+				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
+				rnd >>= 6;
+				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+			}
+			break;
+		}
+		
+		case dirZM:
+		{
+			m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+			for (int i = m_NumSegments; i >= 0; i--)
+			{
+				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
+				rnd >>= 6;
+				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + Ofs, dirXM, a_Noise, a_RecursionLevel);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + Ofs, dirXP, a_Noise, a_RecursionLevel);
+			}
+			break;
+		}
+
+		case dirZP:
+		{
+			m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+			for (int i = m_NumSegments; i >= 0; i--)
+			{
+				int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+				int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
+				rnd >>= 6;
+				int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + Ofs, dirXM, a_Noise, a_RecursionLevel);
+				m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + Ofs, dirXP, a_Noise, a_RecursionLevel);
+			}
+			break;
+		}
+	}  // switch (m_Direction)
+}
+
+
+
+
+
+void cMineShaftCorridor::ProcessChunk(cChunkDesc & a_ChunkDesc)
+{
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	cCuboid RelBoundingBox(m_BoundingBox);
+	RelBoundingBox.Move(-BlockX, 0, -BlockZ);
+	RelBoundingBox.p1.y += 1;
+	RelBoundingBox.p2.y -= 1;
+	cCuboid Top(RelBoundingBox);
+	Top.p2.y += 1;
+	Top.p1.y = Top.p2.y;
+	a_ChunkDesc.FillRelCuboid(RelBoundingBox, E_BLOCK_AIR, 0);
+	a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_AIR, 0, BlockX ^ BlockZ + BlockX, 8000);
+	if (m_SpawnerPosition >= 0)
+	{
+		// Cobwebs around the spider spawner
+		a_ChunkDesc.RandomFillRelCuboid(RelBoundingBox, E_BLOCK_COBWEB, 0, BlockX ^ BlockZ + BlockZ, 8000);
+		a_ChunkDesc.RandomFillRelCuboid(Top,            E_BLOCK_COBWEB, 0, BlockX ^ BlockZ + BlockX, 5000);
+	}
+	a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_COBWEB, 0, BlockX ^ BlockZ + BlockX + 10, 500);
+	RelBoundingBox.p1.y = m_BoundingBox.p1.y;
+	RelBoundingBox.p2.y = m_BoundingBox.p1.y;
+	a_ChunkDesc.FloorRelCuboid(RelBoundingBox, E_BLOCK_PLANKS, 0);
+	switch (m_Direction)
+	{
+		case dirXM:
+		case dirXP:
+		{
+			int y1 = m_BoundingBox.p1.y + 1;
+			int y2 = m_BoundingBox.p1.y + 2;
+			int y3 = m_BoundingBox.p1.y + 3;
+			int z1 = m_BoundingBox.p1.z - BlockZ;
+			int z2 = m_BoundingBox.p2.z - BlockZ;
+			for (int i = 0; i < m_NumSegments; i++)
+			{
+				int x = m_BoundingBox.p1.x + i * 5 + 2 - BlockX;
+				if ((x < 0) || (x >= cChunkDef::Width))
+				{
+					continue;
+				}
+				if ((z1 >= 0) && (z1 < cChunkDef::Width))
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y1, z1, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x, y2, z1, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x, y3, z1, E_BLOCK_PLANKS, 0);
+				}
+				if ((z2 >= 0) && (z2 < cChunkDef::Width))
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y1, z2, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x, y2, z2, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x, y3, z2, E_BLOCK_PLANKS, 0);
+				}
+				if ((z1 >= -1) && (z1 < cChunkDef::Width - 1) && m_HasFullBeam[i])
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x, y3, z1 + 1, E_BLOCK_PLANKS, 0);
+				}
+			}  // for i - NumSegments
+			break;
+		}
+		
+		case dirZM:
+		case dirZP:
+		{
+			int y1 = m_BoundingBox.p1.y + 1;
+			int y2 = m_BoundingBox.p1.y + 2;
+			int y3 = m_BoundingBox.p1.y + 3;
+			int x1 = m_BoundingBox.p1.x - BlockX;
+			int x2 = m_BoundingBox.p2.x - BlockX;
+			for (int i = 0; i < m_NumSegments; i++)
+			{
+				int z = m_BoundingBox.p1.z + i * 5 + 2 - BlockZ;
+				if ((z < 0) || (z >= cChunkDef::Width))
+				{
+					continue;
+				}
+				if ((x1 >= 0) && (x1 < cChunkDef::Width))
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x1, y1, z, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x1, y2, z, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x1, y3, z, E_BLOCK_PLANKS, 0);
+				}
+				if ((x2 >= 0) && (x2 < cChunkDef::Width))
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x2, y1, z, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x2, y2, z, E_BLOCK_FENCE, 0);
+					a_ChunkDesc.SetBlockTypeMeta(x2, y3, z, E_BLOCK_PLANKS, 0);
+				}
+				if ((x1 >= -1) && (x1 < cChunkDef::Width - 1) && m_HasFullBeam[i])
+				{
+					a_ChunkDesc.SetBlockTypeMeta(x1 + 1, y3, z, E_BLOCK_PLANKS, 0);
+				}
+			}  // for i - NumSegments
+			break;
+		}  // case dirZ?
+	}  // for i
+	
+	PlaceChest(a_ChunkDesc);
+	PlaceTracks(a_ChunkDesc);
+	PlaceSpawner(a_ChunkDesc); // (must be after Tracks!)
+	PlaceTorches(a_ChunkDesc);
+}
+
+
+
+
+
+void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
+{
+	static const cLootProbab LootProbab[] =
+	{
+		// Item,                          MinAmount, MaxAmount, Weight
+		{ cItem(E_ITEM_IRON),             1,         5,         10 },
+		{ cItem(E_ITEM_GOLD),             1,         3,          5 },
+		{ cItem(E_ITEM_REDSTONE_DUST),    4,         9,          5 },
+		{ cItem(E_ITEM_DIAMOND),          1,         2,          3 },
+		{ cItem(E_ITEM_DYE, 1, 4),        4,         9,          5 },  // lapis lazuli dye
+		{ cItem(E_ITEM_COAL),             3,         8,         10 },
+		{ cItem(E_ITEM_BREAD),            1,         3,         15 },
+		{ cItem(E_ITEM_IRON_PICKAXE),     1,         1,          1 },
+		{ cItem(E_BLOCK_MINECART_TRACKS), 4,         8,          1 },
+		{ cItem(E_ITEM_MELON_SEEDS),      2,         4,         10 },
+		{ cItem(E_ITEM_PUMPKIN_SEEDS),    2,         4,         10 },
+	} ;
+
+	if (m_ChestPosition < 0)
+	{
+		return;
+	}
+	
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	int x, z;
+	NIBBLETYPE Meta = 0;
+	switch (m_Direction)
+	{
+		case dirXM:
+		case dirXP:
+		{
+			x = m_BoundingBox.p1.x + m_ChestPosition - BlockX;
+			z = m_BoundingBox.p1.z - BlockZ;
+			Meta = E_META_CHEST_FACING_ZP;
+			break;
+		}
+		
+		case dirZM:
+		case dirZP:
+		{
+			x = m_BoundingBox.p1.x - BlockX;
+			z = m_BoundingBox.p1.z + m_ChestPosition - BlockZ;
+			Meta = E_META_CHEST_FACING_XP;
+			break;
+		}
+	}  // switch (Dir)
+
+	if (
+		(x >= 0) && (x < cChunkDef::Width) &&
+		(z >= 0) && (z < cChunkDef::Width)
+	)
+	{
+		a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p1.y + 1, z, E_BLOCK_CHEST, Meta);
+		cChestEntity * ChestEntity = new cChestEntity(BlockX + x, m_BoundingBox.p1.y + 1, BlockZ + z);
+		cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
+		int NumSlots = 3 + ((Noise.IntNoise3DInt(x, m_BoundingBox.p1.y, z) / 11) % 4);
+		int Seed = Noise.IntNoise2DInt(x, z);
+		ChestEntity->GetContents().GenerateRandomLootWithBooks(LootProbab, ARRAYCOUNT(LootProbab), NumSlots, Seed);
+		a_ChunkDesc.AddBlockEntity(ChestEntity);
+	}
+}
+
+
+
+
+
+void cMineShaftCorridor::PlaceTracks(cChunkDesc & a_ChunkDesc)
+{
+	if (!m_HasTracks)
+	{
+		return;
+	}
+	cCuboid Box(m_BoundingBox);
+	Box.Move(-a_ChunkDesc.GetChunkX() * cChunkDef::Width, 1, -a_ChunkDesc.GetChunkZ() * cChunkDef::Width);
+	Box.p2.y = Box.p1.y;
+	Box.p1.x += 1;
+	Box.p2.x -= 1;
+	Box.p1.z += 1;
+	Box.p2.z -= 1;
+	NIBBLETYPE Meta = 0;
+	switch (m_Direction)
+	{
+		case dirXM:
+		case dirXP:
+		{
+			Meta = E_META_TRACKS_X;
+			break;
+		}
+		
+		case dirZM:
+		case dirZP:
+		{
+			Meta = E_META_TRACKS_Z;
+			break;
+		}
+	}  // switch (direction)
+	a_ChunkDesc.RandomFillRelCuboid(Box, E_BLOCK_MINECART_TRACKS, Meta, a_ChunkDesc.GetChunkX() + a_ChunkDesc.GetChunkZ(), 6000);
+}
+
+
+
+
+
+void cMineShaftCorridor::PlaceSpawner(cChunkDesc & a_ChunkDesc)
+{
+	if (m_SpawnerPosition < 0)
+	{
+		// No spawner in this corridor
+		return;
+	}
+	int SpawnerRelX = m_BoundingBox.p1.x + 1 - a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int SpawnerRelZ = m_BoundingBox.p1.z + 1 - a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	switch (m_Direction)
+	{
+		case dirXM:
+		case dirXP:
+		{
+			SpawnerRelX += m_SpawnerPosition - 1;
+			break;
+		}
+		case dirZM:
+		case dirZP:
+		{
+			SpawnerRelZ += m_SpawnerPosition - 1;
+			break;
+		}
+	}
+	if (
+		(SpawnerRelX >= 0) && (SpawnerRelX < cChunkDef::Width) &&
+		(SpawnerRelZ >= 0) && (SpawnerRelZ < cChunkDef::Width)
+	)
+	{
+		a_ChunkDesc.SetBlockTypeMeta(SpawnerRelX, m_BoundingBox.p1.y + 1, SpawnerRelZ, E_BLOCK_MOB_SPAWNER, 0);
+		// TODO: The spawner needs its accompanying cMobSpawnerEntity, when implemented
+	}
+}
+
+
+
+
+
+void cMineShaftCorridor::PlaceTorches(cChunkDesc & a_ChunkDesc)
+{
+	cNoise Noise(m_BoundingBox.p1.x);
+	switch (m_Direction)
+	{
+		case dirXM:
+		case dirXP:
+		{
+			int z = m_BoundingBox.p1.z + 1 - a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+			if ((z < 0) || (z >= cChunkDef::Width))
+			{
+				return;
+			}
+			int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+			for (int i = 0; i < m_NumSegments; i++)
+			{
+				if (!m_HasFullBeam[i])
+				{
+					continue;
+				}
+				int x = m_BoundingBox.p1.x + i * 5 + 1 - BlockX;
+				if ((x >= 0) && (x < cChunkDef::Width))
+				{
+					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)
+					{
+						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_XP);
+					}
+				}
+				x += 2;
+				if ((x >= 0) && (x < cChunkDef::Width))
+				{
+					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)
+					{
+						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_XM);
+					}
+				}
+			}  // for i
+			break;
+		}
+		
+		case dirZM:
+		case dirZP:
+		{
+			int x = m_BoundingBox.p1.x + 1 - a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+			if ((x < 0) || (x >= cChunkDef::Width))
+			{
+				return;
+			}
+			int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+			for (int i = 0; i < m_NumSegments; i++)
+			{
+				if (!m_HasFullBeam[i])
+				{
+					continue;
+				}
+				int z = m_BoundingBox.p1.z + i * 5 + 1 - BlockZ;
+				if ((z >= 0) && (z < cChunkDef::Width))
+				{
+					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)
+					{
+						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_ZP);
+					}
+				}
+				z += 2;
+				if ((z >= 0) && (z < cChunkDef::Width))
+				{
+					if (((Noise.IntNoise2DInt(x, z) / 7) % 10000) < m_ParentSystem.m_ChanceTorch)
+					{
+						a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p2.y, z, E_BLOCK_TORCH, E_META_TORCH_ZM);
+					}
+				}
+			}  // for i
+			break;
+		}
+	}  // switch (direction)
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cMineShaftCrossing:
+
+cMineShaftCrossing::cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox) :
+	super(a_ParentSystem, mskCrossing, a_BoundingBox)
+{
+}
+
+
+
+
+
+cMineShaft * cMineShaftCrossing::CreateAndFit(
+	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+	int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+	cNoise & a_Noise
+)
+{
+	cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
+	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
+	BoundingBox.p2.y += 3;
+	if ((rnd % 4) < 2)
+	{
+		// 2-level crossing:
+		BoundingBox.p2.y += 4;
+		rnd >>= 2;
+		if ((rnd % 4) < 2)
+		{
+			// This is the higher level:
+			BoundingBox.p1.y -= 4;
+			BoundingBox.p2.y -= 4;
+		}
+	}
+	rnd >>= 2;
+	switch (a_Direction)
+	{
+		case dirXP: BoundingBox.p2.x += 4; BoundingBox.p1.z -= 2; BoundingBox.p2.z += 2; break;
+		case dirXM: BoundingBox.p1.x -= 4; BoundingBox.p1.z -= 2; BoundingBox.p2.z += 2; break;
+		case dirZP: BoundingBox.p2.z += 4; BoundingBox.p1.x -= 2; BoundingBox.p2.x += 2; break;
+		case dirZM: BoundingBox.p1.z -= 4; BoundingBox.p1.x -= 2; BoundingBox.p2.x += 2; break;
+	}
+	if (!a_ParentSystem.CanAppend(BoundingBox))
+	{
+		return NULL;
+	}
+	return new cMineShaftCrossing(a_ParentSystem, BoundingBox);
+}
+
+
+
+
+
+void cMineShaftCrossing::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
+{
+	struct
+	{
+		int x, y, z;
+		eDirection dir;
+	} Exits[] =
+	{
+		// Bottom level:
+		{-1, 1,  2, dirXM},
+		{ 2, 1, -1, dirZM},
+		{ 5, 1,  2, dirXP},
+		{ 2, 1,  5, dirZP},
+		// Top level:
+		{-1, 5,  2, dirXM},
+		{ 2, 5, -1, dirZM},
+		{ 5, 5,  2, dirXP},
+		{ 2, 5,  5, dirZP},
+	} ;
+	for (int i = 0; i < ARRAYCOUNT(Exits); i++)
+	{
+		if (m_BoundingBox.p1.y + Exits[i].y >= m_BoundingBox.p2.y)
+		{
+			// This exit is not available (two-level exit on a one-level crossing)
+			continue;
+		}
+		
+		int Height = m_BoundingBox.p1.y + Exits[i].y;
+		m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Exits[i].x, Height, m_BoundingBox.p1.z + Exits[i].z, Exits[i].dir, a_Noise, a_RecursionLevel);
+	}  // for i
+}
+
+
+
+
+
+void cMineShaftCrossing::ProcessChunk(cChunkDesc & a_ChunkDesc)
+{
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	cCuboid box(m_BoundingBox);
+	box.Move(-BlockX, 0, -BlockZ);
+	if ((box.p2.x < 0) || (box.p2.z < 0) || (box.p1.x >= cChunkDef::Width) || (box.p1.z > cChunkDef::Width))
+	{
+		// Does not intersect this chunk
+		return;
+	}
+	int Floor = box.p1.y + 1;
+	int Ceil = box.p2.y;
+
+	// The supports:
+	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p1.x + 1, Floor, Ceil, box.p1.z + 1, box.p1.z + 1, E_BLOCK_PLANKS, 0);
+	a_ChunkDesc.FillRelCuboid(box.p2.x - 1, box.p2.x - 1, Floor, Ceil, box.p1.z + 1, box.p1.z + 1, E_BLOCK_PLANKS, 0);
+	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p1.x + 1, Floor, Ceil, box.p2.z - 1, box.p2.z - 1, E_BLOCK_PLANKS, 0);
+	a_ChunkDesc.FillRelCuboid(box.p2.x - 1, box.p2.x - 1, Floor, Ceil, box.p2.z - 1, box.p2.z - 1, E_BLOCK_PLANKS, 0);
+
+	// The air in between:
+	a_ChunkDesc.FillRelCuboid(box.p1.x + 2, box.p1.x + 2, Floor, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Ceil, box.p1.z + 2, box.p1.z + 2, E_BLOCK_AIR, 0);
+
+	// The air on the edges:
+	int Mid = Floor + 2;
+	a_ChunkDesc.FillRelCuboid(box.p1.x,     box.p1.x,     Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+	a_ChunkDesc.FillRelCuboid(box.p2.x,     box.p2.x,     Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p1.z,     box.p1.z,     E_BLOCK_AIR, 0);
+	a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p2.z,     box.p2.z,     E_BLOCK_AIR, 0);
+	Mid += 2;
+	if (Mid < Ceil)
+	{
+		a_ChunkDesc.FillRelCuboid(box.p1.x,     box.p1.x,     Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+		a_ChunkDesc.FillRelCuboid(box.p2.x,     box.p2.x,     Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+		a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p1.z,     box.p1.z,     E_BLOCK_AIR, 0);
+		a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p2.z,     box.p2.z,     E_BLOCK_AIR, 0);
+	}
+	
+	// The floor, if needed:
+	box.p2.y = box.p1.y;
+	a_ChunkDesc.FloorRelCuboid(box, E_BLOCK_PLANKS, 0);
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cMineShaftStaircase:
+
+cMineShaftStaircase::cMineShaftStaircase(
+	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+	const cCuboid & a_BoundingBox,
+	eDirection a_Direction,
+	eSlope a_Slope
+) :
+	super(a_ParentSystem, mskStaircase, a_BoundingBox),
+	m_Direction(a_Direction),
+	m_Slope(a_Slope)
+{
+}
+
+
+
+
+
+cMineShaft * cMineShaftStaircase::CreateAndFit(
+	cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+	int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+	cNoise & a_Noise
+)
+{
+	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
+	cCuboid Box;
+	switch (a_Direction)
+	{
+		case dirXM:
+		{
+			Box.Assign(a_PivotX - 7, a_PivotY - 1, a_PivotZ - 1, a_PivotX, a_PivotY + 6, a_PivotZ + 1);
+			break;
+		}
+		case dirXP:
+		{
+			Box.Assign(a_PivotX, a_PivotY - 1, a_PivotZ - 1, a_PivotX + 7, a_PivotY + 6, a_PivotZ + 1);
+			break;
+		}
+		case dirZM:
+		{
+			Box.Assign(a_PivotX - 1, a_PivotY - 1, a_PivotZ - 7, a_PivotX + 1, a_PivotY + 6, a_PivotZ);
+			break;
+		}
+		case dirZP:
+		{
+			Box.Assign(a_PivotX - 1, a_PivotY - 1, a_PivotZ, a_PivotX + 1, a_PivotY + 6, a_PivotZ + 7);
+			break;
+		}
+	}
+	eSlope Slope = sUp;
+	if ((rnd % 4) < 2)  // 50 %
+	{
+		Slope = sDown;
+		Box.Move(0, -4, 0);
+	}
+	if (!a_ParentSystem.CanAppend(Box))
+	{
+		return NULL;
+	}
+	return new cMineShaftStaircase(a_ParentSystem, Box, a_Direction, Slope);
+}
+
+
+
+
+
+void cMineShaftStaircase::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
+{
+	int Height = m_BoundingBox.p1.y + ((m_Slope == sDown) ? 1 : 5);
+	switch (m_Direction)
+	{
+		case dirXM: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel); break;
+		case dirXP: m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel); break;
+		case dirZM: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel); break;
+		case dirZP: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel); break;
+	}
+}
+
+
+
+
+
+void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
+{
+	int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
+	cCuboid RelB(m_BoundingBox);
+	RelB.Move(-BlockX, 0, -BlockZ);
+	if (
+		(RelB.p1.x >= cChunkDef::Width) ||
+		(RelB.p1.z >= cChunkDef::Width) ||
+		(RelB.p2.x < 0) ||
+		(RelB.p2.z < 0)
+	)
+	{
+		// No intersection between this staircase and this chunk
+		return;
+	}
+	
+	int SFloor = RelB.p1.y + ((m_Slope == sDown) ? 5 : 1);
+	int DFloor = RelB.p1.y + ((m_Slope == sDown) ? 1 : 5);
+	int Add = (m_Slope == sDown) ? -1 : 1;
+	int InitAdd = (m_Slope == sDown) ? -1 : 0;
+	cCuboid Box;
+	switch (m_Direction)
+	{
+		case dirXM:
+		{
+			a_ChunkDesc.FillRelCuboid (RelB.p2.x - 1, RelB.p2.x,     SFloor,     SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+			a_ChunkDesc.FillRelCuboid (RelB.p1.x,     RelB.p1.x + 1, DFloor,     DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p2.x - 1, RelB.p2.x,     SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p1.x,     RelB.p1.x + 1, DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
+			Box.Assign(RelB.p2.x - 2, SFloor + InitAdd, RelB.p1.z, RelB.p2.x - 2, SFloor + 3 + InitAdd, RelB.p2.z);
+			for (int i = 0; i < 4; i++)
+			{
+				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
+				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+				Box.Move(-1, Add, 0);
+			}
+			break;
+		}
+		
+		case dirXP:
+		{
+			a_ChunkDesc.FillRelCuboid (RelB.p1.x,     RelB.p1.x + 1, SFloor,     SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+			a_ChunkDesc.FillRelCuboid (RelB.p2.x - 1, RelB.p2.x,     DFloor,     DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p1.x,     RelB.p1.x + 1, SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p2.x - 1, RelB.p2.x,     DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
+			Box.Assign(RelB.p1.x + 2, SFloor + InitAdd, RelB.p1.z, RelB.p1.x + 2, SFloor + 3 + InitAdd, RelB.p2.z);
+			for (int i = 0; i < 4; i++)
+			{
+				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
+				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+				Box.Move(1, Add, 0);
+			}
+			break;
+		}
+
+		case dirZM:
+		{
+			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, SFloor,     SFloor + 2, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_AIR, 0);
+			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, DFloor,     DFloor + 2, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_AIR, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_PLANKS, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_PLANKS, 0);
+			Box.Assign(RelB.p1.x, SFloor + InitAdd, RelB.p2.z - 2, RelB.p2.x, SFloor + 3 + InitAdd, RelB.p2.z - 2);
+			for (int i = 0; i < 4; i++)
+			{
+				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
+				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+				Box.Move(0, Add, -1);
+			}
+			break;
+		}
+		
+		case dirZP:
+		{
+			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, SFloor,     SFloor + 2, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_AIR, 0);
+			a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, DFloor,     DFloor + 2, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_AIR, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p1.z,     RelB.p1.z + 1,  E_BLOCK_PLANKS, 0);
+			a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p2.z - 1, RelB.p2.z,      E_BLOCK_PLANKS, 0);
+			Box.Assign(RelB.p1.x, SFloor + InitAdd, RelB.p1.z + 2, RelB.p2.x, SFloor + 3 + InitAdd, RelB.p1.z + 2);
+			for (int i = 0; i < 4; i++)
+			{
+				a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
+				a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+				Box.Move(0, Add, 1);
+			}
+			break;
+		}
+		
+	}  // switch (m_Direction)
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenMineShafts:
+
+cStructGenMineShafts::cStructGenMineShafts(
+	int a_Seed, int a_GridSize, int a_MaxSystemSize,
+	int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
+) :
+	m_Noise(a_Seed),
+	m_GridSize(a_GridSize),
+	m_MaxSystemSize(a_MaxSystemSize),
+	m_ProbLevelCorridor(std::max(0, a_ChanceCorridor)),
+	m_ProbLevelCrossing(std::max(0, a_ChanceCorridor + a_ChanceCrossing)),
+	m_ProbLevelStaircase(std::max(0, a_ChanceCorridor + a_ChanceCrossing + a_ChanceStaircase))
+{
+}
+
+
+
+
+
+cStructGenMineShafts::~cStructGenMineShafts()
+{
+	ClearCache();
+}
+
+
+
+
+
+void cStructGenMineShafts::ClearCache(void)
+{
+	for (cMineShaftSystems::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - m_Cache[]
+	m_Cache.clear();
+}
+
+
+
+
+
+void cStructGenMineShafts::GetMineShaftSystemsForChunk(
+	int a_ChunkX, int a_ChunkZ,
+	cStructGenMineShafts::cMineShaftSystems & a_MineShafts
+)
+{
+	int BaseX = a_ChunkX * cChunkDef::Width / m_GridSize;
+	int BaseZ = a_ChunkZ * cChunkDef::Width / m_GridSize;
+	if (BaseX < 0)
+	{
+		--BaseX;
+	}
+	if (BaseZ < 0)
+	{
+		--BaseZ;
+	}
+	BaseX -= NEIGHBORHOOD_SIZE / 2;
+	BaseZ -= NEIGHBORHOOD_SIZE / 2;
+
+	// Walk the cache, move each cave system that we want into a_Caves:
+	int StartX = BaseX * m_GridSize;
+	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
+	int StartZ = BaseZ * m_GridSize;
+	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
+	for (cMineShaftSystems::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
+	{
+		if (
+			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
+			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
+		)
+		{
+			// want
+			a_MineShafts.push_back(*itr);
+			itr = m_Cache.erase(itr);
+		}
+		else
+		{
+			// don't want
+			++itr;
+		}
+	}  // for itr - m_Cache[]
+	
+	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
+	{
+		int RealX = (BaseX + x) * m_GridSize;
+		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
+		{
+			int RealZ = (BaseZ + z) * m_GridSize;
+			bool Found = false;
+			for (cMineShaftSystems::const_iterator itr = a_MineShafts.begin(), end = a_MineShafts.end(); itr != end; ++itr)
+			{
+				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
+				{
+					Found = true;
+					break;
+				}
+			}  // for itr - a_Mineshafts
+			if (!Found)
+			{
+				a_MineShafts.push_back(new cMineShaftSystem(RealX, RealZ, m_GridSize, m_MaxSystemSize, m_Noise, m_ProbLevelCorridor, m_ProbLevelCrossing, m_ProbLevelStaircase));
+			}
+		}  // for z
+	}  // for x
+	
+	// Copy a_MineShafts into m_Cache to the beginning:
+	cMineShaftSystems MineShaftsCopy(a_MineShafts);
+	m_Cache.splice(m_Cache.begin(), MineShaftsCopy, MineShaftsCopy.begin(), MineShaftsCopy.end());
+	
+	// Trim the cache if it's too long:
+	if (m_Cache.size() > 100)
+	{
+		cMineShaftSystems::iterator itr = m_Cache.begin();
+		std::advance(itr, 100);
+		for (cMineShaftSystems::iterator end = m_Cache.end(); itr != end; ++itr)
+		{
+			delete *itr;
+		}
+		itr = m_Cache.begin();
+		std::advance(itr, 100);
+		m_Cache.erase(itr, m_Cache.end());
+	}
+}
+
+
+
+
+
+
+void cStructGenMineShafts::GenStructures(cChunkDesc & a_ChunkDesc)
+{
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cMineShaftSystems MineShafts;
+	GetMineShaftSystemsForChunk(ChunkX, ChunkZ, MineShafts);
+	for (cMineShaftSystems::const_iterator itr = MineShafts.begin(); itr != MineShafts.end(); ++itr)
+	{
+		(*itr)->ProcessChunk(a_ChunkDesc);
+	}  // for itr - MineShafts[]
+}
+
+
+
+
diff --git a/source/Generating/MineShafts.h b/source/Generating/MineShafts.h
index a2191b665..c53d3bc53 100644
--- a/source/Generating/MineShafts.h
+++ b/source/Generating/MineShafts.h
@@ -1,61 +1,61 @@
-

-// MineShafts.h

-

-// Declares the cStructGenMineShafts class representing the structure generator for abandoned mineshafts

-

-

-

-

-

-#pragma once

-

-#include "ComposableGenerator.h"

-#include "../Noise.h"

-

-

-

-

-

-class cStructGenMineShafts :

-	public cStructureGen

-{

-public:

-	cStructGenMineShafts(

-		int a_Seed, int a_GridSize, int a_MaxSystemSize,

-		int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase

-	);

-	

-	virtual ~cStructGenMineShafts();

-	

-protected:

-	friend class cMineShaft;

-	friend class cMineShaftDirtRoom;

-	friend class cMineShaftCorridor;

-	friend class cMineShaftCrossing;

-	friend class cMineShaftStaircase;

-	class cMineShaftSystem;  // fwd: MineShafts.cpp

-	typedef std::list<cMineShaftSystem *> cMineShaftSystems;

-	

-	cNoise            m_Noise;

-	int               m_GridSize;            ///< Average spacing of the systems

-	int               m_MaxSystemSize;       ///< Maximum blcok size of a mineshaft system

-	int               m_ProbLevelCorridor;   ///< Probability level of a branch object being the corridor

-	int               m_ProbLevelCrossing;   ///< Probability level of a branch object being the crossing, minus Corridor

-	int               m_ProbLevelStaircase;  ///< Probability level of a branch object being the staircase, minus Crossing

-	cMineShaftSystems m_Cache;               ///< Cache of the most recently used systems. MoveToFront used.

-	

-	/// Clears everything from the cache

-	void ClearCache(void);

-	

-	/** Returns all systems that *may* intersect the given chunk.

-	All the systems are valid until the next call to this function (which may delete some of the pointers).

-	*/

-	void GetMineShaftSystemsForChunk(int a_ChunkX, int a_ChunkZ, cMineShaftSystems & a_MineShaftSystems);

-

-	// cStructureGen overrides:

-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

+
+// MineShafts.h
+
+// Declares the cStructGenMineShafts class representing the structure generator for abandoned mineshafts
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "../Noise.h"
+
+
+
+
+
+class cStructGenMineShafts :
+	public cStructureGen
+{
+public:
+	cStructGenMineShafts(
+		int a_Seed, int a_GridSize, int a_MaxSystemSize,
+		int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
+	);
+	
+	virtual ~cStructGenMineShafts();
+	
+protected:
+	friend class cMineShaft;
+	friend class cMineShaftDirtRoom;
+	friend class cMineShaftCorridor;
+	friend class cMineShaftCrossing;
+	friend class cMineShaftStaircase;
+	class cMineShaftSystem;  // fwd: MineShafts.cpp
+	typedef std::list<cMineShaftSystem *> cMineShaftSystems;
+	
+	cNoise            m_Noise;
+	int               m_GridSize;            ///< Average spacing of the systems
+	int               m_MaxSystemSize;       ///< Maximum blcok size of a mineshaft system
+	int               m_ProbLevelCorridor;   ///< Probability level of a branch object being the corridor
+	int               m_ProbLevelCrossing;   ///< Probability level of a branch object being the crossing, minus Corridor
+	int               m_ProbLevelStaircase;  ///< Probability level of a branch object being the staircase, minus Crossing
+	cMineShaftSystems m_Cache;               ///< Cache of the most recently used systems. MoveToFront used.
+	
+	/// Clears everything from the cache
+	void ClearCache(void);
+	
+	/** Returns all systems that *may* intersect the given chunk.
+	All the systems are valid until the next call to this function (which may delete some of the pointers).
+	*/
+	void GetMineShaftSystemsForChunk(int a_ChunkX, int a_ChunkZ, cMineShaftSystems & a_MineShaftSystems);
+
+	// cStructureGen overrides:
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
diff --git a/source/Generating/Noise3DGenerator.cpp b/source/Generating/Noise3DGenerator.cpp
index dcf84abeb..f47c64430 100644
--- a/source/Generating/Noise3DGenerator.cpp
+++ b/source/Generating/Noise3DGenerator.cpp
@@ -1,581 +1,581 @@
-

-// Nosie3DGenerator.cpp

-

-// Generates terrain using 3D noise, rather than composing. Is a test.

-

-#include "Globals.h"

-#include "Noise3DGenerator.h"

-#include "../OSSupport/File.h"

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

-#include "../LinearInterpolation.h"

-#include "../LinearUpscale.h"

-

-

-

-

-

-/*

-// Perform an automatic test of upscaling upon program start (use breakpoints to debug):

-

-class Test

-{

-public:

-	Test(void)

-	{

-		DoTest1();

-		DoTest2();

-	}

-	

-	

-	void DoTest1(void)

-	{

-		float In[3 * 3 * 3];

-		for (int i = 0; i < ARRAYCOUNT(In); i++)

-		{

-			In[i] = (float)(i % 5);

-		}

-		Debug3DNoise(In, 3, 3, 3, "Upscale3D in");

-		float Out[17 * 33 * 35];

-		LinearUpscale3DArray(In, 3, 3, 3, Out, 8, 16, 17);

-		Debug3DNoise(Out, 17, 33, 35, "Upscale3D test");

-	}

-	

-	

-	void DoTest2(void)

-	{

-		float In[3 * 3];

-		for (int i = 0; i < ARRAYCOUNT(In); i++)

-		{

-			In[i] = (float)(i % 5);

-		}

-		Debug2DNoise(In, 3, 3, "Upscale2D in");

-		float Out[17 * 33];

-		LinearUpscale2DArray(In, 3, 3, Out, 8, 16);

-		Debug2DNoise(Out, 17, 33, "Upscale2D test");

-	}

-	

-} gTest;

-//*/

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cNoise3DGenerator:

-

-cNoise3DGenerator::cNoise3DGenerator(cChunkGenerator & a_ChunkGenerator) :

-	super(a_ChunkGenerator),

-	m_Perlin(1000),

-	m_Cubic(1000)

-{

-	m_Perlin.AddOctave(1, (NOISE_DATATYPE)0.5);

-	m_Perlin.AddOctave((NOISE_DATATYPE)0.5, 1);

-	m_Perlin.AddOctave((NOISE_DATATYPE)0.5, 2);

-	

-	#if 0

-	// DEBUG: Test the noise generation:

-	// NOTE: In order to be able to run MCS with this code, you need to increase the default thread stack size

-	// In MSVC, it is done in Project Settings -> Configuration Properties -> Linker -> System, set Stack reserve size to at least 64M

-	m_SeaLevel            = 62;

-	m_HeightAmplification = 0;

-	m_MidPoint            = 75;

-	m_FrequencyX          = 4;

-	m_FrequencyY          = 4;

-	m_FrequencyZ          = 4;

-	m_AirThreshold        = 0.5;

-	

-	const int NumChunks = 4;

-	NOISE_DATATYPE Noise[NumChunks][cChunkDef::Width * cChunkDef::Width * cChunkDef::Height];

-	for (int x = 0; x < NumChunks; x++)

-	{

-		GenerateNoiseArray(x, 5, Noise[x]);

-	}

-

-	// Save in XY cuts:

-	cFile f1;

-	if (f1.Open("Test_XY.grab", cFile::fmWrite))

-	{

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

-		{

-			for (int y = 0; y < cChunkDef::Height; y++)

-			{

-				for (int i = 0; i < NumChunks; i++)

-				{

-					int idx = y * cChunkDef::Width + z * cChunkDef::Width * cChunkDef::Height;

-					unsigned char buf[cChunkDef::Width];

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

-					{

-						buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 32 * Noise[i][idx++]))));

-					}

-					f1.Write(buf, cChunkDef::Width);

-				}

-			}  // for y

-		}  // for z

-	}  // if (XY file open)

-

-	cFile f2;

-	if (f2.Open("Test_XZ.grab", cFile::fmWrite))

-	{

-		for (int y = 0; y < cChunkDef::Height; y++)

-		{

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

-			{

-				for (int i = 0; i < NumChunks; i++)

-				{

-					int idx = y * cChunkDef::Width + z * cChunkDef::Width * cChunkDef::Height;

-					unsigned char buf[cChunkDef::Width];

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

-					{

-						buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 32 * Noise[i][idx++]))));

-					}

-					f2.Write(buf, cChunkDef::Width);

-				}

-			}  // for z

-		}  // for y

-	}  // if (XZ file open)

-	#endif  // 0

-}

-

-

-

-

-

-cNoise3DGenerator::~cNoise3DGenerator()

-{

-	// Nothing needed yet

-}

-

-

-

-

-

-void cNoise3DGenerator::Initialize(cWorld * a_World, cIniFile & a_IniFile)

-{

-	m_World = a_World;

-	

-	// Params:

-	m_SeaLevel            =                 a_IniFile.GetValueSetI("Generator", "Noise3DSeaLevel", 62);

-	m_HeightAmplification = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DHeightAmplification", 0);

-	m_MidPoint            = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DMidPoint", 75);

-	m_FrequencyX          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyX", 8);

-	m_FrequencyY          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyY", 8);

-	m_FrequencyZ          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyZ", 8);

-	m_AirThreshold        = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DAirThreshold", 0.5);

-}

-

-

-

-

-

-void cNoise3DGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)

-{

-	for (int i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)

-	{

-		a_BiomeMap[i] = biExtremeHills;

-	}

-}

-

-

-

-

-

-void cNoise3DGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc)

-{

-	NOISE_DATATYPE Noise[17 * 257 * 17];

-	GenerateNoiseArray(a_ChunkX, a_ChunkZ, Noise);

-	

-	// Output noise into chunk:

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

-	{

-		for (int y = 0; y < cChunkDef::Height; y++)

-		{

-			int idx = z * 17 * 257 + y * 17;

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

-			{

-				NOISE_DATATYPE n = Noise[idx++];

-				BLOCKTYPE BlockType;

-				if (n > m_AirThreshold)

-				{

-					BlockType = (y > m_SeaLevel) ? E_BLOCK_AIR : E_BLOCK_STATIONARY_WATER;

-				}

-				else

-				{

-					BlockType = E_BLOCK_STONE;

-				}

-				a_ChunkDesc.SetBlockType(x, y, z, BlockType);

-			}

-		}

-	}

-	

-	UpdateHeightmap(a_ChunkDesc);

-	ComposeTerrain (a_ChunkDesc);

-}

-

-

-

-

-

-void cNoise3DGenerator::GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DATATYPE * a_OutNoise)

-{

-	NOISE_DATATYPE NoiseO[DIM_X * DIM_Y * DIM_Z];  // Output for the Perlin noise

-	NOISE_DATATYPE NoiseW[DIM_X * DIM_Y * DIM_Z];  // Workspace that the noise calculation can use and trash

-

-	// Our noise array has different layout, XZY, instead of regular chunk's XYZ, that's why the coords are "renamed"

-	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(a_ChunkX       * cChunkDef::Width))     / m_FrequencyX;

-	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((a_ChunkX + 1) * cChunkDef::Width) - 1) / m_FrequencyX;

-	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(a_ChunkZ       * cChunkDef::Width))     / m_FrequencyZ;

-	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((a_ChunkZ + 1) * cChunkDef::Width) - 1) / m_FrequencyZ;

-	NOISE_DATATYPE StartY = 0;

-	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)256) / m_FrequencyY;

-	

-	m_Perlin.Generate3D(NoiseO, DIM_X, DIM_Y, DIM_Z, StartX, EndX, StartY, EndY, StartZ, EndZ, NoiseW);

-	

-	// DEBUG: Debug3DNoise(NoiseO, DIM_X, DIM_Y, DIM_Z, Printf("Chunk_%d_%d_orig", a_ChunkX, a_ChunkZ));

-	

-	// Precalculate a "height" array:

-	NOISE_DATATYPE Height[DIM_X * DIM_Z];  // Output for the cubic noise heightmap ("source")

-	m_Cubic.Generate2D(Height, DIM_X, DIM_Z, StartX / 25, EndX / 25, StartZ / 25, EndZ / 25);

-	for (int i = 0; i < ARRAYCOUNT(Height); i++)

-	{

-		Height[i] = abs(Height[i]) * m_HeightAmplification + 1;

-	}

-	

-	// Modify the noise by height data:

-	for (int y = 0; y < DIM_Y; y++)

-	{

-		NOISE_DATATYPE AddHeight = (y * UPSCALE_Y - m_MidPoint) / 20;

-		AddHeight *= AddHeight * AddHeight;

-		for (int z = 0; z < DIM_Z; z++)

-		{

-			NOISE_DATATYPE * CurRow = &(NoiseO[y * DIM_X + z * DIM_X * DIM_Y]);

-			for (int x = 0; x < DIM_X; x++)

-			{

-				CurRow[x] += AddHeight / Height[x + DIM_X * z];

-			}

-		}

-	}

-

-	// DEBUG: Debug3DNoise(NoiseO, DIM_X, DIM_Y, DIM_Z, Printf("Chunk_%d_%d_hei", a_ChunkX, a_ChunkZ));

-	

-	// Upscale the Perlin noise into full-blown chunk dimensions:

-	LinearUpscale3DArray(

-		NoiseO, DIM_X, DIM_Y, DIM_Z,

-		a_OutNoise, UPSCALE_X, UPSCALE_Y, UPSCALE_Z

-	);

-	

-	// DEBUG: Debug3DNoise(a_OutNoise, 17, 257, 17, Printf("Chunk_%d_%d_lerp", a_ChunkX, a_ChunkZ));

-}

-

-

-

-

-

-void cNoise3DGenerator::UpdateHeightmap(cChunkDesc & a_ChunkDesc)

-{

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

-	{

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

-		{

-			for (int y = cChunkDef::Height - 1; y > 0; y--)

-			{

-				if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_AIR)

-				{

-					a_ChunkDesc.SetHeight(x, z, y);

-					break;

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-void cNoise3DGenerator::ComposeTerrain(cChunkDesc & a_ChunkDesc)

-{

-	// Make basic terrain composition:

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

-	{

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

-		{

-			int LastAir = a_ChunkDesc.GetHeight(x, z) + 1;

-			bool HasHadWater = false;

-			for (int y = LastAir - 1; y > 0; y--)

-			{

-				switch (a_ChunkDesc.GetBlockType(x, y, z))

-				{

-					case E_BLOCK_AIR:

-					{

-						LastAir = y;

-						break;

-					}

-					case E_BLOCK_STONE:

-					{

-						if (LastAir - y > 3)

-						{

-							break;

-						}

-						if (HasHadWater)

-						{

-							a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SAND);

-						}

-						else

-						{

-							a_ChunkDesc.SetBlockType(x, y, z, (LastAir == y + 1) ? E_BLOCK_GRASS : E_BLOCK_DIRT);

-						}

-						break;

-					}

-					case E_BLOCK_STATIONARY_WATER:

-					{

-						LastAir = y;

-						HasHadWater = true;

-						break;

-					}

-				}  // switch (GetBlockType())

-			}  // for y

-			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cNoise3DComposable:

-

-cNoise3DComposable::cNoise3DComposable(int a_Seed) :

-	m_Noise1(a_Seed + 1000),

-	m_Noise2(a_Seed + 2000),

-	m_Noise3(a_Seed + 3000)

-{

-}

-

-

-

-

-

-void cNoise3DComposable::Initialize(cIniFile & a_IniFile)

-{

-	// Params:

-	m_SeaLevel            =                 a_IniFile.GetValueSetI("Generator", "Noise3DSeaLevel", 62);

-	m_HeightAmplification = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DHeightAmplification", 0);

-	m_MidPoint            = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DMidPoint", 75);

-	m_FrequencyX          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyX", 10);

-	m_FrequencyY          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyY", 10);

-	m_FrequencyZ          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyZ", 10);

-	m_AirThreshold        = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DAirThreshold", 0.5);

-}

-

-

-

-

-

-void cNoise3DComposable::GenerateNoiseArrayIfNeeded(int a_ChunkX, int a_ChunkZ)

-{

-	if ((a_ChunkX == m_LastChunkX) && (a_ChunkZ == m_LastChunkZ))

-	{

-		// The noise for this chunk is already generated in m_Noise

-		return;

-	}

-	m_LastChunkX = a_ChunkX;

-	m_LastChunkZ = a_ChunkZ;

-	

-	// Upscaling parameters:

-	const int UPSCALE_X = 8;

-	const int UPSCALE_Y = 4;

-	const int UPSCALE_Z = 8;

-	

-	const int DIM_X = 1 + cChunkDef::Width  / UPSCALE_X;

-	const int DIM_Y = 1 + cChunkDef::Height / UPSCALE_Y;

-	const int DIM_Z = 1 + cChunkDef::Width  / UPSCALE_Z;

-

-	// Precalculate a "height" array:

-	NOISE_DATATYPE Height[17 * 17];  // x + 17 * z

-	for (int z = 0; z < 17; z += UPSCALE_Z)

-	{

-		NOISE_DATATYPE NoiseZ = ((NOISE_DATATYPE)(a_ChunkZ * cChunkDef::Width + z)) / m_FrequencyZ;

-		for (int x = 0; x < 17; x += UPSCALE_X)

-		{

-			NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(a_ChunkX * cChunkDef::Width + x)) / m_FrequencyX;

-			NOISE_DATATYPE val = abs(m_Noise1.CubicNoise2D(NoiseX / 5, NoiseZ / 5)) * m_HeightAmplification + 1;

-			Height[x + 17 * z] = val * val * val;

-		}

-	}

-		

-	int idx = 0;

-	for (int y = 0; y < 257; y += UPSCALE_Y)

-	{

-		NOISE_DATATYPE NoiseY = ((NOISE_DATATYPE)y) / m_FrequencyY;

-		NOISE_DATATYPE AddHeight = (y - m_MidPoint) / 20;

-		AddHeight *= AddHeight * AddHeight;

-		NOISE_DATATYPE * CurFloor = &(m_NoiseArray[y * 17 * 17]);

-		for (int z = 0; z < 17; z += UPSCALE_Z)

-		{

-			NOISE_DATATYPE NoiseZ = ((NOISE_DATATYPE)(a_ChunkZ * cChunkDef::Width + z)) / m_FrequencyZ;

-			for (int x = 0; x < 17; x += UPSCALE_X)

-			{

-				NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(a_ChunkX * cChunkDef::Width + x)) / m_FrequencyX;

-				CurFloor[x + 17 * z] = 

-					m_Noise1.CubicNoise3D(NoiseX, NoiseY, NoiseZ) * (NOISE_DATATYPE)0.5 +

-					m_Noise2.CubicNoise3D(NoiseX / 2, NoiseY / 2, NoiseZ / 2) +

-					m_Noise3.CubicNoise3D(NoiseX / 4, NoiseY / 4, NoiseZ / 4) * 2 +

-					AddHeight / Height[x + 17 * z];

-			}

-		}

-		// Linear-interpolate this XZ floor:

-		LinearUpscale2DArrayInPlace(CurFloor, 17, 17, UPSCALE_X, UPSCALE_Z);

-	}

-	

-	// Finish the 3D linear interpolation by interpolating between each XZ-floors on the Y axis

-	for (int y = 1; y < cChunkDef::Height; y++)

-	{

-		if ((y % UPSCALE_Y) == 0)

-		{

-			// This is the interpolation source floor, already calculated

-			continue;

-		}

-		int LoFloorY = (y / UPSCALE_Y) * UPSCALE_Y;

-		int HiFloorY = LoFloorY + UPSCALE_Y;

-		NOISE_DATATYPE * LoFloor  = &(m_NoiseArray[LoFloorY * 17 * 17]);

-		NOISE_DATATYPE * HiFloor  = &(m_NoiseArray[HiFloorY * 17 * 17]);

-		NOISE_DATATYPE * CurFloor = &(m_NoiseArray[y * 17 * 17]);

-		NOISE_DATATYPE Ratio = ((NOISE_DATATYPE)(y % UPSCALE_Y)) / UPSCALE_Y;

-		int idx = 0;

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

-		{

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

-			{

-				CurFloor[idx] = LoFloor[idx] + (HiFloor[idx] - LoFloor[idx]) * Ratio;

-				idx += 1;

-			}

-			idx += 1;  // Skipping one X column

-		}

-	}

-	

-	// The noise array is now fully interpolated

-	/*

-	// DEBUG: Output two images of the array, sliced by XY and XZ:

-	cFile f1;

-	if (f1.Open(Printf("Chunk_%d_%d_XY.raw", a_ChunkX, a_ChunkZ), cFile::fmWrite))

-	{

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

-		{

-			for (int y = 0; y < cChunkDef::Height; y++)

-			{

-				int idx = y * 17 * 17 + z * 17;

-				unsigned char buf[16];

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

-				{

-					buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 128 * m_Noise[idx++]))));

-				}

-				f1.Write(buf, 16);

-			}  // for y

-		}  // for z

-	}  // if (XY file open)

-

-	cFile f2;

-	if (f2.Open(Printf("Chunk_%d_%d_XZ.raw", a_ChunkX, a_ChunkZ), cFile::fmWrite))

-	{

-		for (int y = 0; y < cChunkDef::Height; y++)

-		{

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

-			{

-				int idx = y * 17 * 17 + z * 17;

-				unsigned char buf[16];

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

-				{

-					buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 128 * m_Noise[idx++]))));

-				}

-				f2.Write(buf, 16);

-			}  // for z

-		}  // for y

-	}  // if (XZ file open)

-	*/

-}

-

-

-

-

-

-void cNoise3DComposable::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)

-{

-	GenerateNoiseArrayIfNeeded(a_ChunkX, a_ChunkZ);

-	

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

-	{

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

-		{

-			cChunkDef::SetHeight(a_HeightMap, x, z, m_SeaLevel);

-			for (int y = cChunkDef::Height - 1; y > m_SeaLevel; y--)

-			{

-				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= m_AirThreshold)

-				{

-					cChunkDef::SetHeight(a_HeightMap, x, z, y);

-					break;

-				}

-			}  // for y

-		}  // for x

-	}  // for z

-}

-

-

-

-

-

-void cNoise3DComposable::ComposeTerrain(cChunkDesc & a_ChunkDesc)

-{

-	GenerateNoiseArrayIfNeeded(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());

-	

-	a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);

-	

-	// Make basic terrain composition:

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

-	{

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

-		{

-			int LastAir = a_ChunkDesc.GetHeight(x, z) + 1;

-			bool HasHadWater = false;

-			for (int y = LastAir; y < m_SeaLevel; y++)

-			{

-				a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STATIONARY_WATER);

-			}

-			for (int y = LastAir - 1; y > 0; y--)

-			{

-				if (m_NoiseArray[x + 17 * z + 17 * 17 * y] > m_AirThreshold)

-				{

-					// "air" part

-					LastAir = y;

-					if (y < m_SeaLevel)

-					{

-						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STATIONARY_WATER);

-						HasHadWater = true;

-					}

-					continue;

-				}

-				// "ground" part:

-				if (LastAir - y > 4)

-				{

-					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STONE);

-					continue;

-				}

-				if (HasHadWater)

-				{

-					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SAND);

-				}

-				else

-				{

-					a_ChunkDesc.SetBlockType(x, y, z, (LastAir == y + 1) ? E_BLOCK_GRASS : E_BLOCK_DIRT);

-				}

-			}  // for y

-			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);

-		}  // for x

-	}  // for z

-}

-

-

-

-

+
+// Nosie3DGenerator.cpp
+
+// Generates terrain using 3D noise, rather than composing. Is a test.
+
+#include "Globals.h"
+#include "Noise3DGenerator.h"
+#include "../OSSupport/File.h"
+#include "../../iniFile/iniFile.h"
+#include "../LinearInterpolation.h"
+#include "../LinearUpscale.h"
+
+
+
+
+
+/*
+// Perform an automatic test of upscaling upon program start (use breakpoints to debug):
+
+class Test
+{
+public:
+	Test(void)
+	{
+		DoTest1();
+		DoTest2();
+	}
+	
+	
+	void DoTest1(void)
+	{
+		float In[3 * 3 * 3];
+		for (int i = 0; i < ARRAYCOUNT(In); i++)
+		{
+			In[i] = (float)(i % 5);
+		}
+		Debug3DNoise(In, 3, 3, 3, "Upscale3D in");
+		float Out[17 * 33 * 35];
+		LinearUpscale3DArray(In, 3, 3, 3, Out, 8, 16, 17);
+		Debug3DNoise(Out, 17, 33, 35, "Upscale3D test");
+	}
+	
+	
+	void DoTest2(void)
+	{
+		float In[3 * 3];
+		for (int i = 0; i < ARRAYCOUNT(In); i++)
+		{
+			In[i] = (float)(i % 5);
+		}
+		Debug2DNoise(In, 3, 3, "Upscale2D in");
+		float Out[17 * 33];
+		LinearUpscale2DArray(In, 3, 3, Out, 8, 16);
+		Debug2DNoise(Out, 17, 33, "Upscale2D test");
+	}
+	
+} gTest;
+//*/
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cNoise3DGenerator:
+
+cNoise3DGenerator::cNoise3DGenerator(cChunkGenerator & a_ChunkGenerator) :
+	super(a_ChunkGenerator),
+	m_Perlin(1000),
+	m_Cubic(1000)
+{
+	m_Perlin.AddOctave(1, (NOISE_DATATYPE)0.5);
+	m_Perlin.AddOctave((NOISE_DATATYPE)0.5, 1);
+	m_Perlin.AddOctave((NOISE_DATATYPE)0.5, 2);
+	
+	#if 0
+	// DEBUG: Test the noise generation:
+	// NOTE: In order to be able to run MCS with this code, you need to increase the default thread stack size
+	// In MSVC, it is done in Project Settings -> Configuration Properties -> Linker -> System, set Stack reserve size to at least 64M
+	m_SeaLevel            = 62;
+	m_HeightAmplification = 0;
+	m_MidPoint            = 75;
+	m_FrequencyX          = 4;
+	m_FrequencyY          = 4;
+	m_FrequencyZ          = 4;
+	m_AirThreshold        = 0.5;
+	
+	const int NumChunks = 4;
+	NOISE_DATATYPE Noise[NumChunks][cChunkDef::Width * cChunkDef::Width * cChunkDef::Height];
+	for (int x = 0; x < NumChunks; x++)
+	{
+		GenerateNoiseArray(x, 5, Noise[x]);
+	}
+
+	// Save in XY cuts:
+	cFile f1;
+	if (f1.Open("Test_XY.grab", cFile::fmWrite))
+	{
+		for (int z = 0; z < cChunkDef::Width; z++)
+		{
+			for (int y = 0; y < cChunkDef::Height; y++)
+			{
+				for (int i = 0; i < NumChunks; i++)
+				{
+					int idx = y * cChunkDef::Width + z * cChunkDef::Width * cChunkDef::Height;
+					unsigned char buf[cChunkDef::Width];
+					for (int x = 0; x < cChunkDef::Width; x++)
+					{
+						buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 32 * Noise[i][idx++]))));
+					}
+					f1.Write(buf, cChunkDef::Width);
+				}
+			}  // for y
+		}  // for z
+	}  // if (XY file open)
+
+	cFile f2;
+	if (f2.Open("Test_XZ.grab", cFile::fmWrite))
+	{
+		for (int y = 0; y < cChunkDef::Height; y++)
+		{
+			for (int z = 0; z < cChunkDef::Width; z++)
+			{
+				for (int i = 0; i < NumChunks; i++)
+				{
+					int idx = y * cChunkDef::Width + z * cChunkDef::Width * cChunkDef::Height;
+					unsigned char buf[cChunkDef::Width];
+					for (int x = 0; x < cChunkDef::Width; x++)
+					{
+						buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 32 * Noise[i][idx++]))));
+					}
+					f2.Write(buf, cChunkDef::Width);
+				}
+			}  // for z
+		}  // for y
+	}  // if (XZ file open)
+	#endif  // 0
+}
+
+
+
+
+
+cNoise3DGenerator::~cNoise3DGenerator()
+{
+	// Nothing needed yet
+}
+
+
+
+
+
+void cNoise3DGenerator::Initialize(cWorld * a_World, cIniFile & a_IniFile)
+{
+	m_World = a_World;
+	
+	// Params:
+	m_SeaLevel            =                 a_IniFile.GetValueSetI("Generator", "Noise3DSeaLevel", 62);
+	m_HeightAmplification = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DHeightAmplification", 0);
+	m_MidPoint            = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DMidPoint", 75);
+	m_FrequencyX          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyX", 8);
+	m_FrequencyY          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyY", 8);
+	m_FrequencyZ          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyZ", 8);
+	m_AirThreshold        = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DAirThreshold", 0.5);
+}
+
+
+
+
+
+void cNoise3DGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)
+{
+	for (int i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)
+	{
+		a_BiomeMap[i] = biExtremeHills;
+	}
+}
+
+
+
+
+
+void cNoise3DGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc)
+{
+	NOISE_DATATYPE Noise[17 * 257 * 17];
+	GenerateNoiseArray(a_ChunkX, a_ChunkZ, Noise);
+	
+	// Output noise into chunk:
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int y = 0; y < cChunkDef::Height; y++)
+		{
+			int idx = z * 17 * 257 + y * 17;
+			for (int x = 0; x < cChunkDef::Width; x++)
+			{
+				NOISE_DATATYPE n = Noise[idx++];
+				BLOCKTYPE BlockType;
+				if (n > m_AirThreshold)
+				{
+					BlockType = (y > m_SeaLevel) ? E_BLOCK_AIR : E_BLOCK_STATIONARY_WATER;
+				}
+				else
+				{
+					BlockType = E_BLOCK_STONE;
+				}
+				a_ChunkDesc.SetBlockType(x, y, z, BlockType);
+			}
+		}
+	}
+	
+	UpdateHeightmap(a_ChunkDesc);
+	ComposeTerrain (a_ChunkDesc);
+}
+
+
+
+
+
+void cNoise3DGenerator::GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DATATYPE * a_OutNoise)
+{
+	NOISE_DATATYPE NoiseO[DIM_X * DIM_Y * DIM_Z];  // Output for the Perlin noise
+	NOISE_DATATYPE NoiseW[DIM_X * DIM_Y * DIM_Z];  // Workspace that the noise calculation can use and trash
+
+	// Our noise array has different layout, XZY, instead of regular chunk's XYZ, that's why the coords are "renamed"
+	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(a_ChunkX       * cChunkDef::Width))     / m_FrequencyX;
+	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((a_ChunkX + 1) * cChunkDef::Width) - 1) / m_FrequencyX;
+	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(a_ChunkZ       * cChunkDef::Width))     / m_FrequencyZ;
+	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((a_ChunkZ + 1) * cChunkDef::Width) - 1) / m_FrequencyZ;
+	NOISE_DATATYPE StartY = 0;
+	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)256) / m_FrequencyY;
+	
+	m_Perlin.Generate3D(NoiseO, DIM_X, DIM_Y, DIM_Z, StartX, EndX, StartY, EndY, StartZ, EndZ, NoiseW);
+	
+	// DEBUG: Debug3DNoise(NoiseO, DIM_X, DIM_Y, DIM_Z, Printf("Chunk_%d_%d_orig", a_ChunkX, a_ChunkZ));
+	
+	// Precalculate a "height" array:
+	NOISE_DATATYPE Height[DIM_X * DIM_Z];  // Output for the cubic noise heightmap ("source")
+	m_Cubic.Generate2D(Height, DIM_X, DIM_Z, StartX / 25, EndX / 25, StartZ / 25, EndZ / 25);
+	for (int i = 0; i < ARRAYCOUNT(Height); i++)
+	{
+		Height[i] = abs(Height[i]) * m_HeightAmplification + 1;
+	}
+	
+	// Modify the noise by height data:
+	for (int y = 0; y < DIM_Y; y++)
+	{
+		NOISE_DATATYPE AddHeight = (y * UPSCALE_Y - m_MidPoint) / 20;
+		AddHeight *= AddHeight * AddHeight;
+		for (int z = 0; z < DIM_Z; z++)
+		{
+			NOISE_DATATYPE * CurRow = &(NoiseO[y * DIM_X + z * DIM_X * DIM_Y]);
+			for (int x = 0; x < DIM_X; x++)
+			{
+				CurRow[x] += AddHeight / Height[x + DIM_X * z];
+			}
+		}
+	}
+
+	// DEBUG: Debug3DNoise(NoiseO, DIM_X, DIM_Y, DIM_Z, Printf("Chunk_%d_%d_hei", a_ChunkX, a_ChunkZ));
+	
+	// Upscale the Perlin noise into full-blown chunk dimensions:
+	LinearUpscale3DArray(
+		NoiseO, DIM_X, DIM_Y, DIM_Z,
+		a_OutNoise, UPSCALE_X, UPSCALE_Y, UPSCALE_Z
+	);
+	
+	// DEBUG: Debug3DNoise(a_OutNoise, 17, 257, 17, Printf("Chunk_%d_%d_lerp", a_ChunkX, a_ChunkZ));
+}
+
+
+
+
+
+void cNoise3DGenerator::UpdateHeightmap(cChunkDesc & a_ChunkDesc)
+{
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			for (int y = cChunkDef::Height - 1; y > 0; y--)
+			{
+				if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_AIR)
+				{
+					a_ChunkDesc.SetHeight(x, z, y);
+					break;
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+void cNoise3DGenerator::ComposeTerrain(cChunkDesc & a_ChunkDesc)
+{
+	// Make basic terrain composition:
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			int LastAir = a_ChunkDesc.GetHeight(x, z) + 1;
+			bool HasHadWater = false;
+			for (int y = LastAir - 1; y > 0; y--)
+			{
+				switch (a_ChunkDesc.GetBlockType(x, y, z))
+				{
+					case E_BLOCK_AIR:
+					{
+						LastAir = y;
+						break;
+					}
+					case E_BLOCK_STONE:
+					{
+						if (LastAir - y > 3)
+						{
+							break;
+						}
+						if (HasHadWater)
+						{
+							a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SAND);
+						}
+						else
+						{
+							a_ChunkDesc.SetBlockType(x, y, z, (LastAir == y + 1) ? E_BLOCK_GRASS : E_BLOCK_DIRT);
+						}
+						break;
+					}
+					case E_BLOCK_STATIONARY_WATER:
+					{
+						LastAir = y;
+						HasHadWater = true;
+						break;
+					}
+				}  // switch (GetBlockType())
+			}  // for y
+			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cNoise3DComposable:
+
+cNoise3DComposable::cNoise3DComposable(int a_Seed) :
+	m_Noise1(a_Seed + 1000),
+	m_Noise2(a_Seed + 2000),
+	m_Noise3(a_Seed + 3000)
+{
+}
+
+
+
+
+
+void cNoise3DComposable::Initialize(cIniFile & a_IniFile)
+{
+	// Params:
+	m_SeaLevel            =                 a_IniFile.GetValueSetI("Generator", "Noise3DSeaLevel", 62);
+	m_HeightAmplification = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DHeightAmplification", 0);
+	m_MidPoint            = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DMidPoint", 75);
+	m_FrequencyX          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyX", 10);
+	m_FrequencyY          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyY", 10);
+	m_FrequencyZ          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyZ", 10);
+	m_AirThreshold        = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DAirThreshold", 0.5);
+}
+
+
+
+
+
+void cNoise3DComposable::GenerateNoiseArrayIfNeeded(int a_ChunkX, int a_ChunkZ)
+{
+	if ((a_ChunkX == m_LastChunkX) && (a_ChunkZ == m_LastChunkZ))
+	{
+		// The noise for this chunk is already generated in m_Noise
+		return;
+	}
+	m_LastChunkX = a_ChunkX;
+	m_LastChunkZ = a_ChunkZ;
+	
+	// Upscaling parameters:
+	const int UPSCALE_X = 8;
+	const int UPSCALE_Y = 4;
+	const int UPSCALE_Z = 8;
+	
+	const int DIM_X = 1 + cChunkDef::Width  / UPSCALE_X;
+	const int DIM_Y = 1 + cChunkDef::Height / UPSCALE_Y;
+	const int DIM_Z = 1 + cChunkDef::Width  / UPSCALE_Z;
+
+	// Precalculate a "height" array:
+	NOISE_DATATYPE Height[17 * 17];  // x + 17 * z
+	for (int z = 0; z < 17; z += UPSCALE_Z)
+	{
+		NOISE_DATATYPE NoiseZ = ((NOISE_DATATYPE)(a_ChunkZ * cChunkDef::Width + z)) / m_FrequencyZ;
+		for (int x = 0; x < 17; x += UPSCALE_X)
+		{
+			NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(a_ChunkX * cChunkDef::Width + x)) / m_FrequencyX;
+			NOISE_DATATYPE val = abs(m_Noise1.CubicNoise2D(NoiseX / 5, NoiseZ / 5)) * m_HeightAmplification + 1;
+			Height[x + 17 * z] = val * val * val;
+		}
+	}
+		
+	int idx = 0;
+	for (int y = 0; y < 257; y += UPSCALE_Y)
+	{
+		NOISE_DATATYPE NoiseY = ((NOISE_DATATYPE)y) / m_FrequencyY;
+		NOISE_DATATYPE AddHeight = (y - m_MidPoint) / 20;
+		AddHeight *= AddHeight * AddHeight;
+		NOISE_DATATYPE * CurFloor = &(m_NoiseArray[y * 17 * 17]);
+		for (int z = 0; z < 17; z += UPSCALE_Z)
+		{
+			NOISE_DATATYPE NoiseZ = ((NOISE_DATATYPE)(a_ChunkZ * cChunkDef::Width + z)) / m_FrequencyZ;
+			for (int x = 0; x < 17; x += UPSCALE_X)
+			{
+				NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(a_ChunkX * cChunkDef::Width + x)) / m_FrequencyX;
+				CurFloor[x + 17 * z] = 
+					m_Noise1.CubicNoise3D(NoiseX, NoiseY, NoiseZ) * (NOISE_DATATYPE)0.5 +
+					m_Noise2.CubicNoise3D(NoiseX / 2, NoiseY / 2, NoiseZ / 2) +
+					m_Noise3.CubicNoise3D(NoiseX / 4, NoiseY / 4, NoiseZ / 4) * 2 +
+					AddHeight / Height[x + 17 * z];
+			}
+		}
+		// Linear-interpolate this XZ floor:
+		LinearUpscale2DArrayInPlace(CurFloor, 17, 17, UPSCALE_X, UPSCALE_Z);
+	}
+	
+	// Finish the 3D linear interpolation by interpolating between each XZ-floors on the Y axis
+	for (int y = 1; y < cChunkDef::Height; y++)
+	{
+		if ((y % UPSCALE_Y) == 0)
+		{
+			// This is the interpolation source floor, already calculated
+			continue;
+		}
+		int LoFloorY = (y / UPSCALE_Y) * UPSCALE_Y;
+		int HiFloorY = LoFloorY + UPSCALE_Y;
+		NOISE_DATATYPE * LoFloor  = &(m_NoiseArray[LoFloorY * 17 * 17]);
+		NOISE_DATATYPE * HiFloor  = &(m_NoiseArray[HiFloorY * 17 * 17]);
+		NOISE_DATATYPE * CurFloor = &(m_NoiseArray[y * 17 * 17]);
+		NOISE_DATATYPE Ratio = ((NOISE_DATATYPE)(y % UPSCALE_Y)) / UPSCALE_Y;
+		int idx = 0;
+		for (int z = 0; z < cChunkDef::Width; z++)
+		{
+			for (int x = 0; x < cChunkDef::Width; x++)
+			{
+				CurFloor[idx] = LoFloor[idx] + (HiFloor[idx] - LoFloor[idx]) * Ratio;
+				idx += 1;
+			}
+			idx += 1;  // Skipping one X column
+		}
+	}
+	
+	// The noise array is now fully interpolated
+	/*
+	// DEBUG: Output two images of the array, sliced by XY and XZ:
+	cFile f1;
+	if (f1.Open(Printf("Chunk_%d_%d_XY.raw", a_ChunkX, a_ChunkZ), cFile::fmWrite))
+	{
+		for (int z = 0; z < cChunkDef::Width; z++)
+		{
+			for (int y = 0; y < cChunkDef::Height; y++)
+			{
+				int idx = y * 17 * 17 + z * 17;
+				unsigned char buf[16];
+				for (int x = 0; x < cChunkDef::Width; x++)
+				{
+					buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 128 * m_Noise[idx++]))));
+				}
+				f1.Write(buf, 16);
+			}  // for y
+		}  // for z
+	}  // if (XY file open)
+
+	cFile f2;
+	if (f2.Open(Printf("Chunk_%d_%d_XZ.raw", a_ChunkX, a_ChunkZ), cFile::fmWrite))
+	{
+		for (int y = 0; y < cChunkDef::Height; y++)
+		{
+			for (int z = 0; z < cChunkDef::Width; z++)
+			{
+				int idx = y * 17 * 17 + z * 17;
+				unsigned char buf[16];
+				for (int x = 0; x < cChunkDef::Width; x++)
+				{
+					buf[x] = (unsigned char)(std::min(256, std::max(0, (int)(128 + 128 * m_Noise[idx++]))));
+				}
+				f2.Write(buf, 16);
+			}  // for z
+		}  // for y
+	}  // if (XZ file open)
+	*/
+}
+
+
+
+
+
+void cNoise3DComposable::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap)
+{
+	GenerateNoiseArrayIfNeeded(a_ChunkX, a_ChunkZ);
+	
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			cChunkDef::SetHeight(a_HeightMap, x, z, m_SeaLevel);
+			for (int y = cChunkDef::Height - 1; y > m_SeaLevel; y--)
+			{
+				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= m_AirThreshold)
+				{
+					cChunkDef::SetHeight(a_HeightMap, x, z, y);
+					break;
+				}
+			}  // for y
+		}  // for x
+	}  // for z
+}
+
+
+
+
+
+void cNoise3DComposable::ComposeTerrain(cChunkDesc & a_ChunkDesc)
+{
+	GenerateNoiseArrayIfNeeded(a_ChunkDesc.GetChunkX(), a_ChunkDesc.GetChunkZ());
+	
+	a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);
+	
+	// Make basic terrain composition:
+	for (int z = 0; z < cChunkDef::Width; z++)
+	{
+		for (int x = 0; x < cChunkDef::Width; x++)
+		{
+			int LastAir = a_ChunkDesc.GetHeight(x, z) + 1;
+			bool HasHadWater = false;
+			for (int y = LastAir; y < m_SeaLevel; y++)
+			{
+				a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STATIONARY_WATER);
+			}
+			for (int y = LastAir - 1; y > 0; y--)
+			{
+				if (m_NoiseArray[x + 17 * z + 17 * 17 * y] > m_AirThreshold)
+				{
+					// "air" part
+					LastAir = y;
+					if (y < m_SeaLevel)
+					{
+						a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STATIONARY_WATER);
+						HasHadWater = true;
+					}
+					continue;
+				}
+				// "ground" part:
+				if (LastAir - y > 4)
+				{
+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_STONE);
+					continue;
+				}
+				if (HasHadWater)
+				{
+					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SAND);
+				}
+				else
+				{
+					a_ChunkDesc.SetBlockType(x, y, z, (LastAir == y + 1) ? E_BLOCK_GRASS : E_BLOCK_DIRT);
+				}
+			}  // for y
+			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);
+		}  // for x
+	}  // for z
+}
+
+
+
+
diff --git a/source/Generating/Noise3DGenerator.h b/source/Generating/Noise3DGenerator.h
index b23e8645b..0d211cddc 100644
--- a/source/Generating/Noise3DGenerator.h
+++ b/source/Generating/Noise3DGenerator.h
@@ -1,106 +1,106 @@
-

-// Noise3DGenerator.h

-

-// Generates terrain using 3D noise, rather than composing. Is a test.

-

-

-

-

-#pragma once

-

-#include "ComposableGenerator.h"

-#include "../Noise.h"

-

-

-

-

-

-class cNoise3DGenerator :

-	public cChunkGenerator::cGenerator

-{

-	typedef cChunkGenerator::cGenerator super;

-	

-public:

-	cNoise3DGenerator(cChunkGenerator & a_ChunkGenerator);

-	virtual ~cNoise3DGenerator();

-	

-	virtual void Initialize(cWorld * a_World, cIniFile & a_IniFile) override;

-	virtual void GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) override;

-	virtual void DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc) override;

-	

-protected:

-	// Linear interpolation step sizes, must be divisors of cChunkDef::Width and cChunkDef::Height, respectively:

-	static const int UPSCALE_X = 8;

-	static const int UPSCALE_Y = 4;

-	static const int UPSCALE_Z = 8;

-	

-	// Linear interpolation buffer dimensions, calculated from the step sizes:

-	static const int DIM_X = 1 + cChunkDef::Width  / UPSCALE_X;

-	static const int DIM_Y = 1 + cChunkDef::Height / UPSCALE_Y;

-	static const int DIM_Z = 1 + cChunkDef::Width  / UPSCALE_Z;

-

-	cPerlinNoise m_Perlin;   // The base 3D noise source for the actual composition

-	cCubicNoise  m_Cubic;    // The noise used for heightmap directing

-	

-	int            m_SeaLevel;

-	NOISE_DATATYPE m_HeightAmplification;

-	NOISE_DATATYPE m_MidPoint;  // Where the vertical "center" of the noise should be

-	NOISE_DATATYPE m_FrequencyX;

-	NOISE_DATATYPE m_FrequencyY;

-	NOISE_DATATYPE m_FrequencyZ;

-	NOISE_DATATYPE m_AirThreshold;

-	

-	/// Generates the 3D noise array used for terrain generation; a_Noise is of ChunkData-size

-	void GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DATATYPE * a_Noise);

-	

-	/// Updates heightmap based on the chunk's contents

-	void UpdateHeightmap(cChunkDesc & a_ChunkDesc);

-	

-	/// Composes terrain - adds dirt, grass and sand

-	void ComposeTerrain(cChunkDesc & a_ChunkDesc);

-} ;

-

-

-

-

-

-class cNoise3DComposable :

-	public cTerrainHeightGen,

-	public cTerrainCompositionGen

-{

-public:

-	cNoise3DComposable(int a_Seed);

-

-	void Initialize(cIniFile & a_IniFile);

-

-protected:

-	cNoise m_Noise1;

-	cNoise m_Noise2;

-	cNoise m_Noise3;

-	

-	int            m_SeaLevel;

-	NOISE_DATATYPE m_HeightAmplification;

-	NOISE_DATATYPE m_MidPoint;  // Where the vertical "center" of the noise should be

-	NOISE_DATATYPE m_FrequencyX;

-	NOISE_DATATYPE m_FrequencyY;

-	NOISE_DATATYPE m_FrequencyZ;

-	NOISE_DATATYPE m_AirThreshold;

-	

-	int m_LastChunkX;

-	int m_LastChunkZ;

-	NOISE_DATATYPE m_NoiseArray[17 * 17 * 257];  // x + 17 * z + 17 * 17 * y

-	

-	

-	/// Generates the 3D noise array used for terrain generation, unless the LastChunk coords are equal to coords given

-	void GenerateNoiseArrayIfNeeded(int a_ChunkX, int a_ChunkZ);

-	

-	// cTerrainHeightGen overrides:

-	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;

-

-	// cTerrainCompositionGen overrides:

-	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

+
+// Noise3DGenerator.h
+
+// Generates terrain using 3D noise, rather than composing. Is a test.
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "../Noise.h"
+
+
+
+
+
+class cNoise3DGenerator :
+	public cChunkGenerator::cGenerator
+{
+	typedef cChunkGenerator::cGenerator super;
+	
+public:
+	cNoise3DGenerator(cChunkGenerator & a_ChunkGenerator);
+	virtual ~cNoise3DGenerator();
+	
+	virtual void Initialize(cWorld * a_World, cIniFile & a_IniFile) override;
+	virtual void GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) override;
+	virtual void DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc) override;
+	
+protected:
+	// Linear interpolation step sizes, must be divisors of cChunkDef::Width and cChunkDef::Height, respectively:
+	static const int UPSCALE_X = 8;
+	static const int UPSCALE_Y = 4;
+	static const int UPSCALE_Z = 8;
+	
+	// Linear interpolation buffer dimensions, calculated from the step sizes:
+	static const int DIM_X = 1 + cChunkDef::Width  / UPSCALE_X;
+	static const int DIM_Y = 1 + cChunkDef::Height / UPSCALE_Y;
+	static const int DIM_Z = 1 + cChunkDef::Width  / UPSCALE_Z;
+
+	cPerlinNoise m_Perlin;   // The base 3D noise source for the actual composition
+	cCubicNoise  m_Cubic;    // The noise used for heightmap directing
+	
+	int            m_SeaLevel;
+	NOISE_DATATYPE m_HeightAmplification;
+	NOISE_DATATYPE m_MidPoint;  // Where the vertical "center" of the noise should be
+	NOISE_DATATYPE m_FrequencyX;
+	NOISE_DATATYPE m_FrequencyY;
+	NOISE_DATATYPE m_FrequencyZ;
+	NOISE_DATATYPE m_AirThreshold;
+	
+	/// Generates the 3D noise array used for terrain generation; a_Noise is of ChunkData-size
+	void GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DATATYPE * a_Noise);
+	
+	/// Updates heightmap based on the chunk's contents
+	void UpdateHeightmap(cChunkDesc & a_ChunkDesc);
+	
+	/// Composes terrain - adds dirt, grass and sand
+	void ComposeTerrain(cChunkDesc & a_ChunkDesc);
+} ;
+
+
+
+
+
+class cNoise3DComposable :
+	public cTerrainHeightGen,
+	public cTerrainCompositionGen
+{
+public:
+	cNoise3DComposable(int a_Seed);
+
+	void Initialize(cIniFile & a_IniFile);
+
+protected:
+	cNoise m_Noise1;
+	cNoise m_Noise2;
+	cNoise m_Noise3;
+	
+	int            m_SeaLevel;
+	NOISE_DATATYPE m_HeightAmplification;
+	NOISE_DATATYPE m_MidPoint;  // Where the vertical "center" of the noise should be
+	NOISE_DATATYPE m_FrequencyX;
+	NOISE_DATATYPE m_FrequencyY;
+	NOISE_DATATYPE m_FrequencyZ;
+	NOISE_DATATYPE m_AirThreshold;
+	
+	int m_LastChunkX;
+	int m_LastChunkZ;
+	NOISE_DATATYPE m_NoiseArray[17 * 17 * 257];  // x + 17 * z + 17 * 17 * y
+	
+	
+	/// Generates the 3D noise array used for terrain generation, unless the LastChunk coords are equal to coords given
+	void GenerateNoiseArrayIfNeeded(int a_ChunkX, int a_ChunkZ);
+	
+	// cTerrainHeightGen overrides:
+	virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;
+
+	// cTerrainCompositionGen overrides:
+	virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+
diff --git a/source/Generating/Ravines.cpp b/source/Generating/Ravines.cpp
index 94d91c0bb..6413b963b 100644
--- a/source/Generating/Ravines.cpp
+++ b/source/Generating/Ravines.cpp
@@ -1,531 +1,531 @@
-

-// Ravines.cpp

-

-// Implements the cStructGenRavines class representing the ravine structure generator

-

-#include "Globals.h"

-#include "Ravines.h"

-

-

-

-

-/// How many ravines in each direction are generated for a given chunk. Must be an even number

-static const int NEIGHBORHOOD_SIZE = 8;

-

-static const int NUM_RAVINE_POINTS = 4;

-

-

-

-

-

-struct cRavDefPoint

-{

-	int m_BlockX;

-	int m_BlockZ;

-	int m_Radius;

-	int m_Top;

-	int m_Bottom;

-	

-	cRavDefPoint(int a_BlockX, int a_BlockZ, int a_Radius, int a_Top, int a_Bottom) :

-		m_BlockX(a_BlockX),

-		m_BlockZ(a_BlockZ),

-		m_Radius(a_Radius),

-		m_Top   (a_Top),

-		m_Bottom(a_Bottom)

-	{

-	}

-} ;

-

-typedef std::vector<cRavDefPoint> cRavDefPoints;

-

-

-

-

-

-class cStructGenRavines::cRavine

-{

-	cRavDefPoints m_Points;

-	

-	/// Generates the shaping defpoints for the ravine, based on the ravine block coords and noise

-	void GenerateBaseDefPoints(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise);

-	

-	/// Refines (adds and smooths) defpoints from a_Src into a_Dst

-	void RefineDefPoints(const cRavDefPoints & a_Src, cRavDefPoints & a_Dst);

-	

-	/// Does one round of smoothing, two passes of RefineDefPoints()

-	void Smooth(void);

-	

-	/// Linearly interpolates the points so that the maximum distance between two neighbors is max 1 block

-	void FinishLinear(void);

-	

-public:

-	// Coords for which the ravine was generated (not necessarily the center)

-	int m_BlockX;

-	int m_BlockZ;

-	

-	cRavine(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise);

-	

-	/// Carves the ravine into the chunk specified

-	void ProcessChunk(

-		int a_ChunkX, int a_ChunkZ, 

-		cChunkDef::BlockTypes & a_BlockTypes, 

-		cChunkDef::HeightMap & a_HeightMap

-	);

-	

-	#ifdef _DEBUG

-	/// Exports itself as a SVG line definition

-	AString ExportAsSVG(int a_Color, int a_OffsetX = 0, int a_OffsetZ = 0) const;

-	#endif  // _DEBUG

-} ;

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenRavines:

-

-cStructGenRavines::cStructGenRavines(int a_Seed, int a_Size) :

-	m_Noise(a_Seed),

-	m_Size(a_Size)

-{

-}

-

-

-

-

-

-cStructGenRavines::~cStructGenRavines()

-{

-	ClearCache();

-}

-

-

-

-

-

-void cStructGenRavines::ClearCache(void)

-{

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

-	{

-		delete *itr;

-	}  // for itr - m_Cache[]

-	m_Cache.clear();

-}

-

-

-

-

-

-void cStructGenRavines::GenStructures(cChunkDesc & a_ChunkDesc)

-{

-	int ChunkX = a_ChunkDesc.GetChunkX();

-	int ChunkZ = a_ChunkDesc.GetChunkZ();

-	cRavines Ravines;

-	GetRavinesForChunk(ChunkX, ChunkZ, Ravines);

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

-	{

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

-	}  // for itr - Ravines[]

-}

-

-

-

-

-

-void cStructGenRavines::GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cStructGenRavines::cRavines & a_Ravines)

-{

-	int BaseX = a_ChunkX * cChunkDef::Width / m_Size;

-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_Size;

-	if (BaseX < 0)

-	{

-		--BaseX;

-	}

-	if (BaseZ < 0)

-	{

-		--BaseZ;

-	}

-	BaseX -= 4;

-	BaseZ -= 4;

-	

-	// Walk the cache, move each ravine that we want into a_Ravines:

-	int StartX = BaseX * m_Size;

-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_Size;

-	int StartZ = BaseZ * m_Size;

-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_Size;

-	for (cRavines::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)

-	{

-		if (

-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&

-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)

-		)

-		{

-			// want

-			a_Ravines.push_back(*itr);

-			itr = m_Cache.erase(itr);

-		}

-		else

-		{

-			// don't want

-			++itr;

-		}

-	}  // for itr - m_Cache[]

-	

-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)

-	{

-		int RealX = (BaseX + x) * m_Size;

-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)

-		{

-			int RealZ = (BaseZ + z) * m_Size;

-			bool Found = false;

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

-			{

-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))

-				{

-					Found = true;

-					break;

-				}

-			}

-			if (!Found)

-			{

-				a_Ravines.push_back(new cRavine(RealX, RealZ, m_Size, m_Noise));

-			}

-		}

-	}

-	

-	// Copy a_Ravines into m_Cache to the beginning:

-	cRavines RavinesCopy(a_Ravines);

-	m_Cache.splice(m_Cache.begin(), RavinesCopy, RavinesCopy.begin(), RavinesCopy.end());

-	

-	// Trim the cache if it's too long:

-	if (m_Cache.size() > 100)

-	{

-		cRavines::iterator itr = m_Cache.begin();

-		std::advance(itr, 100);

-		for (cRavines::iterator end = m_Cache.end(); itr != end; ++itr)

-		{

-			delete *itr;

-		}

-		itr = m_Cache.begin();

-		std::advance(itr, 100);

-		m_Cache.erase(itr, m_Cache.end());

-	}

-	

-	/*

-	#ifdef _DEBUG

-	// DEBUG: Export as SVG into a file specific for the chunk, for visual verification:

-	AString SVG;

-	SVG.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1024\" height = \"1024\">\n");

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

-	{

-		SVG.append((*itr)->ExportAsSVG(0, 512, 512));

-	}

-	SVG.append("</svg>\n");

-	

-	AString fnam;

-	Printf(fnam, "ravines\\%03d_%03d.svg", a_ChunkX, a_ChunkZ);

-	cFile File(fnam, cFile::fmWrite);

-	File.Write(SVG.c_str(), SVG.size());

-	#endif  // _DEBUG

-	//*/

-}

-

-

-

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// cStructGenRavines::cRavine

-

-cStructGenRavines::cRavine::cRavine(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise) :

-	m_BlockX(a_BlockX),

-	m_BlockZ(a_BlockZ)

-{

-	// Calculate the ravine shape-defining points:

-	GenerateBaseDefPoints(a_BlockX, a_BlockZ, a_Size, a_Noise);

-	

-	// Smooth the ravine. A two passes are needed:

-	Smooth();

-	Smooth();

-	

-	// Linearly interpolate the neighbors so that they're close enough together:

-	FinishLinear();

-}

-

-

-

-

-

-void cStructGenRavines::cRavine::GenerateBaseDefPoints(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise)

-{

-	// Modify the size slightly to have different-sized ravines (1/2 to 1/1 of a_Size):

-	a_Size = (512 + ((a_Noise.IntNoise3DInt(19 * a_BlockX, 11 * a_BlockZ, a_BlockX + a_BlockZ) / 17) % 512)) * a_Size / 1024;

-	

-	// The complete offset of the ravine from its cellpoint, up to 2 * a_Size in each direction

-	int OffsetX = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 0)    / 9) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * m_BlockZ, 1000) / 7) % (2 * a_Size)) - 2 * a_Size) / 2;

-	int OffsetZ = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 2000) / 7) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * m_BlockZ, 3000) / 9) % (2 * a_Size)) - 2 * a_Size) / 2;

-	int CenterX = a_BlockX + OffsetX;

-	int CenterZ = a_BlockZ + OffsetZ;

-	

-	// Get the base angle in which the ravine "axis" goes:

-	float Angle = (float)(((float)((a_Noise.IntNoise3DInt(20 * a_BlockX, 70 * a_BlockZ, 6000) / 9) % 16384)) / 16384.0 * 3.141592653);

-	float xc = sin(Angle);

-	float zc = cos(Angle);

-	

-	// Calculate the definition points and radii:

-	int MaxRadius = (int)(sqrt(12.0 + ((a_Noise.IntNoise2DInt(61 * a_BlockX, 97 * a_BlockZ) / 13) % a_Size) / 16));

-	int Top       = 32 + ((a_Noise.IntNoise2DInt(13 * a_BlockX, 17 * a_BlockZ) / 23) % 32);

-	int Bottom    = 5 + ((a_Noise.IntNoise2DInt(17 * a_BlockX, 29 * a_BlockZ) / 13) % 32);

-	int Mid = (Top + Bottom) / 2;

-	int PointX = CenterX - (int)(xc * a_Size / 2);

-	int PointZ = CenterZ - (int)(zc * a_Size / 2);

-	m_Points.push_back(cRavDefPoint(PointX, PointZ, 0, (Mid + Top) / 2, (Mid + Bottom) / 2));

-	for (int i = 1; i < NUM_RAVINE_POINTS - 1; i++)

-	{

-		int LineX = CenterX + (int)(xc * a_Size * (i - NUM_RAVINE_POINTS / 2) / NUM_RAVINE_POINTS);

-		int LineZ = CenterZ + (int)(zc * a_Size * (i - NUM_RAVINE_POINTS / 2) / NUM_RAVINE_POINTS);

-		// Amplitude is the amount of blocks that this point is away from the ravine "axis"

-		int Amplitude = (a_Noise.IntNoise3DInt(70 * a_BlockX, 20 * a_BlockZ + 31 * i, 10000 * i) / 9) % a_Size;

-		Amplitude = Amplitude / 4 - a_Size / 8;  // Amplitude is in interval [-a_Size / 4, a_Size / 4]

-		int PointX = LineX + (int)(zc * Amplitude);

-		int PointZ = LineZ - (int)(xc * Amplitude);

-		int Radius = MaxRadius - abs(i - NUM_RAVINE_POINTS / 2);  // TODO: better radius function

-		int ThisTop    = Top    + ((a_Noise.IntNoise3DInt(7 *  a_BlockX, 19 * a_BlockZ, i * 31) / 13) % 8) - 4;

-		int ThisBottom = Bottom + ((a_Noise.IntNoise3DInt(19 * a_BlockX, 7 *  a_BlockZ, i * 31) / 13) % 8) - 4;

-		m_Points.push_back(cRavDefPoint(PointX, PointZ, Radius, ThisTop, ThisBottom));

-	}  // for i - m_Points[]

-	PointX = CenterX + (int)(xc * a_Size / 2);

-	PointZ = CenterZ + (int)(zc * a_Size / 2);

-	m_Points.push_back(cRavDefPoint(PointX, PointZ, 0, Mid, Mid));

-}

-

-

-

-

-

-void cStructGenRavines::cRavine::RefineDefPoints(const cRavDefPoints & a_Src, cRavDefPoints & a_Dst)

-{

-	// Smoothing: for each line segment, add points on its 1/4 lengths

-	int Num = a_Src.size() - 2;  // this many intermediary points

-	a_Dst.clear();

-	a_Dst.reserve(Num * 2 + 2);

-	cRavDefPoints::const_iterator itr = a_Src.begin() + 1;

-	a_Dst.push_back(a_Src.front());

-	int PrevX = a_Src.front().m_BlockX;

-	int PrevZ = a_Src.front().m_BlockZ;

-	int PrevR = a_Src.front().m_Radius;

-	int PrevT = a_Src.front().m_Top;

-	int PrevB = a_Src.front().m_Bottom;

-	for (int i = 0; i <= Num; ++i, ++itr)

-	{

-		int dx = itr->m_BlockX - PrevX;

-		int dz = itr->m_BlockZ - PrevZ;

-		if (abs(dx) + abs(dz) < 4)

-		{

-			// Too short a segment to smooth-subdivide into quarters

-			continue;

-		}

-		int dr = itr->m_Radius - PrevR;

-		int dt = itr->m_Top    - PrevT;

-		int db = itr->m_Bottom - PrevB;

-		int Rad1 = std::max(PrevR + 1 * dr / 4, 1);

-		int Rad2 = std::max(PrevR + 3 * dr / 4, 1);

-		a_Dst.push_back(cRavDefPoint(PrevX + 1 * dx / 4, PrevZ + 1 * dz / 4, Rad1, PrevT + 1 * dt / 4, PrevB + 1 * db / 4));

-		a_Dst.push_back(cRavDefPoint(PrevX + 3 * dx / 4, PrevZ + 3 * dz / 4, Rad2, PrevT + 3 * dt / 4, PrevB + 3 * db / 4));

-		PrevX = itr->m_BlockX;

-		PrevZ = itr->m_BlockZ;

-		PrevR = itr->m_Radius;

-		PrevT = itr->m_Top;

-		PrevB = itr->m_Bottom;

-	}

-	a_Dst.push_back(a_Src.back());

-}

-

-

-

-

-

-void cStructGenRavines::cRavine::Smooth(void)

-{

-	cRavDefPoints Pts;

-	RefineDefPoints(m_Points, Pts);  // Refine m_Points -> Pts

-	RefineDefPoints(Pts, m_Points);  // Refine Pts -> m_Points

-}

-

-

-

-

-

-void cStructGenRavines::cRavine::FinishLinear(void)

-{

-	// For each segment, use Bresenham's line algorithm to draw a "line" of defpoints

-	// _X 2012_07_20: I tried modifying this algorithm to produce "thick" lines (only one coord change per point)

-	//   But the results were about the same as the original, so I disposed of it again - no need to use twice the count of points

-	

-	cRavDefPoints Pts;

-	std::swap(Pts, m_Points);

-	

-	m_Points.reserve(Pts.size() * 3);

-	int PrevX = Pts.front().m_BlockX;

-	int PrevZ = Pts.front().m_BlockZ;

-	for (cRavDefPoints::const_iterator itr = Pts.begin() + 1, end = Pts.end(); itr != end; ++itr)

-	{

-		int x1 = itr->m_BlockX;

-		int z1 = itr->m_BlockZ;

-		int dx = abs(x1 - PrevX);

-		int dz = abs(z1 - PrevZ);

-		int sx = (PrevX < x1) ? 1 : -1;

-		int sz = (PrevZ < z1) ? 1 : -1;

-		int err = dx - dz;

-		int R = itr->m_Radius;

-		int T = itr->m_Top;

-		int B = itr->m_Bottom;

-		while (true)

-		{

-			m_Points.push_back(cRavDefPoint(PrevX, PrevZ, R, T, B));

-			if ((PrevX == x1) && (PrevZ == z1))

-			{

-				break;

-			}

-			int e2 = 2 * err;

-			if (e2 > -dz)

-			{

-				err -= dz;

-				PrevX += sx;

-			}

-			if (e2 < dx)

-			{

-				err += dx;

-				PrevZ += sz;

-			}

-		}  // while (true)

-	}  // for itr

-}

-

-

-

-

-

-#ifdef _DEBUG

-AString cStructGenRavines::cRavine::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const

-{

-	AString SVG;

-  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#%06x;stroke-width:1px;\"\nd=\"", a_Color);

-  char Prefix = 'M';  // The first point needs "M" prefix, all the others need "L"

-  for (cRavDefPoints::const_iterator itr = m_Points.begin(); itr != m_Points.end(); ++itr)

-  {

-		AppendPrintf(SVG, "%c %d,%d ", Prefix, a_OffsetX + itr->m_BlockX, a_OffsetZ + itr->m_BlockZ);

-		Prefix = 'L';

-  }

-  SVG.append("\"/>\n");

-  

-  // Base point highlight:

-  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",

-		a_OffsetX + m_BlockX - 5, a_OffsetZ + m_BlockZ, a_OffsetX + m_BlockX + 5, a_OffsetZ + m_BlockZ

-	);

-  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",

-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ - 5, a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ + 5

-	);

-	

-	// A gray line from the base point to the first point of the ravine, for identification:

-  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#cfcfcf;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",

-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ, a_OffsetX + m_Points.front().m_BlockX, a_OffsetZ + m_Points.front().m_BlockZ

-	);

-	

-	// Offset guides:

-	if (a_OffsetX > 0)

-	{

-		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M %d,0 L %d,1024\"/>\n",

-			a_OffsetX, a_OffsetX

-		);

-	}

-	if (a_OffsetZ > 0)

-	{

-		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M 0,%d L 1024,%d\"/>\n",

-			a_OffsetZ, a_OffsetZ

-		);

-	}

-	return SVG;

-}

-#endif  // _DEBUG

-

-

-

-

-

-void cStructGenRavines::cRavine::ProcessChunk(

-	int a_ChunkX, int a_ChunkZ, 

-	cChunkDef::BlockTypes & a_BlockTypes,

-	cChunkDef::HeightMap & a_HeightMap

-)

-{

-	int BlockStartX = a_ChunkX * cChunkDef::Width;

-	int BlockStartZ = a_ChunkZ * cChunkDef::Width;

-	int BlockEndX = BlockStartX + cChunkDef::Width;

-	int BlockEndZ = BlockStartZ + cChunkDef::Width;

-	for (cRavDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)

-	{

-		if (

-			(itr->m_BlockX + itr->m_Radius < BlockStartX) ||

-			(itr->m_BlockX - itr->m_Radius > BlockEndX) ||

-			(itr->m_BlockZ + itr->m_Radius < BlockStartZ) ||

-			(itr->m_BlockZ - itr->m_Radius > BlockEndZ)

-		)

-		{

-			// Cannot intersect, bail out early

-			continue;

-		}

-		

-		// Carve out a cylinder around the xz point, m_Radius in diameter, from Bottom to Top:

-		int RadiusSq = itr->m_Radius * itr->m_Radius;  // instead of doing sqrt for each distance, we do sqr of the radius

-		int DifX = BlockStartX - itr->m_BlockX;  // substitution for faster calc

-		int DifZ = BlockStartZ - itr->m_BlockZ;  // substitution for faster calc

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

-		{

-			#ifdef _DEBUG

-			// DEBUG: Make the ravine shapepoints visible on a single layer (so that we can see with Minutor what's going on)

-			if ((DifX + x == 0) && (DifZ + z == 0))

-			{

-				cChunkDef::SetBlock(a_BlockTypes, x, 4, z, E_BLOCK_LAPIS_ORE);

-			}

-			#endif  // _DEBUG

-			

-			int DistSq = (DifX + x) * (DifX + x) + (DifZ + z) * (DifZ + z);

-			if (DistSq <= RadiusSq)

-			{

-				int Top = std::min(itr->m_Top, (int)(cChunkDef::Height));  // Stupid gcc needs int cast

-				for (int y = std::max(itr->m_Bottom, 1); y <= Top; y++)

-				{

-					switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))

-					{

-						// Only carve out these specific block types

-						case E_BLOCK_DIRT:

-						case E_BLOCK_GRASS:

-						case E_BLOCK_STONE:

-						case E_BLOCK_COBBLESTONE:

-						case E_BLOCK_GRAVEL:

-						case E_BLOCK_SAND:

-						case E_BLOCK_SANDSTONE:

-						case E_BLOCK_NETHERRACK:

-						case E_BLOCK_COAL_ORE:

-						case E_BLOCK_IRON_ORE:

-						case E_BLOCK_GOLD_ORE:

-						case E_BLOCK_DIAMOND_ORE:

-						case E_BLOCK_REDSTONE_ORE:

-						case E_BLOCK_REDSTONE_ORE_GLOWING:

-						{

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

-							break;

-						}

-						default: break;

-					}

-				}

-			}

-		}  // for x, z - a_BlockTypes

-	}  // for itr - m_Points[]

-}

-

-

-

-

+
+// Ravines.cpp
+
+// Implements the cStructGenRavines class representing the ravine structure generator
+
+#include "Globals.h"
+#include "Ravines.h"
+
+
+
+
+/// How many ravines in each direction are generated for a given chunk. Must be an even number
+static const int NEIGHBORHOOD_SIZE = 8;
+
+static const int NUM_RAVINE_POINTS = 4;
+
+
+
+
+
+struct cRavDefPoint
+{
+	int m_BlockX;
+	int m_BlockZ;
+	int m_Radius;
+	int m_Top;
+	int m_Bottom;
+	
+	cRavDefPoint(int a_BlockX, int a_BlockZ, int a_Radius, int a_Top, int a_Bottom) :
+		m_BlockX(a_BlockX),
+		m_BlockZ(a_BlockZ),
+		m_Radius(a_Radius),
+		m_Top   (a_Top),
+		m_Bottom(a_Bottom)
+	{
+	}
+} ;
+
+typedef std::vector<cRavDefPoint> cRavDefPoints;
+
+
+
+
+
+class cStructGenRavines::cRavine
+{
+	cRavDefPoints m_Points;
+	
+	/// Generates the shaping defpoints for the ravine, based on the ravine block coords and noise
+	void GenerateBaseDefPoints(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise);
+	
+	/// Refines (adds and smooths) defpoints from a_Src into a_Dst
+	void RefineDefPoints(const cRavDefPoints & a_Src, cRavDefPoints & a_Dst);
+	
+	/// Does one round of smoothing, two passes of RefineDefPoints()
+	void Smooth(void);
+	
+	/// Linearly interpolates the points so that the maximum distance between two neighbors is max 1 block
+	void FinishLinear(void);
+	
+public:
+	// Coords for which the ravine was generated (not necessarily the center)
+	int m_BlockX;
+	int m_BlockZ;
+	
+	cRavine(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise);
+	
+	/// Carves the ravine into the chunk specified
+	void ProcessChunk(
+		int a_ChunkX, int a_ChunkZ, 
+		cChunkDef::BlockTypes & a_BlockTypes, 
+		cChunkDef::HeightMap & a_HeightMap
+	);
+	
+	#ifdef _DEBUG
+	/// Exports itself as a SVG line definition
+	AString ExportAsSVG(int a_Color, int a_OffsetX = 0, int a_OffsetZ = 0) const;
+	#endif  // _DEBUG
+} ;
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenRavines:
+
+cStructGenRavines::cStructGenRavines(int a_Seed, int a_Size) :
+	m_Noise(a_Seed),
+	m_Size(a_Size)
+{
+}
+
+
+
+
+
+cStructGenRavines::~cStructGenRavines()
+{
+	ClearCache();
+}
+
+
+
+
+
+void cStructGenRavines::ClearCache(void)
+{
+	for (cRavines::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
+	{
+		delete *itr;
+	}  // for itr - m_Cache[]
+	m_Cache.clear();
+}
+
+
+
+
+
+void cStructGenRavines::GenStructures(cChunkDesc & a_ChunkDesc)
+{
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cRavines Ravines;
+	GetRavinesForChunk(ChunkX, ChunkZ, Ravines);
+	for (cRavines::const_iterator itr = Ravines.begin(), end = Ravines.end(); itr != end; ++itr)
+	{
+		(*itr)->ProcessChunk(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
+	}  // for itr - Ravines[]
+}
+
+
+
+
+
+void cStructGenRavines::GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cStructGenRavines::cRavines & a_Ravines)
+{
+	int BaseX = a_ChunkX * cChunkDef::Width / m_Size;
+	int BaseZ = a_ChunkZ * cChunkDef::Width / m_Size;
+	if (BaseX < 0)
+	{
+		--BaseX;
+	}
+	if (BaseZ < 0)
+	{
+		--BaseZ;
+	}
+	BaseX -= 4;
+	BaseZ -= 4;
+	
+	// Walk the cache, move each ravine that we want into a_Ravines:
+	int StartX = BaseX * m_Size;
+	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_Size;
+	int StartZ = BaseZ * m_Size;
+	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_Size;
+	for (cRavines::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
+	{
+		if (
+			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
+			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
+		)
+		{
+			// want
+			a_Ravines.push_back(*itr);
+			itr = m_Cache.erase(itr);
+		}
+		else
+		{
+			// don't want
+			++itr;
+		}
+	}  // for itr - m_Cache[]
+	
+	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
+	{
+		int RealX = (BaseX + x) * m_Size;
+		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
+		{
+			int RealZ = (BaseZ + z) * m_Size;
+			bool Found = false;
+			for (cRavines::const_iterator itr = a_Ravines.begin(), end = a_Ravines.end(); itr != end; ++itr)
+			{
+				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
+				{
+					Found = true;
+					break;
+				}
+			}
+			if (!Found)
+			{
+				a_Ravines.push_back(new cRavine(RealX, RealZ, m_Size, m_Noise));
+			}
+		}
+	}
+	
+	// Copy a_Ravines into m_Cache to the beginning:
+	cRavines RavinesCopy(a_Ravines);
+	m_Cache.splice(m_Cache.begin(), RavinesCopy, RavinesCopy.begin(), RavinesCopy.end());
+	
+	// Trim the cache if it's too long:
+	if (m_Cache.size() > 100)
+	{
+		cRavines::iterator itr = m_Cache.begin();
+		std::advance(itr, 100);
+		for (cRavines::iterator end = m_Cache.end(); itr != end; ++itr)
+		{
+			delete *itr;
+		}
+		itr = m_Cache.begin();
+		std::advance(itr, 100);
+		m_Cache.erase(itr, m_Cache.end());
+	}
+	
+	/*
+	#ifdef _DEBUG
+	// DEBUG: Export as SVG into a file specific for the chunk, for visual verification:
+	AString SVG;
+	SVG.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1024\" height = \"1024\">\n");
+	for (cRavines::const_iterator itr = a_Ravines.begin(), end = a_Ravines.end(); itr != end; ++itr)
+	{
+		SVG.append((*itr)->ExportAsSVG(0, 512, 512));
+	}
+	SVG.append("</svg>\n");
+	
+	AString fnam;
+	Printf(fnam, "ravines\\%03d_%03d.svg", a_ChunkX, a_ChunkZ);
+	cFile File(fnam, cFile::fmWrite);
+	File.Write(SVG.c_str(), SVG.size());
+	#endif  // _DEBUG
+	//*/
+}
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cStructGenRavines::cRavine
+
+cStructGenRavines::cRavine::cRavine(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise) :
+	m_BlockX(a_BlockX),
+	m_BlockZ(a_BlockZ)
+{
+	// Calculate the ravine shape-defining points:
+	GenerateBaseDefPoints(a_BlockX, a_BlockZ, a_Size, a_Noise);
+	
+	// Smooth the ravine. A two passes are needed:
+	Smooth();
+	Smooth();
+	
+	// Linearly interpolate the neighbors so that they're close enough together:
+	FinishLinear();
+}
+
+
+
+
+
+void cStructGenRavines::cRavine::GenerateBaseDefPoints(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise)
+{
+	// Modify the size slightly to have different-sized ravines (1/2 to 1/1 of a_Size):
+	a_Size = (512 + ((a_Noise.IntNoise3DInt(19 * a_BlockX, 11 * a_BlockZ, a_BlockX + a_BlockZ) / 17) % 512)) * a_Size / 1024;
+	
+	// The complete offset of the ravine from its cellpoint, up to 2 * a_Size in each direction
+	int OffsetX = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 0)    / 9) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * m_BlockZ, 1000) / 7) % (2 * a_Size)) - 2 * a_Size) / 2;
+	int OffsetZ = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 2000) / 7) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * m_BlockZ, 3000) / 9) % (2 * a_Size)) - 2 * a_Size) / 2;
+	int CenterX = a_BlockX + OffsetX;
+	int CenterZ = a_BlockZ + OffsetZ;
+	
+	// Get the base angle in which the ravine "axis" goes:
+	float Angle = (float)(((float)((a_Noise.IntNoise3DInt(20 * a_BlockX, 70 * a_BlockZ, 6000) / 9) % 16384)) / 16384.0 * 3.141592653);
+	float xc = sin(Angle);
+	float zc = cos(Angle);
+	
+	// Calculate the definition points and radii:
+	int MaxRadius = (int)(sqrt(12.0 + ((a_Noise.IntNoise2DInt(61 * a_BlockX, 97 * a_BlockZ) / 13) % a_Size) / 16));
+	int Top       = 32 + ((a_Noise.IntNoise2DInt(13 * a_BlockX, 17 * a_BlockZ) / 23) % 32);
+	int Bottom    = 5 + ((a_Noise.IntNoise2DInt(17 * a_BlockX, 29 * a_BlockZ) / 13) % 32);
+	int Mid = (Top + Bottom) / 2;
+	int PointX = CenterX - (int)(xc * a_Size / 2);
+	int PointZ = CenterZ - (int)(zc * a_Size / 2);
+	m_Points.push_back(cRavDefPoint(PointX, PointZ, 0, (Mid + Top) / 2, (Mid + Bottom) / 2));
+	for (int i = 1; i < NUM_RAVINE_POINTS - 1; i++)
+	{
+		int LineX = CenterX + (int)(xc * a_Size * (i - NUM_RAVINE_POINTS / 2) / NUM_RAVINE_POINTS);
+		int LineZ = CenterZ + (int)(zc * a_Size * (i - NUM_RAVINE_POINTS / 2) / NUM_RAVINE_POINTS);
+		// Amplitude is the amount of blocks that this point is away from the ravine "axis"
+		int Amplitude = (a_Noise.IntNoise3DInt(70 * a_BlockX, 20 * a_BlockZ + 31 * i, 10000 * i) / 9) % a_Size;
+		Amplitude = Amplitude / 4 - a_Size / 8;  // Amplitude is in interval [-a_Size / 4, a_Size / 4]
+		int PointX = LineX + (int)(zc * Amplitude);
+		int PointZ = LineZ - (int)(xc * Amplitude);
+		int Radius = MaxRadius - abs(i - NUM_RAVINE_POINTS / 2);  // TODO: better radius function
+		int ThisTop    = Top    + ((a_Noise.IntNoise3DInt(7 *  a_BlockX, 19 * a_BlockZ, i * 31) / 13) % 8) - 4;
+		int ThisBottom = Bottom + ((a_Noise.IntNoise3DInt(19 * a_BlockX, 7 *  a_BlockZ, i * 31) / 13) % 8) - 4;
+		m_Points.push_back(cRavDefPoint(PointX, PointZ, Radius, ThisTop, ThisBottom));
+	}  // for i - m_Points[]
+	PointX = CenterX + (int)(xc * a_Size / 2);
+	PointZ = CenterZ + (int)(zc * a_Size / 2);
+	m_Points.push_back(cRavDefPoint(PointX, PointZ, 0, Mid, Mid));
+}
+
+
+
+
+
+void cStructGenRavines::cRavine::RefineDefPoints(const cRavDefPoints & a_Src, cRavDefPoints & a_Dst)
+{
+	// Smoothing: for each line segment, add points on its 1/4 lengths
+	int Num = a_Src.size() - 2;  // this many intermediary points
+	a_Dst.clear();
+	a_Dst.reserve(Num * 2 + 2);
+	cRavDefPoints::const_iterator itr = a_Src.begin() + 1;
+	a_Dst.push_back(a_Src.front());
+	int PrevX = a_Src.front().m_BlockX;
+	int PrevZ = a_Src.front().m_BlockZ;
+	int PrevR = a_Src.front().m_Radius;
+	int PrevT = a_Src.front().m_Top;
+	int PrevB = a_Src.front().m_Bottom;
+	for (int i = 0; i <= Num; ++i, ++itr)
+	{
+		int dx = itr->m_BlockX - PrevX;
+		int dz = itr->m_BlockZ - PrevZ;
+		if (abs(dx) + abs(dz) < 4)
+		{
+			// Too short a segment to smooth-subdivide into quarters
+			continue;
+		}
+		int dr = itr->m_Radius - PrevR;
+		int dt = itr->m_Top    - PrevT;
+		int db = itr->m_Bottom - PrevB;
+		int Rad1 = std::max(PrevR + 1 * dr / 4, 1);
+		int Rad2 = std::max(PrevR + 3 * dr / 4, 1);
+		a_Dst.push_back(cRavDefPoint(PrevX + 1 * dx / 4, PrevZ + 1 * dz / 4, Rad1, PrevT + 1 * dt / 4, PrevB + 1 * db / 4));
+		a_Dst.push_back(cRavDefPoint(PrevX + 3 * dx / 4, PrevZ + 3 * dz / 4, Rad2, PrevT + 3 * dt / 4, PrevB + 3 * db / 4));
+		PrevX = itr->m_BlockX;
+		PrevZ = itr->m_BlockZ;
+		PrevR = itr->m_Radius;
+		PrevT = itr->m_Top;
+		PrevB = itr->m_Bottom;
+	}
+	a_Dst.push_back(a_Src.back());
+}
+
+
+
+
+
+void cStructGenRavines::cRavine::Smooth(void)
+{
+	cRavDefPoints Pts;
+	RefineDefPoints(m_Points, Pts);  // Refine m_Points -> Pts
+	RefineDefPoints(Pts, m_Points);  // Refine Pts -> m_Points
+}
+
+
+
+
+
+void cStructGenRavines::cRavine::FinishLinear(void)
+{
+	// For each segment, use Bresenham's line algorithm to draw a "line" of defpoints
+	// _X 2012_07_20: I tried modifying this algorithm to produce "thick" lines (only one coord change per point)
+	//   But the results were about the same as the original, so I disposed of it again - no need to use twice the count of points
+	
+	cRavDefPoints Pts;
+	std::swap(Pts, m_Points);
+	
+	m_Points.reserve(Pts.size() * 3);
+	int PrevX = Pts.front().m_BlockX;
+	int PrevZ = Pts.front().m_BlockZ;
+	for (cRavDefPoints::const_iterator itr = Pts.begin() + 1, end = Pts.end(); itr != end; ++itr)
+	{
+		int x1 = itr->m_BlockX;
+		int z1 = itr->m_BlockZ;
+		int dx = abs(x1 - PrevX);
+		int dz = abs(z1 - PrevZ);
+		int sx = (PrevX < x1) ? 1 : -1;
+		int sz = (PrevZ < z1) ? 1 : -1;
+		int err = dx - dz;
+		int R = itr->m_Radius;
+		int T = itr->m_Top;
+		int B = itr->m_Bottom;
+		while (true)
+		{
+			m_Points.push_back(cRavDefPoint(PrevX, PrevZ, R, T, B));
+			if ((PrevX == x1) && (PrevZ == z1))
+			{
+				break;
+			}
+			int e2 = 2 * err;
+			if (e2 > -dz)
+			{
+				err -= dz;
+				PrevX += sx;
+			}
+			if (e2 < dx)
+			{
+				err += dx;
+				PrevZ += sz;
+			}
+		}  // while (true)
+	}  // for itr
+}
+
+
+
+
+
+#ifdef _DEBUG
+AString cStructGenRavines::cRavine::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const
+{
+	AString SVG;
+  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#%06x;stroke-width:1px;\"\nd=\"", a_Color);
+  char Prefix = 'M';  // The first point needs "M" prefix, all the others need "L"
+  for (cRavDefPoints::const_iterator itr = m_Points.begin(); itr != m_Points.end(); ++itr)
+  {
+		AppendPrintf(SVG, "%c %d,%d ", Prefix, a_OffsetX + itr->m_BlockX, a_OffsetZ + itr->m_BlockZ);
+		Prefix = 'L';
+  }
+  SVG.append("\"/>\n");
+  
+  // Base point highlight:
+  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
+		a_OffsetX + m_BlockX - 5, a_OffsetZ + m_BlockZ, a_OffsetX + m_BlockX + 5, a_OffsetZ + m_BlockZ
+	);
+  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
+		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ - 5, a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ + 5
+	);
+	
+	// A gray line from the base point to the first point of the ravine, for identification:
+  AppendPrintf(SVG, "<path style=\"fill:none;stroke:#cfcfcf;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
+		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ, a_OffsetX + m_Points.front().m_BlockX, a_OffsetZ + m_Points.front().m_BlockZ
+	);
+	
+	// Offset guides:
+	if (a_OffsetX > 0)
+	{
+		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M %d,0 L %d,1024\"/>\n",
+			a_OffsetX, a_OffsetX
+		);
+	}
+	if (a_OffsetZ > 0)
+	{
+		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M 0,%d L 1024,%d\"/>\n",
+			a_OffsetZ, a_OffsetZ
+		);
+	}
+	return SVG;
+}
+#endif  // _DEBUG
+
+
+
+
+
+void cStructGenRavines::cRavine::ProcessChunk(
+	int a_ChunkX, int a_ChunkZ, 
+	cChunkDef::BlockTypes & a_BlockTypes,
+	cChunkDef::HeightMap & a_HeightMap
+)
+{
+	int BlockStartX = a_ChunkX * cChunkDef::Width;
+	int BlockStartZ = a_ChunkZ * cChunkDef::Width;
+	int BlockEndX = BlockStartX + cChunkDef::Width;
+	int BlockEndZ = BlockStartZ + cChunkDef::Width;
+	for (cRavDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)
+	{
+		if (
+			(itr->m_BlockX + itr->m_Radius < BlockStartX) ||
+			(itr->m_BlockX - itr->m_Radius > BlockEndX) ||
+			(itr->m_BlockZ + itr->m_Radius < BlockStartZ) ||
+			(itr->m_BlockZ - itr->m_Radius > BlockEndZ)
+		)
+		{
+			// Cannot intersect, bail out early
+			continue;
+		}
+		
+		// Carve out a cylinder around the xz point, m_Radius in diameter, from Bottom to Top:
+		int RadiusSq = itr->m_Radius * itr->m_Radius;  // instead of doing sqrt for each distance, we do sqr of the radius
+		int DifX = BlockStartX - itr->m_BlockX;  // substitution for faster calc
+		int DifZ = BlockStartZ - itr->m_BlockZ;  // substitution for faster calc
+		for (int x = 0; x < cChunkDef::Width; x++) for (int z = 0; z < cChunkDef::Width; z++)
+		{
+			#ifdef _DEBUG
+			// DEBUG: Make the ravine shapepoints visible on a single layer (so that we can see with Minutor what's going on)
+			if ((DifX + x == 0) && (DifZ + z == 0))
+			{
+				cChunkDef::SetBlock(a_BlockTypes, x, 4, z, E_BLOCK_LAPIS_ORE);
+			}
+			#endif  // _DEBUG
+			
+			int DistSq = (DifX + x) * (DifX + x) + (DifZ + z) * (DifZ + z);
+			if (DistSq <= RadiusSq)
+			{
+				int Top = std::min(itr->m_Top, (int)(cChunkDef::Height));  // Stupid gcc needs int cast
+				for (int y = std::max(itr->m_Bottom, 1); y <= Top; y++)
+				{
+					switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))
+					{
+						// Only carve out these specific block types
+						case E_BLOCK_DIRT:
+						case E_BLOCK_GRASS:
+						case E_BLOCK_STONE:
+						case E_BLOCK_COBBLESTONE:
+						case E_BLOCK_GRAVEL:
+						case E_BLOCK_SAND:
+						case E_BLOCK_SANDSTONE:
+						case E_BLOCK_NETHERRACK:
+						case E_BLOCK_COAL_ORE:
+						case E_BLOCK_IRON_ORE:
+						case E_BLOCK_GOLD_ORE:
+						case E_BLOCK_DIAMOND_ORE:
+						case E_BLOCK_REDSTONE_ORE:
+						case E_BLOCK_REDSTONE_ORE_GLOWING:
+						{
+							cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);
+							break;
+						}
+						default: break;
+					}
+				}
+			}
+		}  // for x, z - a_BlockTypes
+	}  // for itr - m_Points[]
+}
+
+
+
+
diff --git a/source/Generating/Ravines.h b/source/Generating/Ravines.h
index 1c559c70d..05164a5b2 100644
--- a/source/Generating/Ravines.h
+++ b/source/Generating/Ravines.h
@@ -1,46 +1,46 @@
-

-// Ravines.h

-

-// Interfaces to the cStructGenRavines class representing the ravine structure generator

-

-

-

-

-

-#pragma once

-

-#include "ComposableGenerator.h"

-#include "../Noise.h"

-

-

-

-

-

-class cStructGenRavines :

-	public cStructureGen

-{

-public:

-	cStructGenRavines(int a_Seed, int a_Size);

-	~cStructGenRavines();

-	

-protected:

-	class cRavine;  // fwd: Ravines.cpp

-	typedef std::list<cRavine *> cRavines;

-	

-	cNoise   m_Noise;

-	int      m_Size;  // Max size, in blocks, of the ravines generated

-	cRavines m_Cache;

-	

-	/// Clears everything from the cache

-	void ClearCache(void);

-	

-	/// Returns all ravines that *may* intersect the given chunk. All the ravines are valid until the next call to this function.

-	void GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cRavines & a_Ravines);

-	

-	// cStructureGen override:

-	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;

-} ;

-

-

-

-

+
+// Ravines.h
+
+// Interfaces to the cStructGenRavines class representing the ravine structure generator
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+#include "../Noise.h"
+
+
+
+
+
+class cStructGenRavines :
+	public cStructureGen
+{
+public:
+	cStructGenRavines(int a_Seed, int a_Size);
+	~cStructGenRavines();
+	
+protected:
+	class cRavine;  // fwd: Ravines.cpp
+	typedef std::list<cRavine *> cRavines;
+	
+	cNoise   m_Noise;
+	int      m_Size;  // Max size, in blocks, of the ravines generated
+	cRavines m_Cache;
+	
+	/// Clears everything from the cache
+	void ClearCache(void);
+	
+	/// Returns all ravines that *may* intersect the given chunk. All the ravines are valid until the next call to this function.
+	void GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cRavines & a_Ravines);
+	
+	// cStructureGen override:
+	virtual void GenStructures(cChunkDesc & a_ChunkDesc) override;
+} ;
+
+
+
+