21 files changed, 149 insertions, 185 deletions

diff --git a/Tools/QtBiomeVisualiser/ChunkSource.cpp b/Tools/QtBiomeVisualiser/ChunkSource.cpp
index e5cd7a75a..3e5216458 100644
--- a/Tools/QtBiomeVisualiser/ChunkSource.cpp
+++ b/Tools/QtBiomeVisualiser/ChunkSource.cpp
@@ -43,7 +43,7 @@ void BioGenSource::reload()
 	int seed = m_IniFile->GetValueSetI("Seed", "Seed", 0);
 	bool unused = false;
 	QMutexLocker lock(&m_Mtx);
-	m_BiomeGen.reset(cBiomeGen::CreateBiomeGen(*m_IniFile, seed, unused));
+	m_BiomeGen = cBiomeGen::CreateBiomeGen(*m_IniFile, seed, unused);
 }
 
 
diff --git a/Tools/QtBiomeVisualiser/ChunkSource.h b/Tools/QtBiomeVisualiser/ChunkSource.h
index 7bd1865ff..5332c5d3f 100644
--- a/Tools/QtBiomeVisualiser/ChunkSource.h
+++ b/Tools/QtBiomeVisualiser/ChunkSource.h
@@ -53,7 +53,7 @@ protected:
 	cIniFilePtr m_IniFile;
 
 	/** The generator used for generating biomes. */
-	std::unique_ptr<cBiomeGen> m_BiomeGen;
+	cBiomeGenPtr m_BiomeGen;
 
 	/** Guards m_BiomeGen against multithreaded access. */
 	QMutex m_Mtx;
diff --git a/Tools/QtBiomeVisualiser/GeneratorSetup.cpp b/Tools/QtBiomeVisualiser/GeneratorSetup.cpp
index d6348ee00..7d94a1682 100644
--- a/Tools/QtBiomeVisualiser/GeneratorSetup.cpp
+++ b/Tools/QtBiomeVisualiser/GeneratorSetup.cpp
@@ -59,7 +59,7 @@ GeneratorSetup::GeneratorSetup(const AString & a_IniFileName, QWidget * a_Parent
 		m_IniFile->SetValue("Generator", "Generator", "Composable");
 		m_IniFile->SetValue("Generator", "BiomeGen", m_cbGenerator->currentText().toStdString());
 		bool dummy;
-		delete cBiomeGen::CreateBiomeGen(*m_IniFile, 0, dummy);
+		cBiomeGen::CreateBiomeGen(*m_IniFile, 0, dummy);
 	}
 	updateFromIni();
 
@@ -91,7 +91,7 @@ void GeneratorSetup::generatorChanged(const QString & a_NewName)
 
 	// Create a dummy biome gen from the INI file, this will create the defaults in the INI file:
 	bool dummy;
-	delete cBiomeGen::CreateBiomeGen(*m_IniFile, m_Seed, dummy);
+	cBiomeGen::CreateBiomeGen(*m_IniFile, m_Seed, dummy);
 
 	// Read all values from the INI file and put them into the form layout:
 	updateFromIni();
diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index 9b3d4e98d..f5fe3e980 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);
 	}
 }
 
@@ -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/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 bf8995dcb..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)
 {
@@ -577,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 492bae129..93fe8b472 100644
--- a/src/Generating/DungeonRoomsFinisher.cpp
+++ b/src/Generating/DungeonRoomsFinisher.cpp
@@ -258,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),
@@ -294,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..23f589f55 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);
 }
 
 
@@ -479,7 +479,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..9eab9a94f 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
 	{
@@ -131,7 +131,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 +141,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/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: