shared_ptr -> unique_ptr in generators

src/Generating/BioGen.cpp

@@ -57,8 +57,8 @@ void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cBioGenCache:
 
-cBioGenCache::cBioGenCache(cBiomeGenPtr a_BioGenToCache, size_t a_CacheSize) :
+cBioGenCache::cBioGenCache(cBiomeGen & a_BioGenToCache, size_t a_CacheSize) :
-	m_BioGenToCache(std::move(a_BioGenToCache)),
+	m_BioGenToCache(a_BioGenToCache),
 	m_CacheSize(a_CacheSize),
 	m_NumHits(0),
 	m_NumMisses(0),
@@ -110,7 +110,7 @@ void cBioGenCache::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::BiomeMap & a
 
 	// Not in the cache:
 	m_NumMisses++;
-	m_BioGenToCache->GenBiomes(a_ChunkCoords, a_BiomeMap);
+	m_BioGenToCache.GenBiomes(a_ChunkCoords, a_BiomeMap);
 
 	// Insert it as the first item in the MRU order:
 	size_t Idx = m_CacheOrder[m_CacheSize - 1];
@@ -130,7 +130,7 @@ void cBioGenCache::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::BiomeMap & a
 void cBioGenCache::InitializeBiomeGen(cIniFile & a_IniFile)
 {
 	Super::InitializeBiomeGen(a_IniFile);
-	m_BioGenToCache->InitializeBiomeGen(a_IniFile);
+	m_BioGenToCache.InitializeBiomeGen(a_IniFile);
 }
 
 
@@ -139,13 +139,14 @@ void cBioGenCache::InitializeBiomeGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cBioGenMulticache:
 
-cBioGenMulticache::cBioGenMulticache(const cBiomeGenPtr & a_BioGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches) :
+cBioGenMulticache::cBioGenMulticache(std::unique_ptr<cBiomeGen> a_BioGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches) :
-	m_NumSubCaches(a_NumSubCaches)
+	m_NumSubCaches(a_NumSubCaches),
+	m_Underlying(std::move(a_BioGenToCache))
 {
 	m_Caches.reserve(a_NumSubCaches);
 	for (size_t i = 0; i < a_NumSubCaches; i++)
 	{
-		m_Caches.emplace_back(new cBioGenCache(a_BioGenToCache, a_SubCacheSize));
+		m_Caches.push_back(std::make_unique<cBioGenCache>(*m_Underlying, a_SubCacheSize));
 	}
 }
 
@@ -167,7 +168,7 @@ void cBioGenMulticache::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::BiomeMa
 
 void cBioGenMulticache::InitializeBiomeGen(cIniFile & a_IniFile)
 {
-	for (const auto & itr : m_Caches)
+	for (auto & itr : m_Caches)
 	{
 		itr->InitializeBiomeGen(a_IniFile);
 	}
@@ -1133,7 +1134,7 @@ protected:
 ////////////////////////////////////////////////////////////////////////////////
 // cBiomeGen:
 
-cBiomeGenPtr cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault)
+std::unique_ptr<cBiomeGen> cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool & a_CacheOffByDefault)
 {
 	AString BiomeGenName = a_IniFile.GetValue("Generator", "BiomeGen");
 	if (BiomeGenName.empty())
@@ -1142,37 +1143,37 @@ cBiomeGenPtr cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool &
 		BiomeGenName = "Grown";
 	}
 
-	cBiomeGen * res = nullptr;
+	std::unique_ptr<cBiomeGen> res;
 	a_CacheOffByDefault = false;
 	if (NoCaseCompare(BiomeGenName, "constant") == 0)
 	{
-		res = new cBioGenConstant;
+		res = std::make_unique<cBioGenConstant>();
 		a_CacheOffByDefault = true;  // we're generating faster than a cache would retrieve data :)
 	}
 	else if (NoCaseCompare(BiomeGenName, "checkerboard") == 0)
 	{
-		res = new cBioGenCheckerboard;
+		res = std::make_unique<cBioGenCheckerboard>();
 		a_CacheOffByDefault = true;  // we're (probably) generating faster than a cache would retrieve data
 	}
 	else if (NoCaseCompare(BiomeGenName, "voronoi") == 0)
 	{
-		res = new cBioGenVoronoi(a_Seed);
+		res = std::make_unique<cBioGenVoronoi>(a_Seed);
 	}
 	else if (NoCaseCompare(BiomeGenName, "distortedvoronoi") == 0)
 	{
-		res = new cBioGenDistortedVoronoi(a_Seed);
+		res = std::make_unique<cBioGenDistortedVoronoi>(a_Seed);
 	}
 	else if (NoCaseCompare(BiomeGenName, "twolevel") == 0)
 	{
-		res = new cBioGenTwoLevel(a_Seed);
+		res = std::make_unique<cBioGenTwoLevel>(a_Seed);
 	}
 	else if (NoCaseCompare(BiomeGenName, "multistepmap") == 0)
 	{
-		res = new cBioGenMultiStepMap(a_Seed);
+		res = std::make_unique<cBioGenMultiStepMap>(a_Seed);
 	}
 	else if (NoCaseCompare(BiomeGenName, "grownprot") == 0)
 	{
-		res = new cBioGenProtGrown(a_Seed);
+		res = std::make_unique<cBioGenProtGrown>(a_Seed);
 	}
 	else
 	{
@@ -1180,11 +1181,11 @@ cBiomeGenPtr cBiomeGen::CreateBiomeGen(cIniFile & a_IniFile, int a_Seed, bool &
 		{
 			LOGWARNING("Unknown BiomeGen \"%s\", using \"Grown\" instead.", BiomeGenName.c_str());
 		}
-		res = new cBioGenGrown(a_Seed);
+		res = std::make_unique<cBioGenGrown>(a_Seed);
 	}
 	res->InitializeBiomeGen(a_IniFile);
 
-	return cBiomeGenPtr(res);
+	return res;
 }
 
 
@@ -1234,7 +1235,3 @@ protected:
 } g_BioGenPerfTest;
 
 #endif
-
-
-
-

src/Generating/BioGen.h

@@ -49,13 +49,13 @@ class cBioGenCache:
 
 public:
 
-	cBioGenCache(cBiomeGenPtr a_BioGenToCache, size_t a_CacheSize);
+	cBioGenCache(cBiomeGen & a_BioGenToCache, size_t a_CacheSize);
-	virtual ~cBioGenCache() override = default;
-
 
 protected:
 
-	cBiomeGenPtr m_BioGenToCache;
+	friend class cBioGenMulticache;
+
+	cBiomeGen & m_BioGenToCache;
 
 	struct sCacheData
 	{
@@ -97,17 +97,18 @@ public:
 	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(const cBiomeGenPtr & a_BioGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches);
+	cBioGenMulticache(std::unique_ptr<cBiomeGen> a_BioGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches);
 
 protected:
-	typedef std::vector<cBiomeGenPtr> cBiomeGenPtrs;
-
 
 	/** Number of sub-caches. Pulled out of m_Caches.size() for faster access. */
 	size_t m_NumSubCaches;
 
 	/** Individual sub-caches. */
-	cBiomeGenPtrs m_Caches;
+	std::vector<std::unique_ptr<cBioGenCache>> m_Caches;
+
+	/** The underlying biome generator. */
+	std::unique_ptr<cBiomeGen> m_Underlying;
 
 
 	virtual void GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::BiomeMap & a_BiomeMap) override;
@@ -323,7 +324,3 @@ protected:
 	a_DistLevel is either 0 or 1; zero when it is at the edge of the small Voronoi cell, 1 near the center */
 	EMCSBiome SelectBiome(int a_BiomeGroup, size_t a_BiomeIdx, int a_DistLevel);
 } ;
-
-
-
-

src/Generating/CompoGen.cpp

@@ -329,7 +329,7 @@ void cCompoGenNether::InitializeCompoGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cCompoGenCache:
 
-cCompoGenCache::cCompoGenCache(cTerrainCompositionGenPtr a_Underlying, int a_CacheSize) :
+cCompoGenCache::cCompoGenCache(std::unique_ptr<cTerrainCompositionGen> a_Underlying, int a_CacheSize) :
 	m_Underlying(std::move(a_Underlying)),
 	m_CacheSize(a_CacheSize),
 	m_CacheOrder(new int[ToUnsigned(a_CacheSize)]),
@@ -430,7 +430,3 @@ void cCompoGenCache::InitializeCompoGen(cIniFile & a_IniFile)
 {
 	m_Underlying->InitializeCompoGen(a_IniFile);
 }
-
-
-
-

src/Generating/CompoGen.h

@@ -115,7 +115,7 @@ class cCompoGenCache :
 	public cTerrainCompositionGen
 {
 public:
-	cCompoGenCache(cTerrainCompositionGenPtr a_Underlying, int a_CacheSize);  // Doesn't take ownership of a_Underlying
+	cCompoGenCache(std::unique_ptr<cTerrainCompositionGen> a_Underlying, int a_CacheSize);
 	virtual ~cCompoGenCache() override;
 
 	// cTerrainCompositionGen override:
@@ -124,7 +124,7 @@ public:
 
 protected:
 
-	cTerrainCompositionGenPtr m_Underlying;
+	std::unique_ptr<cTerrainCompositionGen> m_Underlying;
 
 	struct sCacheData
 	{
@@ -145,7 +145,3 @@ protected:
 	int m_NumMisses;
 	int m_TotalChain;  // Number of cache items walked to get to a hit (only added for hits)
 } ;
-
-
-
-

src/Generating/CompoGenBiomal.cpp

@@ -582,10 +582,7 @@ protected:
 
 
 
-cTerrainCompositionGenPtr CreateCompoGenBiomal(int a_Seed)
+std::unique_ptr<cTerrainCompositionGen> CreateCompoGenBiomal(int a_Seed)
 {
-	return std::make_shared<cCompoGenBiomal>(a_Seed);
+	return std::make_unique<cCompoGenBiomal>(a_Seed);
 }
-
-
-

src/Generating/CompoGenBiomal.h

@@ -14,8 +14,4 @@
 
 
 /** Returns a new instance of the Biomal composition generator. */
-cTerrainCompositionGenPtr CreateCompoGenBiomal(int a_Seed);
+std::unique_ptr<cTerrainCompositionGen> CreateCompoGenBiomal(int a_Seed);
-
-
-
-

src/Generating/ComposableGenerator.cpp

@@ -38,10 +38,10 @@
 ////////////////////////////////////////////////////////////////////////////////
 // cTerrainCompositionGen:
 
-cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(
+std::unique_ptr<cTerrainCompositionGen> cTerrainCompositionGen::CreateCompositionGen(
 	cIniFile & a_IniFile,
-	const cBiomeGenPtr & a_BiomeGen,
+	cBiomeGen & a_BiomeGen,
-	const cTerrainShapeGenPtr & a_ShapeGen,
+	cTerrainShapeGen & a_ShapeGen,
 	int a_Seed
 )
 {
@@ -53,7 +53,7 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(
 	}
 
 	// Compositor list is alpha-sorted
-	cTerrainCompositionGenPtr res;
+	std::unique_ptr<cTerrainCompositionGen> res;
 	if (NoCaseCompare(CompoGenName, "Biomal") == 0)
 	{
 		res = CreateCompoGenBiomal(a_Seed);
@@ -65,11 +65,11 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(
 	}
 	else if (NoCaseCompare(CompoGenName, "Classic") == 0)
 	{
-		res = std::make_shared<cCompoGenClassic>();
+		res = std::make_unique<cCompoGenClassic>();
 	}
 	else if (NoCaseCompare(CompoGenName, "DebugBiomes") == 0)
 	{
-		res = std::make_shared<cCompoGenDebugBiomes>();
+		res = std::make_unique<cCompoGenDebugBiomes>();
 	}
 	else if (NoCaseCompare(CompoGenName, "DistortedHeightmap") == 0)
 	{
@@ -78,11 +78,11 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(
 	}
 	else if (NoCaseCompare(CompoGenName, "End") == 0)
 	{
-		res = std::make_shared<cEndGen>(a_Seed);
+		res = std::make_unique<cEndGen>(a_Seed);
 	}
 	else if (NoCaseCompare(CompoGenName, "Nether") == 0)
 	{
-		res = std::make_shared<cCompoGenNether>(a_Seed);
+		res = std::make_unique<cCompoGenNether>(a_Seed);
 	}
 	else if (NoCaseCompare(CompoGenName, "Noise3D") == 0)
 	{
@@ -91,7 +91,7 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(
 	}
 	else if (NoCaseCompare(CompoGenName, "SameBlock") == 0)
 	{
-		res = std::make_shared<cCompoGenSameBlock>();
+		res = std::make_unique<cCompoGenSameBlock>();
 	}
 	else
 	{
@@ -104,7 +104,7 @@ cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(
 	// Read the settings from the ini file:
 	res->InitializeCompoGen(a_IniFile);
 
-	return cTerrainCompositionGenPtr(res);
+	return res;
 }
 
 
@@ -181,10 +181,10 @@ void cComposableGenerator::Generate(cChunkDesc & a_ChunkDesc)
 
 	if (a_ChunkDesc.IsUsingDefaultFinish())
 	{
-		for (cFinishGenList::iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)
+		for (const auto & Finisher : m_FinishGens)
 		{
-			(*itr)->GenFinish(a_ChunkDesc);
+			Finisher->GenFinish(a_ChunkDesc);
-		}  // for itr - m_FinishGens[]
+		}
 		ShouldUpdateHeightmap = true;
 	}
 
@@ -302,11 +302,11 @@ void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)
 	if (MultiCacheLength > 0)
 	{
 		LOGD("Enabling multicache for biomegen of length %d.", MultiCacheLength);
-		m_BiomeGen = std::make_shared<cBioGenMulticache>(m_BiomeGen, static_cast<size_t>(CacheSize), static_cast<size_t>(MultiCacheLength));
+		m_BiomeGen = std::make_unique<cBioGenMulticache>(std::move(m_BiomeGen), static_cast<size_t>(CacheSize), static_cast<size_t>(MultiCacheLength));
 	}
 	else
 	{
-		m_BiomeGen = std::make_shared<cBioGenCache>(m_BiomeGen, static_cast<size_t>(CacheSize));
+		m_BiomeGen = std::make_unique<cBioGenMulticache>(std::move(m_BiomeGen), static_cast<size_t>(CacheSize), 1);
 	}
 }
 
@@ -319,7 +319,7 @@ void cComposableGenerator::InitShapeGen(cIniFile & a_IniFile)
 	bool CacheOffByDefault = false;
 	m_ShapeGen = cTerrainShapeGen::CreateShapeGen(
 		a_IniFile,
-		m_BiomeGen,
+		*m_BiomeGen,
 		m_Seed,
 		CacheOffByDefault
 	);
@@ -351,8 +351,8 @@ void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
 {
 	m_CompositionGen = cTerrainCompositionGen::CreateCompositionGen(
 		a_IniFile,
-		m_BiomeGen,
+		*m_BiomeGen,
-		m_ShapeGen,
+		*m_ShapeGen,
 		m_Seed
 	);
 
@@ -361,11 +361,11 @@ void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
 	int CompoGenCacheSize = a_IniFile.GetValueSetI("Generator", "CompositionGenCacheSize", 64);
 	if (CompoGenCacheSize > 0)
 	{
-		m_CompositionGen = std::make_shared<cCompoGenCache>(m_CompositionGen, CompoGenCacheSize);
+		m_CompositionGen = std::make_unique<cCompoGenCache>(std::move(m_CompositionGen), CompoGenCacheSize);
 	}
 
 	// Create a cache of the composited heightmaps, so that finishers may use it:
-	m_CompositedHeightCache = std::make_shared<cHeiGenMultiCache>(std::make_shared<cCompositedHeiGen>(m_BiomeGen, m_ShapeGen, m_CompositionGen), 16, 128);
+	m_CompositedHeightCache = std::make_unique<cHeiGenMultiCache>(std::make_unique<cCompositedHeiGen>(*m_BiomeGen, *m_ShapeGen, *m_CompositionGen), 16, 128);
 	// 128 subcaches of depth 16 each = 0.5 MiB of RAM. Acceptable, for the amount of work this saves.
 }
 
@@ -392,13 +392,13 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		// Finishers, alpha-sorted:
 		if (NoCaseCompare(finisher, "Animals") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenPassiveMobs(m_Seed, a_IniFile, m_Dimension));
+			m_FinishGens.push_back(std::make_unique<cFinishGenPassiveMobs>(m_Seed, a_IniFile, m_Dimension));
 		}
 		else if (NoCaseCompare(finisher, "BottomLava") == 0)
 		{
 			int DefaultBottomLavaLevel = (m_Dimension == dimNether) ? 30 : 10;
 			int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
-			m_FinishGens.emplace_back(new cFinishGenBottomLava(BottomLavaLevel));
+			m_FinishGens.push_back(std::make_unique<cFinishGenBottomLava>(BottomLavaLevel));
 		}
 		else if (NoCaseCompare(finisher, "DeadBushes") == 0)
 		{
@@ -421,26 +421,26 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			AllowedBlocks.push_back(E_BLOCK_HARDENED_CLAY);
 			AllowedBlocks.push_back(E_BLOCK_STAINED_CLAY);
 
-			m_FinishGens.emplace_back(new cFinishGenSingleTopBlock(m_Seed, E_BLOCK_DEAD_BUSH, AllowedBiomes, 2, AllowedBlocks));
+			m_FinishGens.push_back(std::make_unique<cFinishGenSingleTopBlock>(m_Seed, E_BLOCK_DEAD_BUSH, AllowedBiomes, 2, AllowedBlocks));
 		}
 		else if (NoCaseCompare(finisher, "DirectOverhangs") == 0)
 		{
-			m_FinishGens.emplace_back(new cStructGenDirectOverhangs(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cStructGenDirectOverhangs>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "DirtPockets") == 0)
 		{
-			auto gen = std::make_shared<cFinishGenOrePockets>(m_Seed + 1, cFinishGenOrePockets::DefaultNaturalPatches());
+			auto Gen = std::make_unique<cFinishGenOrePockets>(m_Seed + 1, cFinishGenOrePockets::DefaultNaturalPatches());
-			gen->Initialize(a_IniFile, "DirtPockets");
+			Gen->Initialize(a_IniFile, "DirtPockets");
-			m_FinishGens.push_back(gen);
+			m_FinishGens.push_back(std::move(Gen));
 		}
 		else if (NoCaseCompare(finisher, "DistortedMembraneOverhangs") == 0)
 		{
-			m_FinishGens.emplace_back(new cStructGenDistortedMembraneOverhangs(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cStructGenDistortedMembraneOverhangs>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "DualRidgeCaves") == 0)
 		{
 			float Threshold = static_cast<float>(a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3));
-			m_FinishGens.emplace_back(new cStructGenDualRidgeCaves(m_Seed, Threshold));
+			m_FinishGens.push_back(std::make_unique<cStructGenDualRidgeCaves>(m_Seed, Threshold));
 		}
 		else if (NoCaseCompare(finisher, "DungeonRooms") == 0)
 		{
@@ -448,24 +448,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.emplace_back(new cDungeonRoomsFinisher(m_ShapeGen, m_Seed, GridSize, MaxSize, MinSize, HeightDistrib));
+			m_FinishGens.push_back(std::make_unique<cDungeonRoomsFinisher>(*m_ShapeGen, m_Seed, GridSize, MaxSize, MinSize, HeightDistrib));
 		}
 		else if (NoCaseCompare(finisher, "GlowStone") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenGlowStone(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cFinishGenGlowStone>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "Ice") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenIce);
+			m_FinishGens.push_back(std::make_unique<cFinishGenIce>());
 		}
 		else if (NoCaseCompare(finisher, "LavaLakes") == 0)
 		{
 			int Probability = a_IniFile.GetValueSetI("Generator", "LavaLakesProbability", 10);
-			m_FinishGens.emplace_back(new cStructGenLakes(m_Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, m_ShapeGen, Probability));
+			m_FinishGens.push_back(std::make_unique<cStructGenLakes>(m_Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, *m_ShapeGen, Probability));
 		}
 		else if (NoCaseCompare(finisher, "LavaSprings") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenFluidSprings(m_Seed, E_BLOCK_LAVA, a_IniFile, m_Dimension));
+			m_FinishGens.push_back(std::make_unique<cFinishGenFluidSprings>(m_Seed, E_BLOCK_LAVA, a_IniFile, m_Dimension));
 		}
 		else if (NoCaseCompare(finisher, "Lilypads") == 0)
 		{
@@ -479,11 +479,11 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			AllowedBlocks.push_back(E_BLOCK_WATER);
 			AllowedBlocks.push_back(E_BLOCK_STATIONARY_WATER);
 
-			m_FinishGens.emplace_back(new cFinishGenSingleTopBlock(m_Seed, E_BLOCK_LILY_PAD, AllowedBiomes, 4, AllowedBlocks));
+			m_FinishGens.push_back(std::make_unique<cFinishGenSingleTopBlock>(m_Seed, E_BLOCK_LILY_PAD, AllowedBiomes, 4, AllowedBlocks));
 		}
 		else if (NoCaseCompare(finisher, "MarbleCaves") == 0)
 		{
-			m_FinishGens.emplace_back(new cStructGenMarbleCaves(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cStructGenMarbleCaves>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "MineShafts") == 0)
 		{
@@ -493,37 +493,37 @@ 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.emplace_back(new cStructGenMineShafts(
+			m_FinishGens.push_back(std::make_unique<cStructGenMineShafts>(
 				m_Seed, GridSize, MaxOffset, MaxSystemSize,
 				ChanceCorridor, ChanceCrossing, ChanceStaircase
 			));
 		}
 		else if (NoCaseCompare(finisher, "NaturalPatches") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenOreNests(m_Seed + 1, cFinishGenOreNests::DefaultNaturalPatches()));
+			m_FinishGens.push_back(std::make_unique<cFinishGenOreNests>(m_Seed + 1, cFinishGenOreNests::DefaultNaturalPatches()));
 		}
 		else if (NoCaseCompare(finisher, "NetherClumpFoliage") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenNetherClumpFoliage(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cFinishGenNetherClumpFoliage>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "NetherOreNests") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenOreNests(m_Seed + 2, cFinishGenOreNests::DefaultNetherOres()));
+			m_FinishGens.push_back(std::make_unique<cFinishGenOreNests>(m_Seed + 2, cFinishGenOreNests::DefaultNetherOres()));
 		}
 		else if (NoCaseCompare(finisher, "OreNests") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenOreNests(m_Seed + 3, cFinishGenOreNests::DefaultOverworldOres()));
+			m_FinishGens.push_back(std::make_unique<cFinishGenOreNests>(m_Seed + 3, cFinishGenOreNests::DefaultOverworldOres()));
 		}
 		else if (NoCaseCompare(finisher, "OrePockets") == 0)
 		{
-			auto gen = std::make_shared<cFinishGenOrePockets>(m_Seed + 2, cFinishGenOrePockets::DefaultOverworldOres());
+			auto Gen = std::make_unique<cFinishGenOrePockets>(m_Seed + 2, cFinishGenOrePockets::DefaultOverworldOres());
-			gen->Initialize(a_IniFile, "OrePockets");
+			Gen->Initialize(a_IniFile, "OrePockets");
-			m_FinishGens.push_back(gen);
+			m_FinishGens.push_back(std::move(Gen));
 		}
 		else if (NoCaseCompare(finisher, "OverworldClumpFlowers") == 0)
 		{
 			auto flowers = cFinishGenClumpTopBlock::ParseIniFile(a_IniFile, "OverworldClumpFlowers");
-			m_FinishGens.emplace_back(new cFinishGenClumpTopBlock(m_Seed, flowers));
+			m_FinishGens.push_back(std::make_unique<cFinishGenClumpTopBlock>(m_Seed, flowers));
 		}
 		else if (NoCaseCompare(finisher, "PieceStructures") == 0)
 		{
@@ -533,10 +533,10 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 				continue;
 			}
 
-			auto gen = std::make_shared<cPieceStructuresGen>(m_Seed);
+			auto Gen = std::make_unique<cPieceStructuresGen>(m_Seed);
-			if (gen->Initialize(split[1], seaLevel, m_BiomeGen, m_CompositedHeightCache))
+			if (Gen->Initialize(split[1], seaLevel, *m_BiomeGen, *m_CompositedHeightCache))
 			{
-				m_FinishGens.push_back(gen);
+				m_FinishGens.push_back(std::move(Gen));
 			}
 		}
 		else if (NoCaseCompare(finisher, "PreSimulator") == 0)
@@ -546,11 +546,11 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			bool PreSimulateWater         = a_IniFile.GetValueSetB("Generator", "PreSimulatorWater", true);
 			bool PreSimulateLava          = a_IniFile.GetValueSetB("Generator", "PreSimulatorLava", true);
 
-			m_FinishGens.emplace_back(new cFinishGenPreSimulator(PreSimulateFallingBlocks, PreSimulateWater, PreSimulateLava));
+			m_FinishGens.push_back(std::make_unique<cFinishGenPreSimulator>(PreSimulateFallingBlocks, PreSimulateWater, PreSimulateLava));
 		}
 		else if (NoCaseCompare(finisher, "Ravines") == 0)
 		{
-			m_FinishGens.emplace_back(new cStructGenRavines(m_Seed, 128));
+			m_FinishGens.push_back(std::make_unique<cStructGenRavines>(m_Seed, 128));
 		}
 		else if (NoCaseCompare(finisher, "RoughRavines") == 0)
 		{
@@ -570,7 +570,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.emplace_back(new cRoughRavines(
+			m_FinishGens.push_back(std::make_unique<cRoughRavines>(
 				m_Seed, MaxSize, MinSize,
 				static_cast<float>(MaxCenterWidth),
 				static_cast<float>(MinCenterWidth),
@@ -595,33 +595,33 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 				continue;
 			}
 
-			auto Gen = std::make_shared<cSinglePieceStructuresGen>(m_Seed);
+			auto Gen = std::make_unique<cSinglePieceStructuresGen>(m_Seed);
-			if (Gen->Initialize(split[1], seaLevel, m_BiomeGen, m_CompositedHeightCache))
+			if (Gen->Initialize(split[1], seaLevel, *m_BiomeGen, *m_CompositedHeightCache))
 			{
-				m_FinishGens.push_back(Gen);
+				m_FinishGens.push_back(std::move(Gen));
 			}
 		}
 		else if (NoCaseCompare(finisher, "SoulsandRims") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenSoulsandRims(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cFinishGenSoulsandRims>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "Snow") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenSnow);
+			m_FinishGens.push_back(std::make_unique<cFinishGenSnow>());
 		}
 		else if (NoCaseCompare(finisher, "SprinkleFoliage") == 0)
 		{
 			int MaxCactusHeight 	= a_IniFile.GetValueI("Plants", "MaxCactusHeight", 3);
 			int MaxSugarcaneHeight 	= a_IniFile.GetValueI("Plants", "MaxSugarcaneHeight", 3);
-			m_FinishGens.emplace_back(new cFinishGenSprinkleFoliage(m_Seed, MaxCactusHeight, MaxSugarcaneHeight));
+			m_FinishGens.push_back(std::make_unique<cFinishGenSprinkleFoliage>(m_Seed, MaxCactusHeight, MaxSugarcaneHeight));
 		}
 		else if (NoCaseCompare(finisher, "TallGrass") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenTallGrass(m_Seed));
+			m_FinishGens.push_back(std::make_unique<cFinishGenTallGrass>(m_Seed));
 		}
 		else if (NoCaseCompare(finisher, "Trees") == 0)
 		{
-			m_FinishGens.emplace_back(new cStructGenTrees(m_Seed, m_BiomeGen, m_ShapeGen, m_CompositionGen));
+			m_FinishGens.push_back(std::make_unique<cStructGenTrees>(m_Seed, *m_BiomeGen, *m_ShapeGen, *m_CompositionGen));
 		}
 		else if (NoCaseCompare(finisher, "Villages") == 0)
 		{
@@ -633,28 +633,28 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 			int MaxDensity = a_IniFile.GetValueSetI("Generator", "VillageMaxDensity", 80);
 			AString PrefabList = a_IniFile.GetValueSet("Generator", "VillagePrefabs", "PlainsVillage, SandVillage");
 			auto Prefabs = StringSplitAndTrim(PrefabList, ",");
-			m_FinishGens.emplace_back(new cVillageGen(m_Seed, GridSize, MaxOffset, MaxDepth, MaxSize, MinDensity, MaxDensity, m_BiomeGen, m_CompositedHeightCache, seaLevel, Prefabs));
+			m_FinishGens.push_back(std::make_unique<cVillageGen>(m_Seed, GridSize, MaxOffset, MaxDepth, MaxSize, MinDensity, MaxDensity, *m_BiomeGen, *m_CompositedHeightCache, seaLevel, Prefabs));
 		}
 		else if (NoCaseCompare(finisher, "Vines") == 0)
 		{
 			int Level = a_IniFile.GetValueSetI("Generator", "VinesLevel", 40);
-			m_FinishGens.emplace_back(new cFinishGenVines(m_Seed, Level));
+			m_FinishGens.push_back(std::make_unique<cFinishGenVines>(m_Seed, Level));
 		}
 		else if (NoCaseCompare(finisher, "WaterLakes") == 0)
 		{
 			int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);
-			m_FinishGens.emplace_back(new cStructGenLakes(m_Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, m_ShapeGen, Probability));
+			m_FinishGens.push_back(std::make_unique<cStructGenLakes>(m_Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, *m_ShapeGen, Probability));
 		}
 		else if (NoCaseCompare(finisher, "WaterSprings") == 0)
 		{
-			m_FinishGens.emplace_back(new cFinishGenFluidSprings(m_Seed, E_BLOCK_WATER, a_IniFile, m_Dimension));
+			m_FinishGens.push_back(std::make_unique<cFinishGenFluidSprings>(m_Seed, E_BLOCK_WATER, a_IniFile, m_Dimension));
 		}
 		else if (NoCaseCompare(finisher, "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.emplace_back(new cStructGenWormNestCaves(m_Seed, Size, Grid, MaxOffset));
+			m_FinishGens.push_back(std::make_unique<cStructGenWormNestCaves>(m_Seed, Size, Grid, MaxOffset));
 		}
 		else
 		{
@@ -662,7 +662,3 @@ void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
 		}
 	}  // for itr - Str[]
 }
-
-
-
-

src/Generating/ComposableGenerator.h

@@ -30,11 +30,6 @@ class cTerrainShapeGen;
 class cTerrainHeightGen;
 class cTerrainCompositionGen;
 class cFinishGen;
-typedef std::shared_ptr<cBiomeGen>              cBiomeGenPtr;
-typedef std::shared_ptr<cTerrainShapeGen>       cTerrainShapeGenPtr;
-typedef std::shared_ptr<cTerrainHeightGen>      cTerrainHeightGenPtr;
-typedef std::shared_ptr<cTerrainCompositionGen> cTerrainCompositionGenPtr;
-typedef std::shared_ptr<cFinishGen>             cFinishGenPtr;
 
 
 
@@ -60,7 +55,7 @@ public:
 	a_CacheOffByDefault gets set to whether the cache should be disabled by default.
 	Used in BiomeVisualiser, too.
 	Implemented in BioGen.cpp! */
-	static cBiomeGenPtr CreateBiomeGen(
+	static std::unique_ptr<cBiomeGen> CreateBiomeGen(
 		cIniFile & a_IniFile,
 		int a_Seed,
 		bool & a_CacheOffByDefault
@@ -96,9 +91,9 @@ public:
 	a_CacheOffByDefault gets set to whether the cache should be disabled by default
 	Implemented in ShapeGen.cpp!
 	*/
-	static cTerrainShapeGenPtr CreateShapeGen(
+	static std::unique_ptr<cTerrainShapeGen> CreateShapeGen(
 		cIniFile & a_IniFile,
-		const cBiomeGenPtr & a_BiomeGen,
+		cBiomeGen & a_BiomeGen,
 		int a_Seed,
 		bool & a_CacheOffByDefault
 	);
@@ -135,9 +130,9 @@ public:
 	}
 
 	/** Creates a cTerrainHeightGen descendant based on the INI file settings. */
-	static cTerrainHeightGenPtr CreateHeightGen(
+	static std::unique_ptr<cTerrainHeightGen> CreateHeightGen(
 		cIniFile & a_IniFile,
-		const cBiomeGenPtr & a_BiomeGen,
+		cBiomeGen & a_BiomeGen,
 		int a_Seed,
 		bool & a_CacheOffByDefault
 	);
@@ -167,10 +162,10 @@ public:
 	/** Creates the correct TerrainCompositionGen descendant based on the ini file settings and the seed provided.
 	a_BiomeGen is the underlying biome generator, some composition generators may depend on it providing additional biomes around the chunk
 	a_ShapeGen is the underlying shape generator, some composition generators may depend on it providing additional shape around the chunk. */
-	static cTerrainCompositionGenPtr CreateCompositionGen(
+	static std::unique_ptr<cTerrainCompositionGen> CreateCompositionGen(
 		cIniFile & a_IniFile,
-		const cBiomeGenPtr & a_BiomeGen,
+		cBiomeGen & a_BiomeGen,
-		const cTerrainShapeGenPtr & a_ShapeGen,
+		cTerrainShapeGen & a_ShapeGen,
 		int a_Seed
 	);
 } ;
@@ -194,8 +189,6 @@ public:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) = 0;
 } ;
 
-typedef std::list<cFinishGenPtr> cFinishGenList;
-
 
 
 
@@ -223,19 +216,19 @@ protected:
 
 	// The generator's composition:
 	/** The biome generator. */
-	cBiomeGenPtr m_BiomeGen;
+	std::unique_ptr<cBiomeGen> m_BiomeGen;
 
 	/** The terrain shape generator. */
-	cTerrainShapeGenPtr m_ShapeGen;
+	std::unique_ptr<cTerrainShapeGen> m_ShapeGen;
 
 	/** The terrain composition generator. */
-	cTerrainCompositionGenPtr m_CompositionGen;
+	std::unique_ptr<cTerrainCompositionGen> m_CompositionGen;
 
 	/** The cache for the heights of the composited terrain. */
-	cTerrainHeightGenPtr m_CompositedHeightCache;
+	std::unique_ptr<cTerrainHeightGen> m_CompositedHeightCache;
 
 	/** The finisher generators, in the order in which they are applied. */
-	cFinishGenList m_FinishGens;
+	std::vector<std::unique_ptr<cFinishGen>> m_FinishGens;
 
 
 	/** Reads the BiomeGen settings from the ini and initializes m_BiomeGen accordingly */
@@ -250,7 +243,3 @@ protected:
 	/** Reads the finishers from the ini and initializes m_FinishGens accordingly */
 	void InitFinishGens(cIniFile & a_IniFile);
 } ;
-
-
-
-

src/Generating/CompositedHeiGen.h

@@ -20,10 +20,10 @@ class cCompositedHeiGen:
 	public cTerrainHeightGen
 {
 public:
-	cCompositedHeiGen(cBiomeGenPtr a_BiomeGen, cTerrainShapeGenPtr a_ShapeGen, cTerrainCompositionGenPtr a_CompositionGen):
+	cCompositedHeiGen(cBiomeGen & a_BiomeGen, cTerrainShapeGen & a_ShapeGen, cTerrainCompositionGen & a_CompositionGen):
-		m_BiomeGen(std::move(a_BiomeGen)),
+		m_BiomeGen(a_BiomeGen),
-		m_ShapeGen(std::move(a_ShapeGen)),
+		m_ShapeGen(a_ShapeGen),
-		m_CompositionGen(std::move(a_CompositionGen))
+		m_CompositionGen(a_CompositionGen)
 	{
 	}
 
@@ -33,20 +33,16 @@ public:
 	virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap) override
 	{
 		cChunkDesc::Shape shape;
-		m_ShapeGen->GenShape(a_ChunkCoords, shape);
+		m_ShapeGen.GenShape(a_ChunkCoords, shape);
 		cChunkDesc desc(a_ChunkCoords);
-		m_BiomeGen->GenBiomes(a_ChunkCoords, desc.GetBiomeMap());  // Need to initialize biomes for the composition gen
+		m_BiomeGen.GenBiomes(a_ChunkCoords, desc.GetBiomeMap());  // Need to initialize biomes for the composition gen
 		desc.SetHeightFromShape(shape);
-		m_CompositionGen->ComposeTerrain(desc, shape);
+		m_CompositionGen.ComposeTerrain(desc, shape);
 		memcpy(a_HeightMap, desc.GetHeightMap(), sizeof(a_HeightMap));
 	}
 
 protected:
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
-	cTerrainShapeGenPtr m_ShapeGen;
+	cTerrainShapeGen & m_ShapeGen;
-	cTerrainCompositionGenPtr m_CompositionGen;
+	cTerrainCompositionGen & m_CompositionGen;
 };
-
-
-
-

src/Generating/DistortedHeightmap.cpp

@@ -118,12 +118,12 @@ const cDistortedHeightmap::sGenParam cDistortedHeightmap::m_GenParam[256] =
 
 
 
-cDistortedHeightmap::cDistortedHeightmap(int a_Seed, const cBiomeGenPtr & a_BiomeGen) :
+cDistortedHeightmap::cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen) :
 	m_NoiseDistortX(a_Seed + 1000),
 	m_NoiseDistortZ(a_Seed + 2000),
 	m_CurChunkCoords(0x7fffffff, 0x7fffffff),  // Set impossible coords for the chunk so that it's always considered stale
 	m_BiomeGen(a_BiomeGen),
-	m_UnderlyingHeiGen(new cHeiGenBiomal(a_Seed, a_BiomeGen)),
+	m_UnderlyingHeiGen(a_Seed, a_BiomeGen),
 	m_HeightGen(m_UnderlyingHeiGen, 64),
 	m_IsInitialized(false)
 {
@@ -297,7 +297,7 @@ void cDistortedHeightmap::UpdateDistortAmps(void)
 	{
 		for (int x = -1; x <= 1; x++)
 		{
-			m_BiomeGen->GenBiomes({m_CurChunkCoords.m_ChunkX + x, m_CurChunkCoords.m_ChunkZ + z}, Biomes[x + 1][z + 1]);
+			m_BiomeGen.GenBiomes({m_CurChunkCoords.m_ChunkX + x, m_CurChunkCoords.m_ChunkZ + z}, Biomes[x + 1][z + 1]);
 		}  // for x
 	}  // for z
 

src/Generating/DistortedHeightmap.h

@@ -26,7 +26,7 @@ class cDistortedHeightmap :
 	public cTerrainShapeGen
 {
 public:
-	cDistortedHeightmap(int a_Seed, const cBiomeGenPtr & a_BiomeGen);
+	cDistortedHeightmap(int a_Seed, cBiomeGen & a_BiomeGen);
 
 protected:
 	typedef cChunkDef::BiomeMap BiomeNeighbors[3][3];
@@ -53,10 +53,10 @@ protected:
 	NOISE_DATATYPE m_DistortedHeightmap[17 * 257 * 17];
 
 	/** The bime generator to query for biomes. */
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	/** The generator that provides the base heightmap (before distortion). */
-	cTerrainHeightGenPtr m_UnderlyingHeiGen;
+	cHeiGenBiomal m_UnderlyingHeiGen;
 
 	/** Cache for m_UnderlyingHeiGen. */
 	cHeiGenCache m_HeightGen;

src/Generating/DungeonRoomsFinisher.cpp

@@ -287,9 +287,9 @@ protected:
 ////////////////////////////////////////////////////////////////////////////////
 // cDungeonRoomsFinisher:
 
-cDungeonRoomsFinisher::cDungeonRoomsFinisher(cTerrainShapeGenPtr a_ShapeGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib) :
+cDungeonRoomsFinisher::cDungeonRoomsFinisher(cTerrainShapeGen & a_ShapeGen, 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_ShapeGen(std::move(a_ShapeGen)),
+	m_ShapeGen(a_ShapeGen),
 	m_MaxHalfSize((a_MaxSize + 1) / 2),
 	m_MinHalfSize((a_MinSize + 1) / 2),
 	m_HeightProbability(cChunkDef::Height)
@@ -322,7 +322,7 @@ cDungeonRoomsFinisher::cStructurePtr cDungeonRoomsFinisher::CreateStructure(int
 	int RelX = a_OriginX, RelY = 0, RelZ = a_OriginZ;
 	cChunkDef::AbsoluteToRelative(RelX, RelY, RelZ, ChunkX, ChunkZ);
 	cChunkDesc::Shape shape;
-	m_ShapeGen->GenShape({ChunkX, ChunkZ}, shape);
+	m_ShapeGen.GenShape({ChunkX, ChunkZ}, shape);
 	int height = 0;
 	int idx = RelX * 256 + RelZ * 16 * 256;
 	for (int y = 6; y < cChunkDef::Height; y++)
@@ -337,7 +337,3 @@ cDungeonRoomsFinisher::cStructurePtr cDungeonRoomsFinisher::CreateStructure(int
 	// Create the dungeon room descriptor:
 	return cStructurePtr(new cDungeonRoom(a_GridX, a_GridZ, a_OriginX, a_OriginZ, HalfSizeX, HalfSizeZ, height, m_Noise));
 }
-
-
-
-

src/Generating/DungeonRoomsFinisher.h

@@ -27,12 +27,12 @@ public:
 	a_ShapeGen is the underlying terrain shape 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(cTerrainShapeGenPtr a_ShapeGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib);
+	cDungeonRoomsFinisher(cTerrainShapeGen & a_ShapeGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib);
 
 protected:
 
 	/** The shape gen that is used for limiting the rooms' Y coords */
-	cTerrainShapeGenPtr m_ShapeGen;
+	cTerrainShapeGen & m_ShapeGen;
 
 	/** Maximum half-size (from center to wall) of the dungeon room's inner (air) area. Default is 3 (vanilla). */
 	int m_MaxHalfSize;
@@ -47,7 +47,3 @@ protected:
 	// cGridStructGen overrides:
 	virtual cStructurePtr CreateStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ) override;
 } ;
-
-
-
-

src/Generating/HeiGen.cpp

@@ -106,8 +106,8 @@ void cHeiGenFlat::InitializeHeightGen(cIniFile & a_IniFile)
 ////////////////////////////////////////////////////////////////////////////////
 // cHeiGenCache:
 
-cHeiGenCache::cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_CacheSize) :
+cHeiGenCache::cHeiGenCache(cTerrainHeightGen & a_HeiGenToCache, size_t a_CacheSize) :
-	m_HeiGenToCache(std::move(a_HeiGenToCache)),
+	m_HeiGenToCache(a_HeiGenToCache),
 	m_CacheSize(a_CacheSize),
 	m_NumHits(0),
 	m_NumMisses(0),
@@ -161,7 +161,7 @@ void cHeiGenCache::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap
 
 	// Not in the cache:
 	m_NumMisses++;
-	m_HeiGenToCache->GenHeightMap(a_ChunkCoords, a_HeightMap);
+	m_HeiGenToCache.GenHeightMap(a_ChunkCoords, a_HeightMap);
 
 	// Insert it as the first item in the MRU order:
 	auto Idx = m_CacheOrder[m_CacheSize - 1];
@@ -219,14 +219,15 @@ bool cHeiGenCache::GetHeightAt(int a_ChunkX, int a_ChunkZ, int a_RelX, int a_Rel
 ////////////////////////////////////////////////////////////////////////////////
 // cHeiGenMultiCache:
 
-cHeiGenMultiCache::cHeiGenMultiCache(const cTerrainHeightGenPtr & a_HeiGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches):
+cHeiGenMultiCache::cHeiGenMultiCache(std::unique_ptr<cTerrainHeightGen> a_HeiGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches):
-	m_NumSubCaches(a_NumSubCaches)
+	m_NumSubCaches(a_NumSubCaches),
+	m_Underlying(std::move(a_HeiGenToCache))
 {
 	// Create the individual sub-caches:
 	m_SubCaches.reserve(a_NumSubCaches);
 	for (size_t i = 0; i < a_NumSubCaches; i++)
 	{
-		m_SubCaches.emplace_back(std::make_shared<cHeiGenCache>(a_HeiGenToCache, a_SubCacheSize));
+		m_SubCaches.push_back(std::make_unique<cHeiGenCache>(*m_Underlying, a_SubCacheSize));
 	}
 }
 
@@ -517,7 +518,7 @@ void cHeiGenBiomal::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMa
 	{
 		for (int x = -1; x <= 1; x++)
 		{
-			m_BiomeGen->GenBiomes({a_ChunkCoords.m_ChunkX + x, a_ChunkCoords.m_ChunkZ + z}, Biomes[x + 1][z + 1]);
+			m_BiomeGen.GenBiomes({a_ChunkCoords.m_ChunkX + x, a_ChunkCoords.m_ChunkZ + z}, Biomes[x + 1][z + 1]);
 		}  // for x
 	}  // for z
 
@@ -636,9 +637,9 @@ class cHeiGenMinMax:
 
 public:
 
-	cHeiGenMinMax(int a_Seed, cBiomeGenPtr a_BiomeGen):
+	cHeiGenMinMax(int a_Seed, cBiomeGen & a_BiomeGen):
 		m_Noise(a_Seed),
-		m_BiomeGen(std::move(a_BiomeGen)),
+		m_BiomeGen(a_BiomeGen),
 		m_TotalWeight(0)
 	{
 		// Initialize the weights:
@@ -664,7 +665,7 @@ public:
 		cChunkDef::BiomeMap neighborBiomes[3][3];
 		for (int z = 0; z < 3; z++) for (int x = 0; x < 3; x++)
 		{
-			m_BiomeGen->GenBiomes({a_ChunkCoords.m_ChunkX + x - 1, a_ChunkCoords.m_ChunkZ + z - 1}, neighborBiomes[z][x]);
+			m_BiomeGen.GenBiomes({a_ChunkCoords.m_ChunkX + x - 1, a_ChunkCoords.m_ChunkZ + z - 1}, neighborBiomes[z][x]);
 		}
 
 		// Get the min and max heights based on the biomes:
@@ -735,7 +736,7 @@ protected:
 	cPerlinNoise m_Perlin;
 
 	/** The biome generator to query for the underlying biomes. */
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	/** Weights applied to each of the min / max values in the neighborhood of the currently evaluated column. */
 	double m_Weights[AVERAGING_SIZE * 2 + 1][AVERAGING_SIZE * 2 + 1];
@@ -831,7 +832,7 @@ protected:
 ////////////////////////////////////////////////////////////////////////////////
 // cTerrainHeightGen:
 
-cTerrainHeightGenPtr cTerrainHeightGen::CreateHeightGen(cIniFile & a_IniFile, const cBiomeGenPtr & a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault)
+std::unique_ptr<cTerrainHeightGen> cTerrainHeightGen::CreateHeightGen(cIniFile & a_IniFile, cBiomeGen & a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault)
 {
 	AString HeightGenName = a_IniFile.GetValueSet("Generator", "HeightGen", "");
 	if (HeightGenName.empty())
@@ -841,55 +842,55 @@ cTerrainHeightGenPtr cTerrainHeightGen::CreateHeightGen(cIniFile & a_IniFile, co
 	}
 
 	a_CacheOffByDefault = false;
-	cTerrainHeightGenPtr res;
+	std::unique_ptr<cTerrainHeightGen> res;
 	if (NoCaseCompare(HeightGenName, "Flat") == 0)
 	{
-		res = std::make_shared<cHeiGenFlat>();
+		res = std::make_unique<cHeiGenFlat>();
 		a_CacheOffByDefault = true;  // We're generating faster than a cache would retrieve data
 	}
 	else if (NoCaseCompare(HeightGenName, "classic") == 0)
 	{
-		res = std::make_shared<cHeiGenClassic>(a_Seed);
+		res = std::make_unique<cHeiGenClassic>(a_Seed);
 	}
 	else if (NoCaseCompare(HeightGenName, "DistortedHeightmap") == 0)
 	{
 		// Not a heightmap-based generator, but it used to be accessible via HeightGen, so we need to skip making the default out of it
 		// Return an empty pointer, the caller will create the proper generator:
-		return cTerrainHeightGenPtr();
+		return nullptr;
 	}
 	else if (NoCaseCompare(HeightGenName, "End") == 0)
 	{
 		// Not a heightmap-based generator, but it used to be accessible via HeightGen, so we need to skip making the default out of it
 		// Return an empty pointer, the caller will create the proper generator:
-		return cTerrainHeightGenPtr();
+		return nullptr;
 	}
 	else if (NoCaseCompare(HeightGenName, "MinMax") == 0)
 	{
-		res = std::make_shared<cHeiGenMinMax>(a_Seed, a_BiomeGen);
+		res = std::make_unique<cHeiGenMinMax>(a_Seed, a_BiomeGen);
 	}
 	else if (NoCaseCompare(HeightGenName, "Mountains") == 0)
 	{
-		res = std::make_shared<cHeiGenMountains>(a_Seed);
+		res = std::make_unique<cHeiGenMountains>(a_Seed);
 	}
 	else if (NoCaseCompare(HeightGenName, "BiomalNoise3D") == 0)
 	{
 		// Not a heightmap-based generator, but it used to be accessible via HeightGen, so we need to skip making the default out of it
 		// Return an empty pointer, the caller will create the proper generator:
-		return cTerrainHeightGenPtr();
+		return nullptr;
 	}
 	else if (NoCaseCompare(HeightGenName, "Steppy") == 0)
 	{
-		res = std::make_shared<cHeiGenSteppy>(a_Seed);
+		res = std::make_unique<cHeiGenSteppy>(a_Seed);
 	}
 	else if (NoCaseCompare(HeightGenName, "Noise3D") == 0)
 	{
 		// Not a heightmap-based generator, but it used to be accessible via HeightGen, so we need to skip making the default out of it
 		// Return an empty pointer, the caller will create the proper generator:
-		return cTerrainHeightGenPtr();
+		return nullptr;
 	}
 	else if (NoCaseCompare(HeightGenName, "Biomal") == 0)
 	{
-		res = std::make_shared<cHeiGenBiomal>(a_Seed, a_BiomeGen);
+		res = std::make_unique<cHeiGenBiomal>(a_Seed, a_BiomeGen);
 
 		/*
 		// Performance-testing:

src/Generating/HeiGen.h

@@ -28,8 +28,7 @@ class cHeiGenCache :
 	public cTerrainHeightGen
 {
 public:
-	cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_CacheSize);
+	cHeiGenCache(cTerrainHeightGen & a_HeiGenToCache, size_t a_CacheSize);
-	virtual ~cHeiGenCache() override = default;
 
 	// cTerrainHeightGen overrides:
 	virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap) override;
@@ -51,7 +50,7 @@ protected:
 	} ;
 
 	/** The terrain height generator that is being cached. */
-	cTerrainHeightGenPtr m_HeiGenToCache;
+	cTerrainHeightGen & m_HeiGenToCache;
 
 	// To avoid moving large amounts of data for the MRU behavior, we MRU-ize indices to an array of the actual data
 	size_t                  m_CacheSize;
@@ -73,7 +72,7 @@ class cHeiGenMultiCache:
 	public cTerrainHeightGen
 {
 public:
-	cHeiGenMultiCache(const cTerrainHeightGenPtr & a_HeightGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches);
+	cHeiGenMultiCache(std::unique_ptr<cTerrainHeightGen> a_HeightGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches);
 
 	// cTerrainHeightGen overrides:
 	virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap) override;
@@ -83,9 +82,6 @@ public:
 	bool GetHeightAt(int a_ChunkX, int a_ChunkZ, int a_RelX, int a_RelZ, HEIGHTTYPE & a_Height);
 
 protected:
-	typedef std::shared_ptr<cHeiGenCache> cHeiGenCachePtr;
-	typedef std::vector<cHeiGenCachePtr> cHeiGenCachePtrs;
-
 
 	/** The coefficient used to turn Z coords into index (x + Coeff * z). */
 	static const size_t m_CoeffZ = 5;
@@ -94,7 +90,10 @@ protected:
 	size_t m_NumSubCaches;
 
 	/** The individual sub-caches. */
-	cHeiGenCachePtrs m_SubCaches;
+	std::vector<std::unique_ptr<cHeiGenCache>> m_SubCaches;
+
+	/** The underlying height generator. */
+	std::unique_ptr<cTerrainHeightGen> m_Underlying;
 };
 
 
@@ -174,9 +173,9 @@ class cHeiGenBiomal:
 
 public:
 
-	cHeiGenBiomal(int a_Seed, cBiomeGenPtr a_BiomeGen):
+	cHeiGenBiomal(int a_Seed, cBiomeGen & a_BiomeGen):
 		m_Noise(a_Seed),
-		m_BiomeGen(std::move(a_BiomeGen))
+		m_BiomeGen(a_BiomeGen)
 	{
 	}
 
@@ -192,8 +191,8 @@ protected:
 
 	typedef cChunkDef::BiomeMap BiomeNeighbors[3][3];
 
-	cNoise       m_Noise;
+	cNoise m_Noise;
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	// Per-biome terrain generator parameters:
 	struct sGenParam
@@ -208,7 +207,3 @@ protected:
 
 	NOISE_DATATYPE GetHeightAt(int a_RelX, int a_RelZ, int a_ChunkX, int a_ChunkZ, const BiomeNeighbors & a_BiomeNeighbors);
 } ;
-
-
-
-

src/Generating/Noise3DGenerator.cpp

@@ -506,12 +506,12 @@ void cNoise3DComposable::GenShape(cChunkCoords a_ChunkCoords, cChunkDesc::Shape
 ////////////////////////////////////////////////////////////////////////////////
 // cBiomalNoise3DComposable:
 
-cBiomalNoise3DComposable::cBiomalNoise3DComposable(int a_Seed, cBiomeGenPtr a_BiomeGen) :
+cBiomalNoise3DComposable::cBiomalNoise3DComposable(int a_Seed, cBiomeGen & a_BiomeGen) :
 	m_ChoiceNoise(a_Seed),
 	m_DensityNoiseA(a_Seed + 1),
 	m_DensityNoiseB(a_Seed + 2),
 	m_BaseNoise(a_Seed + 3),
-	m_BiomeGen(std::move(a_BiomeGen)),
+	m_BiomeGen(a_BiomeGen),
 	m_LastChunkCoords(0x7fffffff, 0x7fffffff)  // Set impossible coords for the chunk so that it's always considered stale
 {
 	// Generate the weight distribution for summing up neighboring biomes:
@@ -654,7 +654,7 @@ void cBiomalNoise3DComposable::CalcBiomeParamArrays(cChunkCoords a_ChunkCoords,
 	{
 		for (int x = 0; x < 3; x++)
 		{
-			m_BiomeGen->GenBiomes({a_ChunkCoords.m_ChunkX + x - 1, a_ChunkCoords.m_ChunkZ + z - 1}, neighborBiomes[x + 3 * z]);
+			m_BiomeGen.GenBiomes({a_ChunkCoords.m_ChunkX + x - 1, a_ChunkCoords.m_ChunkZ + z - 1}, neighborBiomes[x + 3 * z]);
 		}
 	}
 
@@ -791,8 +791,3 @@ void cBiomalNoise3DComposable::GenShape(cChunkCoords a_ChunkCoords, cChunkDesc::
 		}  // for x
 	}  // for z
 }
-
-
-
-
-

src/Generating/Noise3DGenerator.h

@@ -136,7 +136,7 @@ class cBiomalNoise3DComposable :
 	public cTerrainShapeGen
 {
 public:
-	cBiomalNoise3DComposable(int a_Seed, cBiomeGenPtr a_BiomeGen);
+	cBiomalNoise3DComposable(int a_Seed, cBiomeGen & a_BiomeGen);
 
 	void Initialize(cIniFile & a_IniFile);
 
@@ -161,7 +161,7 @@ protected:
 	cOctavedNoise<cInterpolNoise<Interp5Deg>> m_BaseNoise;
 
 	/** The underlying biome generator. */
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	/** Block height of the sealevel, used for composing the terrain. */
 	int m_SeaLevel;
@@ -207,7 +207,3 @@ protected:
 	virtual void GenShape(cChunkCoords a_ChunkCoords, cChunkDesc::Shape & a_Shape) override;
 	virtual void InitializeShapeGen(cIniFile & a_IniFile) override { Initialize(a_IniFile); }
 } ;
-
-
-
-

src/Generating/PiecePool.h

@@ -115,7 +115,7 @@ public:
 
 		/** Called when the piece pool is assigned to a generator,
 		so that the strategies may bind to the underlying subgenerators. */
-		virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) {}
+		virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) {}
 	};
 
 	typedef std::shared_ptr<cVerticalStrategy> cVerticalStrategyPtr;
@@ -142,7 +142,7 @@ public:
 
 		/** Called when the piece pool is assigned to a generator,
 		so that the limits may bind to the underlying subgenerators. */
-		virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) {}
+		virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) {}
 	};
 
 	typedef std::shared_ptr<cVerticalLimit> cVerticalLimitPtr;
@@ -328,8 +328,3 @@ protected:
 
 typedef std::unique_ptr<cPlacedPiece> cPlacedPiecePtr;
 typedef std::vector<cPlacedPiecePtr> cPlacedPieces;
-
-
-
-
-

src/Generating/PieceStructuresGen.cpp

@@ -20,10 +20,10 @@ class cPieceStructuresGen::cGen:
 
 public:
 
-	cGen(int a_Seed, cBiomeGenPtr a_BiomeGen, cTerrainHeightGenPtr a_HeightGen, int a_SeaLevel, const AString & a_Name):
+	cGen(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_SeaLevel, const AString & a_Name):
 		Super(a_Seed),
-		m_BiomeGen(std::move(a_BiomeGen)),
+		m_BiomeGen(a_BiomeGen),
-		m_HeightGen(std::move(a_HeightGen)),
+		m_HeightGen(a_HeightGen),
 		m_SeaLevel(a_SeaLevel),
 		m_Name(a_Name),
 		m_MaxDepth(5)
@@ -95,10 +95,10 @@ protected:
 	typedef std::vector<cFreeConnector> cFreeConnectors;
 
 	/** The underlying biome generator that defines whether the structure is created or not */
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	/** The underlying height generator, used to position the prefabs crossing chunk borders if they are set to FitGround. */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen & m_HeightGen;
 
 	/** The world's sea level, if available. Used for some cVerticalStrategy descendants. */
 	int m_SeaLevel;
@@ -129,7 +129,7 @@ cPieceStructuresGen::cPieceStructuresGen(int a_Seed):
 
 
 
-bool cPieceStructuresGen::Initialize(const AString & a_Prefabs, int a_SeaLevel, const cBiomeGenPtr & a_BiomeGen, const cTerrainHeightGenPtr & a_HeightGen)
+bool cPieceStructuresGen::Initialize(const AString & a_Prefabs, int a_SeaLevel, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen)
 {
 	// Load each piecepool:
 	auto Structures = StringSplitAndTrim(a_Prefabs, "|");
@@ -172,8 +172,3 @@ void cPieceStructuresGen::GenFinish(cChunkDesc & a_Chunk)
 		Gen->GenFinish(a_Chunk);
 	}
 }
-
-
-
-
-

src/Generating/PieceStructuresGen.h

@@ -34,7 +34,7 @@ public:
 	a_Prefabs contains the list of prefab sets that should be activated, "|"-separated.
 	All problems are logged to the console and the generator skips over them.
 	Returns true if at least one prefab set is valid (the generator should be kept). */
-	bool Initialize(const AString & a_Prefabs, int a_SeaLevel, const cBiomeGenPtr & a_BiomeGen, const cTerrainHeightGenPtr & a_HeightGen);
+	bool Initialize(const AString & a_Prefabs, int a_SeaLevel, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen);
 
 	// cFinishGen override:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
@@ -54,7 +54,3 @@ protected:
 	/** The seed for the random number generator */
 	int m_Seed;
 };
-
-
-
-

src/Generating/PrefabPiecePool.cpp

@@ -724,7 +724,7 @@ AString cPrefabPiecePool::GetMetadata(const AString & a_ParamName) const
 
 
 
-void cPrefabPiecePool::AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_HeightGen, int a_SeaLevel)
+void cPrefabPiecePool::AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_SeaLevel)
 {
 	// Assign the generator linkage to all starting pieces' VerticalStrategies:
 	for (auto & piece: m_StartingPieces)
@@ -808,7 +808,3 @@ void cPrefabPiecePool::Reset(void)
 {
 	// Do nothing
 }
-
-
-
-

src/Generating/PrefabPiecePool.h

@@ -108,7 +108,7 @@ public:
 
 	/** Called when the piece pool is assigned to a generator,
 	so that the individual starting pieces' vertical strategies may bind to the underlying subgenerators. */
-	void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_HeightGen, int a_SeaLevel);
+	void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_SeaLevel);
 
 	// cPiecePool overrides:
 	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;

src/Generating/PrefabStructure.cpp

@@ -15,11 +15,11 @@ cPrefabStructure::cPrefabStructure(
 	int a_GridX, int a_GridZ,
 	int a_OriginX, int a_OriginZ,
 	cPlacedPieces && a_Pieces,
-	cTerrainHeightGenPtr a_HeightGen
+	cTerrainHeightGen & a_HeightGen
 ):
 	Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
 	m_Pieces(std::move(a_Pieces)),
-	m_HeightGen(std::move(a_HeightGen))
+	m_HeightGen(a_HeightGen)
 {
 }
 
@@ -55,11 +55,7 @@ void cPrefabStructure::PlacePieceOnGround(cPlacedPiece & a_Piece)
 	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);
 }
-
-
-
-

src/Generating/PrefabStructure.h

@@ -27,7 +27,7 @@ public:
 		int a_GridX, int a_GridZ,
 		int a_OriginX, int a_OriginZ,
 		cPlacedPieces && a_Pieces,
-		cTerrainHeightGenPtr a_HeightGen
+		cTerrainHeightGen & a_HeightGen
 	);
 
 protected:
@@ -35,7 +35,7 @@ protected:
 	cPlacedPieces m_Pieces;
 
 	/** The height generator used when adjusting pieces onto the ground. */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen & m_HeightGen;
 
 
 	// cGridStructGen::cStructure overrides:
@@ -45,7 +45,3 @@ protected:
 	Ground level is assumed to be represented by the first connector in the piece. */
 	void PlacePieceOnGround(cPlacedPiece & a_Piece);
 };
-
-
-
-

src/Generating/ShapeGen.cpp

@@ -23,7 +23,7 @@ class cTerrainHeightToShapeGen:
 	public cTerrainShapeGen
 {
 public:
-	cTerrainHeightToShapeGen(cTerrainHeightGenPtr a_HeightGen):
+	cTerrainHeightToShapeGen(std::unique_ptr<cTerrainHeightGen> a_HeightGen):
 		m_HeightGen(std::move(a_HeightGen))
 	{
 	}
@@ -63,7 +63,7 @@ public:
 
 protected:
 	/** The height generator being converted. */
-	cTerrainHeightGenPtr m_HeightGen;
+	std::unique_ptr<cTerrainHeightGen> m_HeightGen;
 };
 
 typedef std::shared_ptr<cTerrainHeightToShapeGen> cTerrainHeightToShapeGenPtr;
@@ -75,9 +75,9 @@ typedef std::shared_ptr<cTerrainHeightToShapeGen> cTerrainHeightToShapeGenPtr;
 ////////////////////////////////////////////////////////////////////////////////
 // cTerrainShapeGen:
 
-cTerrainShapeGenPtr cTerrainShapeGen::CreateShapeGen(
+std::unique_ptr<cTerrainShapeGen> cTerrainShapeGen::CreateShapeGen(
 	cIniFile & a_IniFile,
-	const cBiomeGenPtr & a_BiomeGen,
+	cBiomeGen & a_BiomeGen,
 	int a_Seed,
 	bool & a_CacheOffByDefault
 )
@@ -92,10 +92,10 @@ cTerrainShapeGenPtr cTerrainShapeGen::CreateShapeGen(
 	// If the shapegen is HeightMap, redirect to older HeightMap-based generators:
 	if (NoCaseCompare(shapeGenName, "HeightMap") == 0)
 	{
-		cTerrainHeightGenPtr heightGen = cTerrainHeightGen::CreateHeightGen(a_IniFile, a_BiomeGen, a_Seed, a_CacheOffByDefault);
+		auto heightGen = cTerrainHeightGen::CreateHeightGen(a_IniFile, a_BiomeGen, a_Seed, a_CacheOffByDefault);
 		if (heightGen != nullptr)
 		{
-			return std::make_shared<cTerrainHeightToShapeGen>(heightGen);
+			return std::make_unique<cTerrainHeightToShapeGen>(std::move(heightGen));
 		}
 
 		// The height gen was not recognized; several heightgens were promoted to shape gens, so let's try them instead:
@@ -110,22 +110,22 @@ cTerrainShapeGenPtr cTerrainShapeGen::CreateShapeGen(
 
 	// Choose the shape generator based on the name:
 	a_CacheOffByDefault = false;
-	cTerrainShapeGenPtr res;
+	std::unique_ptr<cTerrainShapeGen> res;
 	if (NoCaseCompare(shapeGenName, "DistortedHeightmap") == 0)
 	{
-		res = std::make_shared<cDistortedHeightmap>(a_Seed, a_BiomeGen);
+		res = std::make_unique<cDistortedHeightmap>(a_Seed, a_BiomeGen);
 	}
 	else if (NoCaseCompare(shapeGenName, "End") == 0)
 	{
-		res = std::make_shared<cEndGen>(a_Seed);
+		res = std::make_unique<cEndGen>(a_Seed);
 	}
 	else if (NoCaseCompare(shapeGenName, "BiomalNoise3D") == 0)
 	{
-		res = std::make_shared<cBiomalNoise3DComposable>(a_Seed, a_BiomeGen);
+		res = std::make_unique<cBiomalNoise3DComposable>(a_Seed, a_BiomeGen);
 	}
 	else if (NoCaseCompare(shapeGenName, "Noise3D") == 0)
 	{
-		res = std::make_shared<cNoise3DComposable>(a_Seed);
+		res = std::make_unique<cNoise3DComposable>(a_Seed);
 	}
 	else if (NoCaseCompare(shapeGenName, "TwoHeights") == 0)
 	{
@@ -144,7 +144,3 @@ cTerrainShapeGenPtr cTerrainShapeGen::CreateShapeGen(
 
 	return res;
 }
-
-
-
-

src/Generating/SinglePieceStructuresGen.cpp

@@ -14,10 +14,10 @@ class cSinglePieceStructuresGen::cGen :
 {
 	using Super = cGridStructGen;
 public:
-	cGen(int a_Seed, cBiomeGenPtr a_BiomeGen, cTerrainHeightGenPtr a_HeightGen, int a_SeaLevel, const AString & a_Name):
+	cGen(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_SeaLevel, const AString & a_Name):
 		Super(a_Seed),
-		m_BiomeGen(std::move(a_BiomeGen)),
+		m_BiomeGen(a_BiomeGen),
-		m_HeightGen(std::move(a_HeightGen)),
+		m_HeightGen(a_HeightGen),
 		m_SeaLevel(a_SeaLevel),
 		m_Name(a_Name)
 	{
@@ -61,7 +61,7 @@ public:
 		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);
 
 		// Checks if the biome at the origin position is allowed
 		auto Relative = cChunkDef::AbsoluteToRelative(Vector3i(a_OriginX, 1, a_OriginZ), {ChunkX, ChunkZ});
@@ -132,10 +132,10 @@ public:
 
 protected:
 	/** The underlying biome generator that defines whether the structure is created or not */
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	/** The underlying height generator, used to position the prefabs crossing chunk borders if they are set to FitGround. */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen & m_HeightGen;
 
 	/** The world's sea level, if available. Used for some cVerticalStrategy descendants. */
 	int m_SeaLevel;
@@ -160,7 +160,7 @@ cSinglePieceStructuresGen::cSinglePieceStructuresGen(int a_Seed) :
 
 
 
-bool cSinglePieceStructuresGen::Initialize(const AString & a_Prefabs, int a_SeaLevel, const cBiomeGenPtr & a_BiomeGen, const cTerrainHeightGenPtr & a_HeightGen)
+bool cSinglePieceStructuresGen::Initialize(const AString & a_Prefabs, int a_SeaLevel, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen)
 {
 	// Load each piecepool:
 	auto Structures = StringSplitAndTrim(a_Prefabs, "|");

src/Generating/SinglePieceStructuresGen.h

@@ -30,7 +30,7 @@ public:
 	a_Prefabs contains the list of prefab sets that should be activated, "|"-separated.
 	All problems are logged to the console and the generator skips over them.
 	Returns true if at least one prefab set is valid (the generator should be kept). */
-	bool Initialize(const AString & a_Prefabs, int a_SeaLevel, const cBiomeGenPtr & a_BiomeGen, const cTerrainHeightGenPtr & a_HeightGen);
+	bool Initialize(const AString & a_Prefabs, int a_SeaLevel, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen);
 
 
 	// cFinishGen override:

src/Generating/StructGen.cpp

@@ -40,10 +40,10 @@ void cStructGenTrees::GenFinish(cChunkDesc & a_ChunkDesc)
 				// TODO: This may cause a lot of wasted calculations, instead of pulling data out of a single (cChunkDesc) cache
 
 				cChunkDesc::Shape workerShape;
-				m_BiomeGen->GenBiomes           ({BaseX, BaseZ}, WorkerDesc.GetBiomeMap());
+				m_BiomeGen.GenBiomes           ({BaseX, BaseZ}, WorkerDesc.GetBiomeMap());
-				m_ShapeGen->GenShape            ({BaseX, BaseZ}, workerShape);
+				m_ShapeGen.GenShape            ({BaseX, BaseZ}, workerShape);
-				WorkerDesc.SetHeightFromShape   (workerShape);
+				WorkerDesc.SetHeightFromShape  (workerShape);
-				m_CompositionGen->ComposeTerrain(WorkerDesc, workerShape);
+				m_CompositionGen.ComposeTerrain(WorkerDesc, workerShape);
 			}
 			else
 			{
@@ -575,7 +575,3 @@ void cStructGenDistortedMembraneOverhangs::GenFinish(cChunkDesc & a_ChunkDesc)
 		}  // for x
 	}  // for z
 }
-
-
-
-

src/Generating/StructGen.h

@@ -22,21 +22,21 @@ class cStructGenTrees :
 	public cFinishGen
 {
 public:
-	cStructGenTrees(int a_Seed, cBiomeGenPtr a_BiomeGen, cTerrainShapeGenPtr a_ShapeGen, cTerrainCompositionGenPtr a_CompositionGen) :
+	cStructGenTrees(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainShapeGen & a_ShapeGen, cTerrainCompositionGen & a_CompositionGen) :
 		m_Seed(a_Seed),
 		m_Noise(a_Seed),
-		m_BiomeGen(std::move(a_BiomeGen)),
+		m_BiomeGen(a_BiomeGen),
-		m_ShapeGen(std::move(a_ShapeGen)),
+		m_ShapeGen(a_ShapeGen),
-		m_CompositionGen(std::move(a_CompositionGen))
+		m_CompositionGen(a_CompositionGen)
 	{}
 
 protected:
 
 	int m_Seed;
 	cNoise m_Noise;
-	cBiomeGenPtr              m_BiomeGen;
+	cBiomeGen &              m_BiomeGen;
-	cTerrainShapeGenPtr       m_ShapeGen;
+	cTerrainShapeGen &       m_ShapeGen;
-	cTerrainCompositionGenPtr m_CompositionGen;
+	cTerrainCompositionGen & m_CompositionGen;
 
 	/** Generates and applies an image of a single tree.
 	Parts of the tree inside the chunk are applied to a_ChunkDesc.
@@ -78,20 +78,20 @@ class cStructGenLakes :
 	public cFinishGen
 {
 public:
-	cStructGenLakes(int a_Seed, BLOCKTYPE a_Fluid, cTerrainShapeGenPtr a_ShapeGen, int a_Probability) :
+	cStructGenLakes(int a_Seed, BLOCKTYPE a_Fluid, cTerrainShapeGen & a_ShapeGen, int a_Probability) :
 		m_Noise(a_Seed),
 		m_Seed(a_Seed),
 		m_Fluid(a_Fluid),
-		m_ShapeGen(std::move(a_ShapeGen)),
+		m_ShapeGen(a_ShapeGen),
 		m_Probability(a_Probability)
 	{
 	}
 
 protected:
-	cNoise              m_Noise;
+	cNoise             m_Noise;
-	int                 m_Seed;
+	int                m_Seed;
-	BLOCKTYPE           m_Fluid;
+	BLOCKTYPE          m_Fluid;
-	cTerrainShapeGenPtr m_ShapeGen;
+	cTerrainShapeGen & m_ShapeGen;
 
 	/** Chance, [0 .. 100], of a chunk having the lake. */
 	int m_Probability;
@@ -143,7 +143,3 @@ protected:
 	// cFinishGen override:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
-
-
-
-

src/Generating/TwoHeights.cpp

@@ -21,7 +21,7 @@ class cTwoHeights:
 
 public:
 
-	cTwoHeights(int a_Seed, const cBiomeGenPtr & a_BiomeGen):
+	cTwoHeights(int a_Seed, cBiomeGen & a_BiomeGen):
 		m_Seed(a_Seed),
 		m_Choice(a_Seed),
 		m_HeightA(a_Seed + 1, a_BiomeGen),
@@ -113,11 +113,7 @@ protected:
 
 
 
-cTerrainShapeGenPtr CreateShapeGenTwoHeights(int a_Seed, const cBiomeGenPtr & a_BiomeGen)
+std::unique_ptr<cTerrainShapeGen> CreateShapeGenTwoHeights(int a_Seed, cBiomeGen & a_BiomeGen)
 {
-	return std::make_shared<cTwoHeights>(a_Seed, a_BiomeGen);
+	return std::make_unique<cTwoHeights>(a_Seed, a_BiomeGen);
 }
-
-
-
-

src/Generating/TwoHeights.h

@@ -16,8 +16,4 @@
 
 /** Creates and returns a new instance of the cTwoHeights terrain shape generator.
 The instance must be Initialize()-d before it is used. */
-extern cTerrainShapeGenPtr CreateShapeGenTwoHeights(int a_Seed, const cBiomeGenPtr & a_BiomeGen);
+extern std::unique_ptr<cTerrainShapeGen> CreateShapeGenTwoHeights(int a_Seed, cBiomeGen & a_BiomeGen);
-
-
-
-

src/Generating/VerticalLimit.cpp

@@ -133,6 +133,7 @@ class cVerticalLimitAboveTerrain:
 public:
 	virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
 	{
+		ASSERT(m_TerrainHeightGen != nullptr);
 		auto terrainHeight = m_TerrainHeightGen->GetHeightAt(a_BlockX, a_BlockZ);
 		int compareHeight = a_Height - terrainHeight;
 		return (
@@ -151,14 +152,14 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
 	{
-		m_TerrainHeightGen = a_TerrainHeightGen;
+		m_TerrainHeightGen = &a_TerrainHeightGen;
 	}
 
 protected:
 	/** The underlying height generator. */
-	cTerrainHeightGenPtr m_TerrainHeightGen;
+	cTerrainHeightGen * m_TerrainHeightGen;
 
 	/** How many blocks above the terrain level do we accept on minimum. */
 	int m_MinBlocksAbove;
@@ -198,15 +199,15 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
 	{
-		m_TerrainHeightGen = a_TerrainHeightGen;
+		m_TerrainHeightGen = &a_TerrainHeightGen;
 		m_SeaLevel = a_SeaLevel;
 	}
 
 protected:
 	/** The underlying height generator. */
-	cTerrainHeightGenPtr m_TerrainHeightGen;
+	cTerrainHeightGen * m_TerrainHeightGen;
 
 	/** The sealevel for the current world. */
 	int m_SeaLevel;
@@ -282,14 +283,14 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
 	{
-		m_TerrainHeightGen = a_TerrainHeightGen;
+		m_TerrainHeightGen = &a_TerrainHeightGen;
 	}
 
 protected:
 	/** The underlying height generator. */
-	cTerrainHeightGenPtr m_TerrainHeightGen;
+	cTerrainHeightGen * m_TerrainHeightGen;
 
 	/** How many blocks below the terrain level do we accept on minimum. */
 	int m_MinBlocksBelow;
@@ -328,15 +329,15 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
 	{
-		m_TerrainHeightGen = a_TerrainHeightGen;
+		m_TerrainHeightGen = &a_TerrainHeightGen;
 		m_SeaLevel = a_SeaLevel;
 	}
 
 protected:
 	/** The underlying height generator. */
-	cTerrainHeightGenPtr m_TerrainHeightGen;
+	cTerrainHeightGen * m_TerrainHeightGen;
 
 	/** The sealevel for the current world. */
 	int m_SeaLevel;
@@ -413,7 +414,3 @@ cPiece::cVerticalLimitPtr CreateVerticalLimitFromString(const AString & a_LimitD
 
 	return Limit;
 }
-
-
-
-

src/Generating/VerticalStrategy.cpp

@@ -162,7 +162,7 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_TerrainHeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
 	{
 		m_Seed = a_Seed + SEED_OFFSET;
 	}
@@ -209,10 +209,10 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_HeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_SeaLevel) override
 	{
 		m_Seed = a_Seed + SEED_OFFSET;
-		m_HeightGen = a_HeightGen;
+		m_HeightGen = &a_HeightGen;
 	}
 
 protected:
@@ -220,7 +220,7 @@ protected:
 	int m_Seed;
 
 	/** Height generator from which the top of the terrain is read. */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen * m_HeightGen;
 
 	/** Minimum relative height at which the prefab is placed. */
 	int m_MinRelHeight;
@@ -265,10 +265,10 @@ public:
 	}
 
 
-	virtual void AssignGens(int a_Seed, cBiomeGenPtr & a_BiomeGen, cTerrainHeightGenPtr & a_HeightGen, int a_SeaLevel) override
+	virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_HeightGen, int a_SeaLevel) override
 	{
 		m_Seed = a_Seed + SEED_OFFSET;
-		m_HeightGen = a_HeightGen;
+		m_HeightGen = &a_HeightGen;
 		m_SeaLevel = a_SeaLevel;
 	}
 
@@ -277,7 +277,7 @@ protected:
 	int m_Seed;
 
 	/** Height generator from which the top of the terrain is read. */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen * m_HeightGen;
 
 	/** The sea level used by the world. */
 	int m_SeaLevel;
@@ -342,7 +342,3 @@ cPiece::cVerticalStrategyPtr CreateVerticalStrategyFromString(const AString & a_
 
 	return Strategy;
 }
-
-
-
-

src/Generating/VillageGen.cpp

@@ -125,7 +125,7 @@ public:
 		int a_MaxSize,
 		int a_Density,
 		cVillagePiecePool & a_Prefabs,
-		cTerrainHeightGenPtr a_HeightGen
+		cTerrainHeightGen & a_HeightGen
 	):
 		Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
 		m_Seed(a_Seed),
@@ -137,7 +137,7 @@ public:
 			{a_OriginX + a_MaxSize, cChunkDef::Height - 1, a_OriginZ + a_MaxSize}
 		),
 		m_Prefabs(a_Prefabs),
-		m_HeightGen(std::move(a_HeightGen))
+		m_HeightGen(a_HeightGen)
 	{
 		// Generate the pieces for this village; don't care about the Y coord:
 		cPieceGeneratorBFSTree pg(*this, a_Seed);
@@ -169,7 +169,7 @@ protected:
 	cVillagePiecePool & m_Prefabs;
 
 	/** The underlying height generator, used for placing the structures on top of the terrain. */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen & m_HeightGen;
 
 	/** The village pieces, placed by the generator. */
 	cPlacedPieces m_Pieces;
@@ -182,7 +182,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.GetChunkCoords(), HeightMap);
+		m_HeightGen.GenHeightMap(a_Chunk.GetChunkCoords(), HeightMap);
 		for (cPlacedPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
 		{
 			const cPrefab & Prefab = static_cast<const cPrefab &>((*itr)->GetPiece());
@@ -212,7 +212,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);
 	}
@@ -337,8 +337,8 @@ cVillageGen::cVillageGen(
 	int a_MaxSize,
 	int a_MinDensity,
 	int a_MaxDensity,
-	cBiomeGenPtr a_BiomeGen,
+	cBiomeGen & a_BiomeGen,
-	cTerrainHeightGenPtr a_HeightGen,
+	cTerrainHeightGen & a_HeightGen,
 	int a_SeaLevel,
 	const AStringVector & a_PrefabsToLoad
 ) :
@@ -348,8 +348,8 @@ cVillageGen::cVillageGen(
 	m_MaxSize(a_MaxSize),
 	m_MinDensity(a_MinDensity),
 	m_MaxDensity(a_MaxDensity),
-	m_BiomeGen(std::move(a_BiomeGen)),
+	m_BiomeGen(a_BiomeGen),
-	m_HeightGen(std::move(a_HeightGen))
+	m_HeightGen(a_HeightGen)
 {
 	for (const auto & toLoad: a_PrefabsToLoad)
 	{
@@ -379,7 +379,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);
 
 	// Get a list of pools that support each biome within the chunk:
 	// If just one column's biome is not allowed, the pool is not used because it's likely that an unfriendly biome is too close
@@ -424,7 +424,3 @@ cGridStructGen::cStructurePtr cVillageGen::CreateStructure(int a_GridX, int a_Gr
 	// Create a village based on the chosen prefabs:
 	return cStructurePtr(new cVillage(m_Seed, a_GridX, a_GridZ, a_OriginX, a_OriginZ, m_MaxDepth, m_MaxSize, Density, *pool.get(), m_HeightGen));
 }
-
-
-
-

src/Generating/VillageGen.h

@@ -38,8 +38,8 @@ public:
 		int a_MaxDepth,
 		int a_MaxSize,
 		int a_MinDensity, int a_MaxDensity,
-		cBiomeGenPtr a_BiomeGen,
+		cBiomeGen & a_BiomeGen,
-		cTerrainHeightGenPtr a_HeightGen,
+		cTerrainHeightGen & a_HeightGen,
 		int a_SeaLevel,
 		const AStringVector & a_PrefabsToLoad
 	);
@@ -64,10 +64,10 @@ protected:
 	int m_MaxDensity;
 
 	/** The underlying biome generator that defines whether the village is created or not */
-	cBiomeGenPtr m_BiomeGen;
+	cBiomeGen & m_BiomeGen;
 
 	/** The underlying height generator, used to position the prefabs crossing chunk borders */
-	cTerrainHeightGenPtr m_HeightGen;
+	cTerrainHeightGen & m_HeightGen;
 
 	/** All available prefab sets. Each village gets one of these chosen randomly. */
 	cVillagePiecePools m_Pools;
@@ -76,7 +76,3 @@ protected:
 	// cGridStructGen overrides:
 	virtual cStructurePtr CreateStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ) override;
 } ;
-
-
-
-