20 files changed, 279 insertions, 208 deletions

diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index 8924a7999..b9face1f8 100644
--- a/src/Generating/BioGen.cpp
+++ b/src/Generating/BioGen.cpp
@@ -45,7 +45,7 @@ void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cBioGenCache:
 
-cBioGenCache::cBioGenCache(cBiomeGen * a_BioGenToCache, int a_CacheSize) :
+cBioGenCache::cBioGenCache(cBiomeGenPtr a_BioGenToCache, int a_CacheSize) :
 	m_BioGenToCache(a_BioGenToCache),
 	m_CacheSize(a_CacheSize),
 	m_CacheOrder(new int[a_CacheSize]),
@@ -145,25 +145,13 @@ void cBioGenCache::InitializeBiomeGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cBioGenMulticache:
 
-cBioGenMulticache::cBioGenMulticache(cBiomeGen * a_BioGenToCache, size_t a_CacheSize, size_t a_CachesLength) :
-	m_CachesLength(a_CachesLength)
+cBioGenMulticache::cBioGenMulticache(cBiomeGenPtr a_BioGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches) :
+	m_NumSubCaches(a_NumSubCaches)
 {
-	m_Caches.reserve(a_CachesLength);
-	for (size_t i = 0; i < a_CachesLength; i++)
+	m_Caches.reserve(a_NumSubCaches);
+	for (size_t i = 0; i < a_NumSubCaches; i++)
 	{
-		m_Caches.push_back(new cBioGenCache(a_BioGenToCache, a_CacheSize));
-	}
-}
-
-
-
-
-
-cBioGenMulticache::~cBioGenMulticache()
-{
-	for (cBiomeGens::iterator it = m_Caches.begin(); it != m_Caches.end(); it++)
-	{
-		delete *it;
+		m_Caches.push_back(cBiomeGenPtr(new cBioGenCache(a_BioGenToCache, a_SubCacheSize)));
 	}
 }
 
@@ -174,7 +162,7 @@ cBioGenMulticache::~cBioGenMulticache()
 void cBioGenMulticache::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)
 {
 	const size_t coefficient = 3;
-	const size_t cacheIdx = ((size_t)a_ChunkX + coefficient * (size_t)a_ChunkZ) % m_CachesLength;
+	const size_t cacheIdx = ((size_t)a_ChunkX + coefficient * (size_t)a_ChunkZ) % m_NumSubCaches;
 
 	m_Caches[cacheIdx]->GenBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);
 }
@@ -185,10 +173,9 @@ void cBioGenMulticache::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMa
 
 void cBioGenMulticache::InitializeBiomeGen(cIniFile & a_IniFile)
 {
-	for (cBiomeGens::iterator it = m_Caches.begin(); it != m_Caches.end(); it++)
+	for (auto itr : m_Caches)
 	{
-		cBiomeGen * tmp = *it;
-		tmp->InitializeBiomeGen(a_IniFile);
+		itr->InitializeBiomeGen(a_IniFile);
 	}
 }
 
@@ -760,8 +747,8 @@ void cBioGenTwoLevel::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap
 	int DistortZ[cChunkDef::Width + 1][cChunkDef::Width + 1];
 	for (int x = 0; x <= 4; x++) for (int z = 0; z <= 4; z++)
 	{
-		float BlockX = BaseX + x * 4;
-		float BlockZ = BaseZ + z * 4;
+		float BlockX = static_cast<float>(BaseX + x * 4);
+		float BlockZ = static_cast<float>(BaseZ + z * 4);
 		double NoiseX = m_AmpX1 * m_Noise1.CubicNoise2D(BlockX * m_FreqX1, BlockZ * m_FreqX1);
 		NoiseX       += m_AmpX2 * m_Noise2.CubicNoise2D(BlockX * m_FreqX2, BlockZ * m_FreqX2);
 		NoiseX       += m_AmpX3 * m_Noise3.CubicNoise2D(BlockX * m_FreqX3, BlockZ * m_FreqX3);
@@ -785,7 +772,7 @@ void cBioGenTwoLevel::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap
 			int BiomeGroup = m_VoronoiLarge.GetValueAt(DistortX[x][z], DistortZ[x][z], SeedX, SeedZ, MinDist2) / 7;
 			int BiomeIdx   = m_VoronoiSmall.GetValueAt(DistortX[x][z], DistortZ[x][z], SeedX, SeedZ, MinDist2) / 11;
 			int MinDist1 = (DistortX[x][z] - SeedX) * (DistortX[x][z] - SeedX) + (DistortZ[x][z] - SeedZ) * (DistortZ[x][z] - SeedZ);
-			cChunkDef::SetBiome(a_BiomeMap, x, z, SelectBiome(BiomeGroup, BiomeIdx, (MinDist1 < MinDist2 / 4) ? 0 : 1));
+			cChunkDef::SetBiome(a_BiomeMap, x, z, SelectBiome(BiomeGroup, BiomeIdx, (MinDist1 < MinDist2 / 4) ? 1 : 0));
 		}
 	}
 }
@@ -932,7 +919,7 @@ void cBioGenTwoLevel::InitializeBiomeGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cBiomeGen:
 
-cBiomeGen * cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault)
+cBiomeGenPtr cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault)
 {
 	AString BiomeGenName = a_IniFile.GetValueSet("Generator", "BiomeGen", "");
 	if (BiomeGenName.empty())
@@ -988,7 +975,7 @@ cBiomeGen * cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a
 	}
 	res->InitializeBiomeGen(a_IniFile);
 
-	return res;
+	return cBiomeGenPtr(res);
 }
 
 
diff --git a/src/Generating/BioGen.h b/src/Generating/BioGen.h
index 22ddfae5c..5fd0844d9 100644
--- a/src/Generating/BioGen.h
+++ b/src/Generating/BioGen.h
@@ -48,12 +48,12 @@ class cBioGenCache :
 	typedef cBiomeGen super;
 	
 public:
-	cBioGenCache(cBiomeGen * a_BioGenToCache, int a_CacheSize);  // Doesn't take ownership of a_BioGenToCache
-	~cBioGenCache();
+	cBioGenCache(cBiomeGenPtr a_BioGenToCache, int a_CacheSize);
+	virtual ~cBioGenCache();
 	
 protected:
 
-	cBiomeGen * m_BioGenToCache;
+	cBiomeGenPtr m_BioGenToCache;
 	
 	struct sCacheData
 	{
@@ -87,19 +87,21 @@ class cBioGenMulticache :
 	typedef cBiomeGen super;
 
 public:
-	/*
-	a_CacheSize defines the size of each singular cache
-	a_CachesLength defines how many caches are used for the multicache
-	*/
-	cBioGenMulticache(cBiomeGen * a_BioGenToCache, size_t a_CacheSize, size_t a_CachesLength);  // Doesn't take ownership of a_BioGenToCache
-	~cBioGenMulticache();
+	/* Creates a new multicache - a cache that divides the caching into several sub-caches based on the chunk coords.
+	This allows us to use shorter cache depths with faster lookups for more covered area. (#381)
+	a_SubCacheSize defines the size of each sub-cache
+	a_NumSubCaches defines how many sub-caches are used for the multicache. */
+	cBioGenMulticache(cBiomeGenPtr a_BioGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches);
 
 protected:
-	typedef std::vector<cBiomeGen *> cBiomeGens;
+	typedef std::vector<cBiomeGenPtr> cBiomeGenPtrs;
+
 
+	/** Number of sub-caches. Pulled out of m_Caches.size() for faster access. */
+	size_t m_NumSubCaches;
 
-	size_t     m_CachesLength;
-	cBiomeGens m_Caches;
+	/** Individual sub-caches. */
+	cBiomeGenPtrs m_Caches;
 
 
 	virtual void GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) override;
diff --git a/src/Generating/ChunkDesc.cpp b/src/Generating/ChunkDesc.cpp
index c0b646fd0..566332b1f 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -269,10 +269,10 @@ void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX
 		LOGWARNING("%s: MaxRelX less than zero, adjusting to zero", __FUNCTION__);
 		a_MaxRelX = 0;
 	}
-	else if (a_MaxRelX >= cChunkDef::Width)
+	else if (a_MaxRelX > cChunkDef::Width)
 	{
 		LOGWARNING("%s: MaxRelX more than chunk width, adjusting to chunk width", __FUNCTION__);
-		a_MaxRelX = cChunkDef::Width - 1;
+		a_MaxRelX = cChunkDef::Width;
 	}
 
 	if (a_MinRelY < 0)
@@ -290,10 +290,10 @@ void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX
 		LOGWARNING("%s: MaxRelY less than zero, adjusting to zero", __FUNCTION__);
 		a_MaxRelY = 0;
 	}
-	else if (a_MaxRelY >= cChunkDef::Height)
+	else if (a_MaxRelY > cChunkDef::Height)
 	{
 		LOGWARNING("%s: MaxRelY more than chunk height, adjusting to chunk height", __FUNCTION__);
-		a_MaxRelY = cChunkDef::Height - 1;
+		a_MaxRelY = cChunkDef::Height;
 	}
 
 	if (a_MinRelZ < 0)
@@ -311,10 +311,10 @@ void cChunkDesc::ReadBlockArea(cBlockArea & a_Dest, int a_MinRelX, int a_MaxRelX
 		LOGWARNING("%s: MaxRelZ less than zero, adjusting to zero", __FUNCTION__);
 		a_MaxRelZ = 0;
 	}
-	else if (a_MaxRelZ >= cChunkDef::Width)
+	else if (a_MaxRelZ > cChunkDef::Width)
 	{
 		LOGWARNING("%s: MaxRelZ more than chunk width, adjusting to chunk width", __FUNCTION__);
-		a_MaxRelZ = cChunkDef::Width - 1;
+		a_MaxRelZ = cChunkDef::Width;
 	}
 
 	// Prepare the block area:
diff --git a/src/Generating/CompoGen.cpp b/src/Generating/CompoGen.cpp
index 178673e32..0105fdb70 100644
--- a/src/Generating/CompoGen.cpp
+++ b/src/Generating/CompoGen.cpp
@@ -663,7 +663,7 @@ void cCompoGenNether::InitializeCompoGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cCompoGenCache:
 
-cCompoGenCache::cCompoGenCache(cTerrainCompositionGen & a_Underlying, int a_CacheSize) :
+cCompoGenCache::cCompoGenCache(cTerrainCompositionGenPtr a_Underlying, int a_CacheSize) :
 	m_Underlying(a_Underlying),
 	m_CacheSize(a_CacheSize),
 	m_CacheOrder(new int[a_CacheSize]),
@@ -739,7 +739,7 @@ void cCompoGenCache::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 	
 	// Not in the cache:
 	m_NumMisses++;
-	m_Underlying.ComposeTerrain(a_ChunkDesc);
+	m_Underlying->ComposeTerrain(a_ChunkDesc);
 	
 	// Insert it as the first item in the MRU order:
 	int Idx = m_CacheOrder[m_CacheSize - 1];
@@ -760,7 +760,7 @@ void cCompoGenCache::ComposeTerrain(cChunkDesc & a_ChunkDesc)
 
 void cCompoGenCache::InitializeCompoGen(cIniFile & a_IniFile)
 {
-	m_Underlying.InitializeCompoGen(a_IniFile);
+	m_Underlying->InitializeCompoGen(a_IniFile);
 }
 
 
diff --git a/src/Generating/CompoGen.h b/src/Generating/CompoGen.h
index 096b0fb5a..b145b6ba3 100644
--- a/src/Generating/CompoGen.h
+++ b/src/Generating/CompoGen.h
@@ -144,12 +144,12 @@ protected:
 
 
 
-/// Caches most-recently-used chunk composition of another composition generator. Caches only the types and metas
+/** Caches most-recently-used chunk composition of another composition generator. Caches only the types and metas */
 class cCompoGenCache :
 	public cTerrainCompositionGen
 {
 public:
-	cCompoGenCache(cTerrainCompositionGen & a_Underlying, int a_CacheSize);  // Doesn't take ownership of a_Underlying
+	cCompoGenCache(cTerrainCompositionGenPtr a_Underlying, int a_CacheSize);  // Doesn't take ownership of a_Underlying
 	~cCompoGenCache();
 	
 	// cTerrainCompositionGen override:
@@ -158,7 +158,7 @@ public:
 	
 protected:
 
-	cTerrainCompositionGen & m_Underlying;
+	cTerrainCompositionGenPtr m_Underlying;
 	
 	struct sCacheData
 	{
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index 87461b944..358d97c92 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/src/Generating/ComposableGenerator.cpp
@@ -39,7 +39,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 // cTerrainCompositionGen:
 
-cTerrainCompositionGen * cTerrainCompositionGen::CreateCompositionGen(cIniFile & a_IniFile, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_Seed)
+cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_Seed)
 {
 	AString CompoGenName = a_IniFile.GetValueSet("Generator", "CompositionGen", "");
 	if (CompoGenName.empty())
@@ -107,7 +107,7 @@ cTerrainCompositionGen * cTerrainCompositionGen::CreateCompositionGen(cIniFile &
 	// Read the settings from the ini file:
 	res->InitializeCompoGen(a_IniFile);
 	
-	return res;
+	return cTerrainCompositionGenPtr(res);
 }
 
 
@@ -119,12 +119,9 @@ cTerrainCompositionGen * cTerrainCompositionGen::CreateCompositionGen(cIniFile &
 
 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)
+	m_BiomeGen(nullptr),
+	m_HeightGen(nullptr),
+	m_CompositionGen(nullptr)
 {
 }
 
@@ -132,33 +129,6 @@ cComposableGenerator::cComposableGenerator(cChunkGenerator & a_ChunkGenerator) :
 
 
 
-cComposableGenerator::~cComposableGenerator()
-{
-	// Delete the generating composition:
-	for (cFinishGenList::const_iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)
-	{
-		delete *itr;
-	}
-	m_FinishGens.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(cIniFile & a_IniFile)
 {
 	super::Initialize(a_IniFile);
@@ -245,15 +215,14 @@ void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)
 		CacheSize = 4;
 	}
 	LOGD("Using a cache for biomegen of size %d.", CacheSize);
-	m_UnderlyingBiomeGen = m_BiomeGen;
 	if (MultiCacheLength > 0)
 	{
 		LOGD("Enabling multicache for biomegen of length %d.", MultiCacheLength);
-		m_BiomeGen = new cBioGenMulticache(m_UnderlyingBiomeGen, CacheSize, MultiCacheLength);
+		m_BiomeGen = cBiomeGenPtr(new cBioGenMulticache(m_BiomeGen, CacheSize, MultiCacheLength));
 	}
 	else
 	{
-		m_BiomeGen = new cBioGenCache(m_UnderlyingBiomeGen, CacheSize);
+		m_BiomeGen = cBiomeGenPtr(new cBioGenCache(m_BiomeGen, CacheSize));
 	}
 }
 
@@ -264,7 +233,7 @@ void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)
 void cComposableGenerator::InitHeightGen(cIniFile & a_IniFile)
 {
 	bool CacheOffByDefault = false;
-	m_HeightGen = cTerrainHeightGen::CreateHeightGen(a_IniFile, *m_BiomeGen, m_ChunkGenerator.GetSeed(), CacheOffByDefault);
+	m_HeightGen = cTerrainHeightGen::CreateHeightGen(a_IniFile, m_BiomeGen, m_ChunkGenerator.GetSeed(), CacheOffByDefault);
 	
 	// Add a cache, if requested:
 	int CacheSize = a_IniFile.GetValueSetI("Generator", "HeightGenCacheSize", CacheOffByDefault ? 0 : 64);
@@ -278,8 +247,7 @@ void cComposableGenerator::InitHeightGen(cIniFile & a_IniFile)
 			CacheSize = 4;
 		}
 		LOGD("Using a cache for Heightgen of size %d.", CacheSize);
-		m_UnderlyingHeightGen = m_HeightGen;
-		m_HeightGen = new cHeiGenCache(*m_UnderlyingHeightGen, CacheSize);
+		m_HeightGen = cTerrainHeightGenPtr(new cHeiGenCache(m_HeightGen, CacheSize));
 	}
 }
 
@@ -289,13 +257,12 @@ void cComposableGenerator::InitHeightGen(cIniFile & a_IniFile)
 
 void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
 {
-	m_CompositionGen = cTerrainCompositionGen::CreateCompositionGen(a_IniFile, *m_BiomeGen, *m_HeightGen, m_ChunkGenerator.GetSeed());
+	m_CompositionGen = cTerrainCompositionGen::CreateCompositionGen(a_IniFile, m_BiomeGen, *m_HeightGen, m_ChunkGenerator.GetSeed());
 	
 	int CompoGenCacheSize = a_IniFile.GetValueSetI("Generator", "CompositionGenCacheSize", 64);
 	if (CompoGenCacheSize > 1)
 	{
-		m_UnderlyingCompositionGen = m_CompositionGen;
-		m_CompositionGen = new cCompoGenCache(*m_UnderlyingCompositionGen, 32);
+		m_CompositionGen = cTerrainCompositionGenPtr(new cCompoGenCache(m_CompositionGen, 32));
 	}
 }
 
@@ -319,7 +286,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		{
 			int DefaultBottomLavaLevel = (Dimension == dimNether) ? 30 : 10;
 			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
-			m_FinishGens.push_back(new cFinishGenBottomLava(BottomLavaLevel));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenBottomLava(BottomLavaLevel)));
 		}
 		else if (NoCaseCompare(*itr, "DeadBushes") == 0)
 		{
@@ -341,20 +308,20 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			AllowedBlocks.push_back(E_BLOCK_HARDENED_CLAY);
 			AllowedBlocks.push_back(E_BLOCK_STAINED_CLAY);
 
-			m_FinishGens.push_back(new cFinishGenSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, AllowedBiomes, 2, AllowedBlocks));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, AllowedBiomes, 2, AllowedBlocks)));
 		}
 		else if (NoCaseCompare(*itr, "DirectOverhangs") == 0)
 		{
-			m_FinishGens.push_back(new cStructGenDirectOverhangs(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenDirectOverhangs(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "DistortedMembraneOverhangs") == 0)
 		{
-			m_FinishGens.push_back(new cStructGenDistortedMembraneOverhangs(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenDistortedMembraneOverhangs(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "DualRidgeCaves") == 0)
 		{
 			float Threshold = (float)a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3);
-			m_FinishGens.push_back(new cStructGenDualRidgeCaves(Seed, Threshold));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenDualRidgeCaves(Seed, Threshold)));
 		}
 		else if (NoCaseCompare(*itr, "DungeonRooms") == 0)
 		{
@@ -362,24 +329,24 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			int     MaxSize       = a_IniFile.GetValueSetI("Generator", "DungeonRoomsMaxSize", 7);
 			int     MinSize       = a_IniFile.GetValueSetI("Generator", "DungeonRoomsMinSize", 5);
 			AString HeightDistrib = a_IniFile.GetValueSet ("Generator", "DungeonRoomsHeightDistrib", "0, 0; 10, 10; 11, 500; 40, 500; 60, 40; 90, 1");
-			m_FinishGens.push_back(new cDungeonRoomsFinisher(*m_HeightGen, Seed, GridSize, MaxSize, MinSize, HeightDistrib));
+			m_FinishGens.push_back(cFinishGenPtr(new cDungeonRoomsFinisher(m_HeightGen, Seed, GridSize, MaxSize, MinSize, HeightDistrib)));
 		}
 		else if (NoCaseCompare(*itr, "Ice") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenIce);
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenIce));
 		}
 		else if (NoCaseCompare(*itr, "LavaLakes") == 0)
 		{
 			int Probability = a_IniFile.GetValueSetI("Generator", "LavaLakesProbability", 10);
-			m_FinishGens.push_back(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, *m_HeightGen, Probability));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, m_HeightGen, Probability)));
 		}
 		else if (NoCaseCompare(*itr, "LavaSprings") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, Dimension));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, Dimension)));
 		}
 		else if (NoCaseCompare(*itr, "MarbleCaves") == 0)
 		{
-			m_FinishGens.push_back(new cStructGenMarbleCaves(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenMarbleCaves(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "MineShafts") == 0)
 		{
@@ -389,10 +356,10 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			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_FinishGens.push_back(new cStructGenMineShafts(
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenMineShafts(
 				Seed, GridSize, MaxOffset, MaxSystemSize,
 				ChanceCorridor, ChanceCrossing, ChanceStaircase
-			));
+			)));
 		}
 		else if (NoCaseCompare(*itr, "Lilypads") == 0)
 		{
@@ -406,7 +373,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			AllowedBlocks.push_back(E_BLOCK_WATER);
 			AllowedBlocks.push_back(E_BLOCK_STATIONARY_WATER);
 
-			m_FinishGens.push_back(new cFinishGenSingleTopBlock(Seed, E_BLOCK_LILY_PAD, AllowedBiomes, 4, AllowedBlocks));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSingleTopBlock(Seed, E_BLOCK_LILY_PAD, AllowedBiomes, 4, AllowedBlocks)));
 		}
 		else if (NoCaseCompare(*itr, "NaturalPatches") == 0)
 		{
@@ -455,18 +422,18 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			AndesiteVein.NestSize = 32;
 			Ores.push_back(AndesiteVein);
 
-			m_FinishGens.push_back(new cStructGenOreNests(Seed, Ores, E_BLOCK_STONE));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenOreNests(Seed, Ores, E_BLOCK_STONE)));
 		}
 		else if (NoCaseCompare(*itr, "NetherClumpFoliage") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenNetherClumpFoliage(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenNetherClumpFoliage(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "NetherForts") == 0)
 		{
 			int GridSize  = a_IniFile.GetValueSetI("Generator", "NetherFortsGridSize", 512);
 			int MaxOffset = a_IniFile.GetValueSetI("Generator", "NetherFortMaxOffset", 128);
 			int MaxDepth  = a_IniFile.GetValueSetI("Generator", "NetherFortsMaxDepth", 12);
-			m_FinishGens.push_back(new cNetherFortGen(Seed, GridSize, MaxOffset, MaxDepth));
+			m_FinishGens.push_back(cFinishGenPtr(new cNetherFortGen(Seed, GridSize, MaxOffset, MaxDepth)));
 		}
 		else if (NoCaseCompare(*itr, "NetherOreNests") == 0)
 		{
@@ -480,7 +447,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			QuartzVein.NestSize = 8;
 			Ores.push_back(QuartzVein);
 
-			m_FinishGens.push_back(new cStructGenOreNests(Seed, Ores, E_BLOCK_NETHERRACK));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenOreNests(Seed, Ores, E_BLOCK_NETHERRACK)));
 
 		}
 		else if (NoCaseCompare(*itr, "OreNests") == 0)
@@ -535,11 +502,11 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			DiamondVein.NestSize = 4;
 			Ores.push_back(DiamondVein);
 
-			m_FinishGens.push_back(new cStructGenOreNests(Seed, Ores, E_BLOCK_STONE));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenOreNests(Seed, Ores, E_BLOCK_STONE)));
 		}
 		else if (NoCaseCompare(*itr, "POCPieces") == 0)
 		{
-			m_FinishGens.push_back(new cPOCPieceGenerator(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cPOCPieceGenerator(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "PreSimulator") == 0)
 		{
@@ -548,7 +515,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			bool PreSimulateWater         = a_IniFile.GetValueSetB("Generator", "PreSimulatorWater", true);
 			bool PreSimulateLava          = a_IniFile.GetValueSetB("Generator", "PreSimulatorLava", true);
 
-			m_FinishGens.push_back(new cFinishGenPreSimulator(PreSimulateFallingBlocks, PreSimulateWater, PreSimulateLava));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenPreSimulator(PreSimulateFallingBlocks, PreSimulateWater, PreSimulateLava)));
 		}
 		else if (NoCaseCompare(*itr, "RainbowRoads") == 0)
 		{
@@ -556,11 +523,11 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			int MaxOffset = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxOffset", 128);
 			int MaxDepth  = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxDepth",   30);
 			int MaxSize   = a_IniFile.GetValueSetI("Generator", "RainbowRoadsMaxSize",   260);
-			m_FinishGens.push_back(new cRainbowRoadsGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize));
+			m_FinishGens.push_back(cFinishGenPtr(new cRainbowRoadsGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize)));
 		}
 		else if (NoCaseCompare(*itr, "Ravines") == 0)
 		{
-			m_FinishGens.push_back(new cStructGenRavines(Seed, 128));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenRavines(Seed, 128)));
 		}
 		else if (NoCaseCompare(*itr, "RoughRavines") == 0)
 		{
@@ -580,7 +547,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			double MinCeilingHeightEdge   = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCeilingHeightEdge",   38);
 			double MaxCeilingHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCeilingHeightCenter", 58);
 			double MinCeilingHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCeilingHeightCenter", 36);
-			m_FinishGens.push_back(new cRoughRavines(
+			m_FinishGens.push_back(cFinishGenPtr(new cRoughRavines(
 				Seed, MaxSize, MinSize,
 				(float)MaxCenterWidth,         (float)MinCenterWidth,
 				(float)MaxRoughness,           (float)MinRoughness,
@@ -589,27 +556,27 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 				(float)MaxCeilingHeightEdge,   (float)MinCeilingHeightEdge,
 				(float)MaxCeilingHeightCenter, (float)MinCeilingHeightCenter,
 				GridSize, MaxOffset
-			));
+			)));
 		}
 		else if (NoCaseCompare(*itr, "Snow") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSnow);
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSnow));
 		}
 		else if (NoCaseCompare(*itr, "SprinkleFoliage") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenSprinkleFoliage(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSprinkleFoliage(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "TallGrass") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenTallGrass(Seed));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenTallGrass(Seed)));
 		}
 		else if (NoCaseCompare(*itr, "TestRails") == 0)
 		{
-			m_FinishGens.push_back(new cTestRailsGen(Seed, 100, 1, 7, 50));
+			m_FinishGens.push_back(cFinishGenPtr(new cTestRailsGen(Seed, 100, 1, 7, 50)));
 		}
 		else if (NoCaseCompare(*itr, "Trees") == 0)
 		{
-			m_FinishGens.push_back(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenTrees(Seed, m_BiomeGen, m_HeightGen, m_CompositionGen)));
 		}
 		else if (NoCaseCompare(*itr, "UnderwaterBases") == 0)
 		{
@@ -617,7 +584,7 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			int MaxOffset = a_IniFile.GetValueSetI("Generator", "UnderwaterBaseMaxOffset", 128);
 			int MaxDepth  = a_IniFile.GetValueSetI("Generator", "UnderwaterBaseMaxDepth",    7);
 			int MaxSize   = a_IniFile.GetValueSetI("Generator", "UnderwaterBaseMaxSize",   128);
-			m_FinishGens.push_back(new cUnderwaterBaseGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize, *m_BiomeGen));
+			m_FinishGens.push_back(cFinishGenPtr(new cUnderwaterBaseGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize, m_BiomeGen)));
 		}
 		else if (NoCaseCompare(*itr, "Villages") == 0)
 		{
@@ -627,23 +594,23 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			int MaxSize    = a_IniFile.GetValueSetI("Generator", "VillageMaxSize",   128);
 			int MinDensity = a_IniFile.GetValueSetI("Generator", "VillageMinDensity", 50);
 			int MaxDensity = a_IniFile.GetValueSetI("Generator", "VillageMaxDensity", 80);
-			m_FinishGens.push_back(new cVillageGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize, MinDensity, MaxDensity, *m_BiomeGen, *m_HeightGen));
+			m_FinishGens.push_back(cFinishGenPtr(new cVillageGen(Seed, GridSize, MaxOffset, MaxDepth, MaxSize, MinDensity, MaxDensity, m_BiomeGen, m_HeightGen)));
 		}
 		else if (NoCaseCompare(*itr, "WaterLakes") == 0)
 		{
 			int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);
-			m_FinishGens.push_back(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, *m_HeightGen, Probability));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, m_HeightGen, Probability)));
 		}
 		else if (NoCaseCompare(*itr, "WaterSprings") == 0)
 		{
-			m_FinishGens.push_back(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, Dimension));
+			m_FinishGens.push_back(cFinishGenPtr(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, Dimension)));
 		}
 		else if (NoCaseCompare(*itr, "WormNestCaves") == 0)
 		{
 			int Size      = a_IniFile.GetValueSetI("Generator", "WormNestCavesSize", 64);
 			int Grid      = a_IniFile.GetValueSetI("Generator", "WormNestCavesGrid", 96);
 			int MaxOffset = a_IniFile.GetValueSetI("Generator", "WormNestMaxOffset", 32);
-			m_FinishGens.push_back(new cStructGenWormNestCaves(Seed, Size, Grid, MaxOffset));
+			m_FinishGens.push_back(cFinishGenPtr(new cStructGenWormNestCaves(Seed, Size, Grid, MaxOffset)));
 		}
 		else
 		{
diff --git a/src/Generating/ComposableGenerator.h b/src/Generating/ComposableGenerator.h
index 6b7627d2e..a091f8d53 100644
--- a/src/Generating/ComposableGenerator.h
+++ b/src/Generating/ComposableGenerator.h
@@ -24,6 +24,16 @@ See http://forum.mc-server.org/showthread.php?tid=409 for details.
 
 
 
+// Forward-declare the shared pointers to subgenerator classes:
+class cBiomeGen;
+class cTerrainHeightGen;
+class cTerrainCompositionGen;
+class cFinishGen;
+typedef SharedPtr<cBiomeGen>              cBiomeGenPtr;
+typedef SharedPtr<cTerrainHeightGen>      cTerrainHeightGenPtr;
+typedef SharedPtr<cTerrainCompositionGen> cTerrainCompositionGenPtr;
+typedef SharedPtr<cFinishGen>             cFinishGenPtr;
+
 // fwd: Noise3DGenerator.h
 class cNoise3DComposable;
 
@@ -53,8 +63,7 @@ public:
 	a_CacheOffByDefault gets set to whether the cache should be disabled by default.
 	Used in BiomeVisualiser, too.
 	Implemented in BioGen.cpp! */
-	static cBiomeGen * CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault);
-
+	static cBiomeGenPtr CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault);
 } ;
 
 
@@ -83,7 +92,7 @@ public:
 	a_CacheOffByDefault gets set to whether the cache should be disabled by default
 	Implemented in HeiGen.cpp!
 	*/
-	static cTerrainHeightGen * CreateHeightGen(cIniFile & a_IniFile, cBiomeGen & a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault);
+	static cTerrainHeightGenPtr CreateHeightGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault);
 } ;
 
 
@@ -109,7 +118,7 @@ public:
 	a_BiomeGen is the underlying biome generator, some composition generators may depend on it to generate more biomes
 	a_HeightGen is the underlying height generator, some composition generators may depend on it providing additional values
 	*/
-	static cTerrainCompositionGen * CreateCompositionGen(cIniFile & a_IniFile, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_Seed);
+	static cTerrainCompositionGenPtr CreateCompositionGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_Seed);
 } ;
 
 
@@ -131,7 +140,7 @@ public:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) = 0;
 } ;
 
-typedef std::list<cFinishGen *> cFinishGenList;
+typedef std::list<cFinishGenPtr> cFinishGenList;
 
 
 
@@ -144,7 +153,6 @@ class cComposableGenerator :
 	
 public:
 	cComposableGenerator(cChunkGenerator & a_ChunkGenerator);
-	virtual ~cComposableGenerator();
 	
 	virtual void Initialize(cIniFile & a_IniFile) override;
 	virtual void GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap) override;
@@ -152,15 +160,10 @@ public:
 
 protected:
 	// The generation composition:
-	cBiomeGen *              m_BiomeGen;
-	cTerrainHeightGen *      m_HeightGen;
-	cTerrainCompositionGen * m_CompositionGen;
-	cFinishGenList           m_FinishGens;
-	
-	// Generators underlying the caches:
-	cBiomeGen *              m_UnderlyingBiomeGen;
-	cTerrainHeightGen *      m_UnderlyingHeightGen;
-	cTerrainCompositionGen * m_UnderlyingCompositionGen;
+	cBiomeGenPtr              m_BiomeGen;
+	cTerrainHeightGenPtr      m_HeightGen;
+	cTerrainCompositionGenPtr m_CompositionGen;
+	cFinishGenList            m_FinishGens;
 	
 	
 	/** Reads the biome gen settings from the ini and initializes m_BiomeGen accordingly */
diff --git a/src/Generating/DistortedHeightmap.cpp b/src/Generating/DistortedHeightmap.cpp
index c18c402da..e6849fadf 100644
--- a/src/Generating/DistortedHeightmap.cpp
+++ b/src/Generating/DistortedHeightmap.cpp
@@ -276,13 +276,13 @@ const cDistortedHeightmap::sGenParam cDistortedHeightmap::m_GenParam[256] =
 
 
 
-cDistortedHeightmap::cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen) :
+cDistortedHeightmap::cDistortedHeightmap(int a_Seed, cBiomeGenPtr a_BiomeGen) :
 	m_NoiseDistortX(a_Seed + 1000),
 	m_NoiseDistortZ(a_Seed + 2000),
 	m_OceanFloorSelect(a_Seed + 3000),
 	m_MesaFloor(a_Seed + 4000),
 	m_BiomeGen(a_BiomeGen),
-	m_UnderlyingHeiGen(a_Seed, a_BiomeGen),
+	m_UnderlyingHeiGen(new cHeiGenBiomal(a_Seed, a_BiomeGen)),
 	m_HeightGen(m_UnderlyingHeiGen, 64),
 	m_IsInitialized(false)
 {
@@ -540,10 +540,11 @@ void cDistortedHeightmap::InitializeCompoGen(cIniFile & a_IniFile)
 
 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);
+	int RelX = (int)std::floor(a_X);
+	int RelY = 0;
+	int RelZ = (int)std::floor(a_Z);
+	int ChunkX, ChunkZ;
+	cChunkDef::AbsoluteToRelative(RelX, RelY, RelZ, ChunkX, ChunkZ);
 
 	// If we're withing the same chunk, return the pre-cached heightmap:
 	if ((ChunkX == m_CurChunkX) && (ChunkZ == m_CurChunkZ))
@@ -576,7 +577,7 @@ void cDistortedHeightmap::UpdateDistortAmps(void)
 	{
 		for (int x = -1; x <= 1; x++)
 		{
-			m_BiomeGen.GenBiomes(m_CurChunkX + x, m_CurChunkZ + z, Biomes[x + 1][z + 1]);
+			m_BiomeGen->GenBiomes(m_CurChunkX + x, m_CurChunkZ + z, Biomes[x + 1][z + 1]);
 		}  // for x
 	}  // for z
 
diff --git a/src/Generating/DistortedHeightmap.h b/src/Generating/DistortedHeightmap.h
index e6b3c9d3f..d073f29e4 100644
--- a/src/Generating/DistortedHeightmap.h
+++ b/src/Generating/DistortedHeightmap.h
@@ -35,7 +35,7 @@ public:
 		NIBBLETYPE BlockMeta;
 	} ;
 
-	cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen);
+	cDistortedHeightmap(int a_Seed, cBiomeGenPtr a_BiomeGen);
 	
 protected:
 	typedef cChunkDef::BiomeMap BiomeNeighbors[3][3];
@@ -64,9 +64,14 @@ protected:
 	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
+	/** The bime generator to query for biomes. */
+	cBiomeGenPtr m_BiomeGen;
+
+	/** The generator that provides the base heightmap (before distortion). */
+	cTerrainHeightGenPtr m_UnderlyingHeiGen;
+
+	/** Cache for m_UnderlyingHeiGen. */
+	cHeiGenCache  m_HeightGen;
 	
 	/// Heightmap for the current chunk, before distortion (from m_HeightGen). Used for optimization.
 	cChunkDef::HeightMap m_CurChunkHeights;
diff --git a/src/Generating/DungeonRoomsFinisher.cpp b/src/Generating/DungeonRoomsFinisher.cpp
index f213455d6..93fe8b472 100644
--- a/src/Generating/DungeonRoomsFinisher.cpp
+++ b/src/Generating/DungeonRoomsFinisher.cpp
@@ -6,6 +6,7 @@
 #include "Globals.h"
 #include "DungeonRoomsFinisher.h"
 #include "../FastRandom.h"
+#include "../BlockEntities/ChestEntity.h"
 
 
 
@@ -175,7 +176,33 @@ protected:
 		}
 		a_ChunkDesc.SetBlockTypeMeta(RelX, m_FloorHeight + 1, RelZ, E_BLOCK_CHEST, (NIBBLETYPE)a_Chest.y);
 
-		// TODO: Fill the chest with random loot
+		// Fill the chest with random loot
+		static const cLootProbab LootProbab[] =
+		{
+			// Item,                          MinAmount, MaxAmount, Weight
+			{ cItem(E_ITEM_GOLDEN_APPLE),        1,         1,         1 },
+			{ cItem(E_ITEM_DIAMOND_HORSE_ARMOR), 1,         1,         1 },
+			{ cItem(E_ITEM_GOLD_HORSE_ARMOR),    1,         1,         2 },
+			{ cItem(E_ITEM_13_DISC),             1,         1,         4 },
+			{ cItem(E_ITEM_CAT_DISC),            1,         1,         4 },
+			{ cItem(E_ITEM_IRON_HORSE_ARMOR),    1,         1,         5 },
+			{ cItem(E_ITEM_IRON),                1,         4,        10 },
+			{ cItem(E_ITEM_WHEAT),               1,         4,        10 },
+			{ cItem(E_ITEM_GUNPOWDER),           1,         4,        10 },
+			{ cItem(E_ITEM_STRING),              1,         4,        10 },
+			{ cItem(E_ITEM_REDSTONE_DUST),       1,         4,        10 },
+			{ cItem(E_ITEM_SADDLE),              1,         1,        10 },
+			{ cItem(E_ITEM_BUCKET),              1,         1,        10 },
+			{ cItem(E_ITEM_BREAD),               1,         1,        10 },
+			{ cItem(E_ITEM_NAME_TAG),            1,         1,        10 },
+		} ;
+
+		cChestEntity * ChestEntity = (cChestEntity *)a_ChunkDesc.GetBlockEntity(RelX, m_FloorHeight + 1, RelZ);
+		ASSERT((ChestEntity != NULL) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
+		cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
+		int NumSlots = 3 + ((Noise.IntNoise3DInt(a_Chest.x, a_Chest.y, a_Chest.z) / 11) % 4);
+		int Seed = Noise.IntNoise2DInt(RelX, RelZ);
+		ChestEntity->GetContents().GenerateRandomLootWithBooks(LootProbab, ARRAYCOUNT(LootProbab), NumSlots, Seed);
 	}
 
 
@@ -193,6 +220,7 @@ protected:
 			// The chunk is not intersecting the room at all, bail out
 			return;
 		}
+
 		int b = m_FloorHeight + 1;  // Bottom
 		int t = m_FloorHeight + 1 + ROOM_HEIGHT;  // Top
 		ReplaceCuboidRandom(a_ChunkDesc, m_StartX, m_FloorHeight, m_StartZ, m_EndX + 1, b, m_EndZ + 1, E_BLOCK_MOSSY_COBBLESTONE, E_BLOCK_COBBLESTONE);  // Floor
@@ -230,7 +258,7 @@ protected:
 ////////////////////////////////////////////////////////////////////////////////
 // cDungeonRoomsFinisher:
 
-cDungeonRoomsFinisher::cDungeonRoomsFinisher(cTerrainHeightGen & a_HeightGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib) :
+cDungeonRoomsFinisher::cDungeonRoomsFinisher(cTerrainHeightGenPtr a_HeightGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib) :
 	super(a_Seed + 100, a_GridSize, a_GridSize, a_GridSize, a_GridSize, a_MaxSize, a_MaxSize, 1024),
 	m_HeightGen(a_HeightGen),
 	m_MaxHalfSize((a_MaxSize + 1) / 2),
@@ -266,7 +294,7 @@ cDungeonRoomsFinisher::cStructurePtr cDungeonRoomsFinisher::CreateStructure(int
 	int RelX = a_OriginX, RelY = 0, RelZ = a_OriginZ;
 	cChunkDef::AbsoluteToRelative(RelX, RelY, RelZ, ChunkX, ChunkZ);
 	cChunkDef::HeightMap HeightMap;
-	m_HeightGen.GenHeightMap(ChunkX, ChunkZ, HeightMap);
+	m_HeightGen->GenHeightMap(ChunkX, ChunkZ, HeightMap);
 	int Height = cChunkDef::GetHeight(HeightMap, RelX, RelZ);  // Max room height at {a_OriginX, a_OriginZ}
 	Height = Clamp(m_HeightProbability.MapValue(rnd % m_HeightProbability.GetSum()), 10, Height - 5);
 
diff --git a/src/Generating/DungeonRoomsFinisher.h b/src/Generating/DungeonRoomsFinisher.h
index 2b52c9de6..09dd0448a 100644
--- a/src/Generating/DungeonRoomsFinisher.h
+++ b/src/Generating/DungeonRoomsFinisher.h
@@ -26,12 +26,12 @@ public:
 	a_HeightGen is the underlying height generator, so that the rooms can always be placed under the terrain.
 	a_MaxSize and a_MinSize are the maximum and minimum sizes of the room's internal (air) area, in blocks across.
 	a_HeightDistrib is the string defining the height distribution for the rooms (cProbabDistrib format). */
-	cDungeonRoomsFinisher(cTerrainHeightGen & a_HeightGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib);
+	cDungeonRoomsFinisher(cTerrainHeightGenPtr a_HeightGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib);
 
 protected:
 
 	/** The height gen that is used for limiting the rooms' Y coords */
-	cTerrainHeightGen & m_HeightGen;
+	cTerrainHeightGenPtr m_HeightGen;
 
 	/** Maximum half-size (from center to wall) of the dungeon room's inner (air) area. Default is 3 (vanilla). */
 	int m_MaxHalfSize;
diff --git a/src/Generating/HeiGen.cpp b/src/Generating/HeiGen.cpp
index 79d529a6a..b7d4b337c 100644
--- a/src/Generating/HeiGen.cpp
+++ b/src/Generating/HeiGen.cpp
@@ -19,7 +19,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 // cTerrainHeightGen:
 
-cTerrainHeightGen * cTerrainHeightGen::CreateHeightGen(cIniFile &a_IniFile, cBiomeGen & a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault)
+cTerrainHeightGenPtr cTerrainHeightGen::CreateHeightGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault)
 {
 	AString HeightGenName = a_IniFile.GetValueSet("Generator", "HeightGen", "");
 	if (HeightGenName.empty())
@@ -84,7 +84,7 @@ cTerrainHeightGen * cTerrainHeightGen::CreateHeightGen(cIniFile &a_IniFile, cBio
 	// Read the settings:
 	res->InitializeHeightGen(a_IniFile);
 	
-	return res;
+	return cTerrainHeightGenPtr(res);
 }
 
 
@@ -118,7 +118,7 @@ void cHeiGenFlat::InitializeHeightGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cHeiGenCache:
 
-cHeiGenCache::cHeiGenCache(cTerrainHeightGen & a_HeiGenToCache, int a_CacheSize) :
+cHeiGenCache::cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, int a_CacheSize) :
 	m_HeiGenToCache(a_HeiGenToCache),
 	m_CacheSize(a_CacheSize),
 	m_CacheOrder(new int[a_CacheSize]),
@@ -190,7 +190,7 @@ void cHeiGenCache::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap
 	
 	// Not in the cache:
 	m_NumMisses++;
-	m_HeiGenToCache.GenHeightMap(a_ChunkX, a_ChunkZ, a_HeightMap);
+	m_HeiGenToCache->GenHeightMap(a_ChunkX, a_ChunkZ, a_HeightMap);
 	
 	// Insert it as the first item in the MRU order:
 	int Idx = m_CacheOrder[m_CacheSize - 1];
@@ -210,7 +210,7 @@ void cHeiGenCache::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap
 
 void cHeiGenCache::InitializeHeightGen(cIniFile & a_IniFile)
 {
-	m_HeiGenToCache.InitializeHeightGen(a_IniFile);
+	m_HeiGenToCache->InitializeHeightGen(a_IniFile);
 }
 
 
@@ -317,7 +317,9 @@ void cHeiGenClassic::InitializeHeightGen(cIniFile & a_IniFile)
 
 cHeiGenMountains::cHeiGenMountains(int a_Seed) :
 	m_Seed(a_Seed),
-	m_Noise(a_Seed)
+	m_MountainNoise(a_Seed + 100),
+	m_DitchNoise(a_Seed + 200),
+	m_Perlin(a_Seed + 300)
 {
 }
 
@@ -332,9 +334,11 @@ void cHeiGenMountains::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::Heigh
 	NOISE_DATATYPE StartZ = (NOISE_DATATYPE)(a_ChunkZ * cChunkDef::Width);
 	NOISE_DATATYPE EndZ   = (NOISE_DATATYPE)(a_ChunkZ * cChunkDef::Width + cChunkDef::Width - 1);
 	NOISE_DATATYPE Workspace[16 * 16];
-	NOISE_DATATYPE Noise[16 * 16];
+	NOISE_DATATYPE MountainNoise[16 * 16];
+	NOISE_DATATYPE DitchNoise[16 * 16];
 	NOISE_DATATYPE PerlinNoise[16 * 16];
-	m_Noise.Generate2D(Noise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
+	m_MountainNoise.Generate2D(MountainNoise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
+	m_DitchNoise.Generate2D(DitchNoise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
 	m_Perlin.Generate2D(PerlinNoise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
 	for (int z = 0; z < cChunkDef::Width; z++)
 	{
@@ -342,7 +346,7 @@ void cHeiGenMountains::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::Heigh
 		for (int x = 0; x < cChunkDef::Width; x++)
 		{
 			int idx = IdxZ + x;
-			int hei = 100 - (int)((Noise[idx] + PerlinNoise[idx]) * 15);
+			int hei = 100 - (int)((MountainNoise[idx] - DitchNoise[idx] + PerlinNoise[idx]) * 15);
 			if (hei < 10)
 			{
 				hei = 10;
@@ -363,9 +367,12 @@ void cHeiGenMountains::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::Heigh
 void cHeiGenMountains::InitializeHeightGen(cIniFile & a_IniFile)
 {
 	// TODO: Read the params from an INI file
-	m_Noise.AddOctave(0.1f,  0.1f);
-	m_Noise.AddOctave(0.05f, 0.5f);
-	m_Noise.AddOctave(0.02f, 1.5f);
+	m_MountainNoise.AddOctave(0.1f,  0.2f);
+	m_MountainNoise.AddOctave(0.05f, 0.4f);
+	m_MountainNoise.AddOctave(0.02f, 1.0f);
+	m_DitchNoise.AddOctave(0.1f,  0.2f);
+	m_DitchNoise.AddOctave(0.05f, 0.4f);
+	m_DitchNoise.AddOctave(0.02f, 1.0f);
 
 	m_Perlin.AddOctave(0.01f, 1.5f);
 }
@@ -479,7 +486,7 @@ void cHeiGenBiomal::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMa
 	{
 		for (int x = -1; x <= 1; x++)
 		{
-			m_BiomeGen.GenBiomes(a_ChunkX + x, a_ChunkZ + z, Biomes[x + 1][z + 1]);
+			m_BiomeGen->GenBiomes(a_ChunkX + x, a_ChunkZ + z, Biomes[x + 1][z + 1]);
 		}  // for x
 	}  // for z
 	
diff --git a/src/Generating/HeiGen.h b/src/Generating/HeiGen.h
index 5c106c7d9..6ae5ba362 100644
--- a/src/Generating/HeiGen.h
+++ b/src/Generating/HeiGen.h
@@ -45,7 +45,7 @@ class cHeiGenCache :
 	public cTerrainHeightGen
 {
 public:
-	cHeiGenCache(cTerrainHeightGen & a_HeiGenToCache, int a_CacheSize);  // Doesn't take ownership of a_HeiGenToCache
+	cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, int a_CacheSize);
 	~cHeiGenCache();
 	
 	// cTerrainHeightGen overrides:
@@ -57,7 +57,7 @@ public:
 	
 protected:
 
-	cTerrainHeightGen & m_HeiGenToCache;
+	cTerrainHeightGenPtr m_HeiGenToCache;
 	
 	struct sCacheData
 	{
@@ -115,7 +115,8 @@ public:
 protected:
 
 	int m_Seed;
-	cRidgedMultiNoise m_Noise;
+	cRidgedMultiNoise m_MountainNoise;
+	cRidgedMultiNoise m_DitchNoise;
 	cPerlinNoise m_Perlin;
 	
 	// cTerrainHeightGen overrides:
@@ -131,7 +132,7 @@ class cHeiGenBiomal :
 	public cTerrainHeightGen
 {
 public:
-	cHeiGenBiomal(int a_Seed, cBiomeGen & a_BiomeGen) :
+	cHeiGenBiomal(int a_Seed, cBiomeGenPtr a_BiomeGen) :
 		m_Noise(a_Seed),
 		m_BiomeGen(a_BiomeGen)
 	{
@@ -141,8 +142,8 @@ protected:
 
 	typedef cChunkDef::BiomeMap BiomeNeighbors[3][3];
 
-	cNoise      m_Noise;
-	cBiomeGen & m_BiomeGen;
+	cNoise       m_Noise;
+	cBiomeGenPtr m_BiomeGen;
 	
 	// Per-biome terrain generator parameters:
 	struct sGenParam
diff --git a/src/Generating/StructGen.cpp b/src/Generating/StructGen.cpp
index c23a72621..bdefcd8c1 100644
--- a/src/Generating/StructGen.cpp
+++ b/src/Generating/StructGen.cpp
@@ -411,7 +411,7 @@ void cStructGenLakes::CreateLakeImage(int a_ChunkX, int a_ChunkZ, cBlockArea & a
 	
 	// Find the minimum height in this chunk:
 	cChunkDef::HeightMap HeightMap;
-	m_HeiGen.GenHeightMap(a_ChunkX, a_ChunkZ, HeightMap);
+	m_HeiGen->GenHeightMap(a_ChunkX, a_ChunkZ, HeightMap);
 	HEIGHTTYPE MinHeight = HeightMap[0];
 	for (size_t i = 1; i < ARRAYCOUNT(HeightMap); i++)
 	{
diff --git a/src/Generating/StructGen.h b/src/Generating/StructGen.h
index 96aa3e437..906fdd722 100644
--- a/src/Generating/StructGen.h
+++ b/src/Generating/StructGen.h
@@ -24,7 +24,7 @@ class cStructGenTrees :
 	public cFinishGen
 {
 public:
-	cStructGenTrees(int a_Seed, cBiomeGen * a_BiomeGen, cTerrainHeightGen * a_HeightGen, cTerrainCompositionGen * a_CompositionGen) :
+	cStructGenTrees(int a_Seed, cBiomeGenPtr a_BiomeGen, cTerrainHeightGenPtr a_HeightGen, cTerrainCompositionGenPtr a_CompositionGen) :
 		m_Seed(a_Seed),
 		m_Noise(a_Seed),
 		m_BiomeGen(a_BiomeGen),
@@ -36,9 +36,9 @@ protected:
 
 	int m_Seed;
 	cNoise m_Noise;
-	cBiomeGen *              m_BiomeGen;
-	cTerrainHeightGen *      m_HeightGen;
-	cTerrainCompositionGen * m_CompositionGen;
+	cBiomeGenPtr              m_BiomeGen;
+	cTerrainHeightGenPtr      m_HeightGen;
+	cTerrainCompositionGenPtr m_CompositionGen;
 	
 	/** Generates and applies an image of a single tree.
 	Parts of the tree inside the chunk are applied to a_BlockX.
@@ -124,7 +124,7 @@ class cStructGenLakes :
 	public cFinishGen
 {
 public:
-	cStructGenLakes(int a_Seed, BLOCKTYPE a_Fluid, cTerrainHeightGen & a_HeiGen, int a_Probability) :
+	cStructGenLakes(int a_Seed, BLOCKTYPE a_Fluid, cTerrainHeightGenPtr a_HeiGen, int a_Probability) :
 		m_Noise(a_Seed),
 		m_Seed(a_Seed),
 		m_Fluid(a_Fluid),
@@ -134,11 +134,11 @@ public:
 	}
 	
 protected:
-	cNoise              m_Noise;
-	int                 m_Seed;
-	BLOCKTYPE           m_Fluid;
-	cTerrainHeightGen & m_HeiGen;
-	int                 m_Probability;  ///< Chance, 0 .. 100, of a chunk having the lake
+	cNoise               m_Noise;
+	int                  m_Seed;
+	BLOCKTYPE            m_Fluid;
+	cTerrainHeightGenPtr m_HeiGen;
+	int                  m_Probability;  ///< Chance, 0 .. 100, of a chunk having the lake
 	
 	// cFinishGen override:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
diff --git a/src/Generating/Trees.cpp b/src/Generating/Trees.cpp
index 1b0f2dc14..7fd6d6f07 100644
--- a/src/Generating/Trees.cpp
+++ b/src/Generating/Trees.cpp
@@ -224,8 +224,6 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 		case biMegaTaiga:
 		case biMegaTaigaHills:
 		case biExtremeHillsPlus:
-		case biSavanna:
-		case biSavannaPlateau:
 		case biMesa:
 		case biMesaPlateauF:
 		case biMesaPlateau:
@@ -241,8 +239,6 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 		case biMegaSpruceTaiga:
 		case biMegaSpruceTaigaHills:
 		case biExtremeHillsPlusM:
-		case biSavannaM:
-		case biSavannaPlateauM:
 		case biMesaBryce:
 		case biMesaPlateauFM:
 		case biMesaPlateauM:
@@ -252,6 +248,15 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 			return;
 		}
 
+		case biSavanna:
+		case biSavannaPlateau:
+		case biSavannaM:
+		case biSavannaPlateauM:
+		{
+			GetAcaciaTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
+			return;
+		}
+
 		case biRoofedForest:
 		case biRoofedForestM:
 		{
@@ -403,7 +408,72 @@ void GetBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Nois
 
 void GetAcaciaTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
 {
-	// TODO
+	// Calculate a base height
+	int Height = 2 + (a_Noise.IntNoise3DInt(a_BlockX, a_BlockY, a_BlockZ) / 11 % 3);
+	
+	// Create the trunk
+	for (int i = 0; i < Height; i++)
+	{
+		a_LogBlocks.push_back(sSetBlock(a_BlockX, a_BlockY + i, a_BlockZ, E_BLOCK_NEW_LOG, E_META_NEW_LOG_ACACIA_WOOD));
+	}
+
+	// Array with possible directions for a branch to go to.
+	const Vector3i AvailableDirections[] =
+	{
+		{ -1, 1, 0 }, { 0, 1, -1 },
+		{ -1, 1, 1 }, { -1, 1, -1 },
+		{ 1, 1, 1 }, { 1, 1, -1 },
+		{ 1, 1, 0 }, { 0, 1, 1 },
+	};
+
+	// Set the starting point of the branch
+	Vector3i BranchPos = Vector3i(a_BlockX, a_BlockY + Height - 1, a_BlockZ);
+
+	// Get a direction for the trunk to go to.
+	Vector3i BranchDirection = AvailableDirections[a_Noise.IntNoise3DInt(a_BlockX, a_BlockY, a_BlockZ) % 8];
+
+	// Calculate a height for the branch between 1 and 3
+	int BranchHeight = a_Noise.IntNoise3DInt(a_BlockX, a_BlockY, a_BlockZ) % 3 + 1;
+
+	// Place the logs of the branch.
+	for (int i = 0; i < BranchHeight; i++)
+	{
+		BranchPos = BranchPos + BranchDirection;
+		a_LogBlocks.push_back(sSetBlock(BranchPos.x, BranchPos.y, BranchPos.z, E_BLOCK_NEW_LOG, E_META_NEW_LOG_ACACIA_WOOD));
+	}
+
+	// Add the leaves to the top of the branch
+	PushCoordBlocks(BranchPos.x, BranchPos.y, BranchPos.z, a_OtherBlocks, BigO2, ARRAYCOUNT(BigO2), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_ACACIA_WOOD);
+	PushCoordBlocks(BranchPos.x, BranchPos.y + 1, BranchPos.z, a_OtherBlocks, BigO1, ARRAYCOUNT(BigO1), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_ACACIA_WOOD);
+	a_OtherBlocks.push_back(sSetBlock(BranchPos.x, BranchPos.y + 1, BranchPos.z, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_ACACIA_WOOD));
+
+	// Choose if we have to add another branch
+	bool TwoTop = (a_Noise.IntNoise3D(a_BlockX, a_BlockY, a_BlockZ) < 0 ? true : false);
+	if (!TwoTop)
+	{
+		return;
+	}
+
+	// Reset the starting point of the branch
+	BranchPos = Vector3i(a_BlockX, a_BlockY + Height - 1, a_BlockZ);
+
+	// Invert the direction of the previous branch.
+	BranchDirection = Vector3d(-BranchDirection.x, 1, -BranchDirection.z);
+
+	// Calculate a new height for the second branch
+	BranchHeight = a_Noise.IntNoise3DInt(a_BlockX * a_Seq, a_BlockY * a_Seq * 10, a_BlockZ * a_Seq) % 3 + 1;
+
+	// Place the logs in the same way as the first branch
+	for (int i = 0; i < BranchHeight; i++)
+	{
+		BranchPos = BranchPos + BranchDirection;
+		a_LogBlocks.push_back(sSetBlock(BranchPos.x, BranchPos.y, BranchPos.z, E_BLOCK_NEW_LOG, E_META_NEW_LOG_ACACIA_WOOD));
+	}
+
+	// And add the leaves ontop of the second branch
+	PushCoordBlocks(BranchPos.x, BranchPos.y, BranchPos.z, a_OtherBlocks, BigO2, ARRAYCOUNT(BigO2), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_ACACIA_WOOD);
+	PushCoordBlocks(BranchPos.x, BranchPos.y + 1, BranchPos.z, a_OtherBlocks, BigO1, ARRAYCOUNT(BigO1), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_ACACIA_WOOD);
+	a_OtherBlocks.push_back(sSetBlock(BranchPos.x, BranchPos.y + 1, BranchPos.z, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_ACACIA_WOOD));
 }
 
 
diff --git a/src/Generating/UnderwaterBaseGen.cpp b/src/Generating/UnderwaterBaseGen.cpp
index 9278ea546..8916f4b5f 100644
--- a/src/Generating/UnderwaterBaseGen.cpp
+++ b/src/Generating/UnderwaterBaseGen.cpp
@@ -93,7 +93,7 @@ protected:
 
 
 
-cUnderwaterBaseGen::cUnderwaterBaseGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, cBiomeGen & a_BiomeGen) :
+cUnderwaterBaseGen::cUnderwaterBaseGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, cBiomeGenPtr a_BiomeGen) :
 	super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 100),
 	m_Noise(a_Seed + 1000),
 	m_MaxDepth(a_MaxDepth),
@@ -112,7 +112,7 @@ cGridStructGen::cStructurePtr cUnderwaterBaseGen::CreateStructure(int a_GridX, i
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_OriginX, a_OriginZ, ChunkX, ChunkZ);
 	cChunkDef::BiomeMap Biomes;
-	m_BiomeGen.GenBiomes(ChunkX, ChunkZ, Biomes);
+	m_BiomeGen->GenBiomes(ChunkX, ChunkZ, Biomes);
 
 	// Check if all the biomes are ocean:
 	// If just one is not, no base is created, because it's likely that an unfriendly biome is too close
diff --git a/src/Generating/UnderwaterBaseGen.h b/src/Generating/UnderwaterBaseGen.h
index d6267b602..b24eb1075 100644
--- a/src/Generating/UnderwaterBaseGen.h
+++ b/src/Generating/UnderwaterBaseGen.h
@@ -22,7 +22,7 @@ class cUnderwaterBaseGen :
 	typedef cGridStructGen super;
 	
 public:
-	cUnderwaterBaseGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, cBiomeGen & a_BiomeGen);
+	cUnderwaterBaseGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, cBiomeGenPtr a_BiomeGen);
 
 protected:
 	class cUnderwaterBase;  // fwd: UnderwaterBaseGen.cpp
@@ -38,7 +38,7 @@ protected:
 	int m_MaxSize;
 	
 	/** The underlying biome generator that defines whether the base is created or not */
-	cBiomeGen & m_BiomeGen;
+	cBiomeGenPtr m_BiomeGen;
 
 
 	// cGridStructGen overrides:
diff --git a/src/Generating/VillageGen.cpp b/src/Generating/VillageGen.cpp
index a7f66b75e..1806fd427 100644
--- a/src/Generating/VillageGen.cpp
+++ b/src/Generating/VillageGen.cpp
@@ -116,7 +116,7 @@ public:
 		int a_MaxSize,
 		int a_Density,
 		cPiecePool & a_Prefabs,
-		cTerrainHeightGen & a_HeightGen,
+		cTerrainHeightGenPtr a_HeightGen,
 		BLOCKTYPE a_RoadBlock,
 		BLOCKTYPE a_WaterRoadBlock
 	) :
@@ -175,7 +175,7 @@ protected:
 	cPiecePool & m_Prefabs;
 	
 	/** The underlying height generator, used for placing the structures on top of the terrain. */
-	cTerrainHeightGen & m_HeightGen;
+	cTerrainHeightGenPtr m_HeightGen;
 	
 	/** The village pieces, placed by the generator. */
 	cPlacedPieces m_Pieces;
@@ -194,7 +194,7 @@ protected:
 		// Each intersecting prefab is placed on ground, then drawn
 		// Each intersecting road is drawn by replacing top soil blocks with gravel / sandstone blocks
 		cChunkDef::HeightMap HeightMap;  // Heightmap for this chunk, used by roads
-		m_HeightGen.GenHeightMap(a_Chunk.GetChunkX(), a_Chunk.GetChunkZ(), HeightMap);
+		m_HeightGen->GenHeightMap(a_Chunk.GetChunkX(), a_Chunk.GetChunkZ(), HeightMap);
 		for (cPlacedPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
 		{
 			cPrefab & Prefab = (cPrefab &)((*itr)->GetPiece());
@@ -224,7 +224,7 @@ protected:
 		int BlockY;
 		cChunkDef::AbsoluteToRelative(BlockX, BlockY, BlockZ, ChunkX, ChunkZ);
 		cChunkDef::HeightMap HeightMap;
-		m_HeightGen.GenHeightMap(ChunkX, ChunkZ, HeightMap);
+		m_HeightGen->GenHeightMap(ChunkX, ChunkZ, HeightMap);
 		int TerrainHeight = cChunkDef::GetHeight(HeightMap, BlockX, BlockZ);
 		a_Piece.MoveToGroundBy(TerrainHeight - FirstConnector.m_Pos.y + 1);
 	}
@@ -359,7 +359,7 @@ static cVillagePiecePool * g_PlainsVillagePools[] =
 
 
 
-cVillageGen::cVillageGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, int a_MinDensity, int a_MaxDensity, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen) :
+cVillageGen::cVillageGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, int a_MinDensity, int a_MaxDensity, cBiomeGenPtr a_BiomeGen, cTerrainHeightGenPtr a_HeightGen) :
 	super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 100),
 	m_Noise(a_Seed + 1000),
 	m_MaxDepth(a_MaxDepth),
@@ -381,7 +381,7 @@ cGridStructGen::cStructurePtr cVillageGen::CreateStructure(int a_GridX, int a_Gr
 	int ChunkX, ChunkZ;
 	cChunkDef::BlockToChunk(a_OriginX, a_OriginZ, ChunkX, ChunkZ);
 	cChunkDef::BiomeMap Biomes;
-	m_BiomeGen.GenBiomes(ChunkX, ChunkZ, Biomes);
+	m_BiomeGen->GenBiomes(ChunkX, ChunkZ, Biomes);
 
 	// Check if all the biomes are village-friendly:
 	// If just one is not, no village is created, because it's likely that an unfriendly biome is too close
diff --git a/src/Generating/VillageGen.h b/src/Generating/VillageGen.h
index 694ea2358..ed8d739df 100644
--- a/src/Generating/VillageGen.h
+++ b/src/Generating/VillageGen.h
@@ -21,7 +21,7 @@ class cVillageGen :
 {
 	typedef cGridStructGen super;
 public:
-	cVillageGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, int a_MinDensity, int a_MaxDensity, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen);
+	cVillageGen(int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxDepth, int a_MaxSize, int a_MinDensity, int a_MaxDensity, cBiomeGenPtr a_BiomeGen, cTerrainHeightGenPtr a_HeightGen);
 
 protected:
 	class cVillage;  // fwd: VillageGen.cpp
@@ -42,10 +42,10 @@ protected:
 	int m_MaxDensity;
 
 	/** The underlying biome generator that defines whether the village is created or not */
-	cBiomeGen & m_BiomeGen;
+	cBiomeGenPtr m_BiomeGen;
 	
 	/** The underlying height generator, used to position the prefabs crossing chunk borders */
-	cTerrainHeightGen & m_HeightGen;
+	cTerrainHeightGenPtr m_HeightGen;
 
 
 	// cGridStructGen overrides: