summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/Generating/BioGen.cpp43
-rw-r--r--src/Generating/BioGen.h21
-rw-r--r--src/Generating/CompoGen.cpp6
-rw-r--r--src/Generating/CompoGen.h8
-rw-r--r--src/Generating/CompoGenBiomal.cpp7
-rw-r--r--src/Generating/CompoGenBiomal.h6
-rw-r--r--src/Generating/ComposableGenerator.cpp132
-rw-r--r--src/Generating/ComposableGenerator.h37
-rw-r--r--src/Generating/CompositedHeiGen.h24
-rw-r--r--src/Generating/DistortedHeightmap.cpp6
-rw-r--r--src/Generating/DistortedHeightmap.h6
-rw-r--r--src/Generating/DungeonRoomsFinisher.cpp10
-rw-r--r--src/Generating/DungeonRoomsFinisher.h8
-rw-r--r--src/Generating/HeiGen.cpp47
-rw-r--r--src/Generating/HeiGen.h27
-rw-r--r--src/Generating/Noise3DGenerator.cpp11
-rw-r--r--src/Generating/Noise3DGenerator.h8
-rw-r--r--src/Generating/PiecePool.h9
-rw-r--r--src/Generating/PieceStructuresGen.cpp17
-rw-r--r--src/Generating/PieceStructuresGen.h6
-rw-r--r--src/Generating/PrefabPiecePool.cpp6
-rw-r--r--src/Generating/PrefabPiecePool.h2
-rw-r--r--src/Generating/PrefabStructure.cpp10
-rw-r--r--src/Generating/PrefabStructure.h8
-rw-r--r--src/Generating/ShapeGen.cpp26
-rw-r--r--src/Generating/SinglePieceStructuresGen.cpp14
-rw-r--r--src/Generating/SinglePieceStructuresGen.h2
-rw-r--r--src/Generating/StructGen.cpp12
-rw-r--r--src/Generating/StructGen.h30
-rw-r--r--src/Generating/TwoHeights.cpp10
-rw-r--r--src/Generating/TwoHeights.h6
-rw-r--r--src/Generating/VerticalLimit.cpp29
-rw-r--r--src/Generating/VerticalStrategy.cpp18
-rw-r--r--src/Generating/VillageGen.cpp24
-rw-r--r--src/Generating/VillageGen.h12
35 files changed, 263 insertions, 385 deletions
diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index 9a97be006..74547800f 100644
--- a/src/Generating/BioGen.cpp
+++ b/src/Generating/BioGen.cpp
@@ -57,8 +57,8 @@ void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
////////////////////////////////////////////////////////////////////////////////
// cBioGenCache:
-cBioGenCache::cBioGenCache(cBiomeGenPtr a_BioGenToCache, size_t a_CacheSize) :
- m_BioGenToCache(std::move(a_BioGenToCache)),
+cBioGenCache::cBioGenCache(cBiomeGen & a_BioGenToCache, size_t a_CacheSize) :
+ 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) :
- m_NumSubCaches(a_NumSubCaches)
+cBioGenMulticache::cBioGenMulticache(std::unique_ptr<cBiomeGen> a_BioGenToCache, size_t a_SubCacheSize, size_t 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
-
-
-
-
diff --git a/src/Generating/BioGen.h b/src/Generating/BioGen.h
index c23c8ac46..3c630e396 100644
--- a/src/Generating/BioGen.h
+++ b/src/Generating/BioGen.h
@@ -49,13 +49,13 @@ class cBioGenCache:
public:
- cBioGenCache(cBiomeGenPtr a_BioGenToCache, size_t a_CacheSize);
- virtual ~cBioGenCache() override = default;
-
+ cBioGenCache(cBiomeGen & a_BioGenToCache, size_t a_CacheSize);
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);
} ;
-
-
-
-
diff --git a/src/Generating/CompoGen.cpp b/src/Generating/CompoGen.cpp
index 7cc8fa095..02786ede9 100644
--- a/src/Generating/CompoGen.cpp
+++ b/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);
}
-
-
-
-
diff --git a/src/Generating/CompoGen.h b/src/Generating/CompoGen.h
index bc15a2dcb..53154ec07 100644
--- a/src/Generating/CompoGen.h
+++ b/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)
} ;
-
-
-
-
diff --git a/src/Generating/CompoGenBiomal.cpp b/src/Generating/CompoGenBiomal.cpp
index 951cb1a64..967a4a89c 100644
--- a/src/Generating/CompoGenBiomal.cpp
+++ b/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);
}
-
-
-
diff --git a/src/Generating/CompoGenBiomal.h b/src/Generating/CompoGenBiomal.h
index a3a65d3dc..6248b19d4 100644
--- a/src/Generating/CompoGenBiomal.h
+++ b/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);
diff --git a/src/Generating/ComposableGenerator.cpp b/src/Generating/ComposableGenerator.cpp
index 0e637613b..d5c64e4c4 100644
--- a/src/Generating/ComposableGenerator.cpp
+++ b/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,
- const cTerrainShapeGenPtr & a_ShapeGen,
+ cBiomeGen & a_BiomeGen,
+ 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);
- } // for itr - m_FinishGens[]
+ Finisher->GenFinish(a_ChunkDesc);
+ }
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_ShapeGen,
+ *m_BiomeGen,
+ *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());
- gen->Initialize(a_IniFile, "DirtPockets");
- m_FinishGens.push_back(gen);
+ auto Gen = std::make_unique<cFinishGenOrePockets>(m_Seed + 1, cFinishGenOrePockets::DefaultNaturalPatches());
+ Gen->Initialize(a_IniFile, "DirtPockets");
+ 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());
- gen->Initialize(a_IniFile, "OrePockets");
- m_FinishGens.push_back(gen);
+ auto Gen = std::make_unique<cFinishGenOrePockets>(m_Seed + 2, cFinishGenOrePockets::DefaultOverworldOres());
+ Gen->Initialize(a_IniFile, "OrePockets");
+ 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);
- if (gen->Initialize(split[1], seaLevel, m_BiomeGen, m_CompositedHeightCache))
+ auto Gen = std::make_unique<cPieceStructuresGen>(m_Seed);
+ 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);
- if (Gen->Initialize(split[1], seaLevel, m_BiomeGen, m_CompositedHeightCache))
+ auto Gen = std::make_unique<cSinglePieceStructuresGen>(m_Seed);
+ 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[]
}
-
-
-
-
diff --git a/src/Generating/ComposableGenerator.h b/src/Generating/ComposableGenerator.h
index 661a7276b..4105fbf83 100644
--- a/src/Generating/ComposableGenerator.h
+++ b/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,
- const cTerrainShapeGenPtr & a_ShapeGen,
+ cBiomeGen & a_BiomeGen,
+ 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);
} ;
-
-
-
-
diff --git a/src/Generating/CompositedHeiGen.h b/src/Generating/CompositedHeiGen.h
index 400008d88..6107d33ae 100644
--- a/src/Generating/CompositedHeiGen.h
+++ b/src/Generating/CompositedHeiGen.h
@@ -20,10 +20,10 @@ class cCompositedHeiGen:
public cTerrainHeightGen
{
public:
- cCompositedHeiGen(cBiomeGenPtr a_BiomeGen, cTerrainShapeGenPtr a_ShapeGen, cTerrainCompositionGenPtr a_CompositionGen):
- m_BiomeGen(std::move(a_BiomeGen)),
- m_ShapeGen(std::move(a_ShapeGen)),
- m_CompositionGen(std::move(a_CompositionGen))
+ cCompositedHeiGen(cBiomeGen & a_BiomeGen, cTerrainShapeGen & a_ShapeGen, cTerrainCompositionGen & a_CompositionGen):
+ m_BiomeGen(a_BiomeGen),
+ m_ShapeGen(a_ShapeGen),
+ 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;
- cTerrainShapeGenPtr m_ShapeGen;
- cTerrainCompositionGenPtr m_CompositionGen;
+ cBiomeGen & m_BiomeGen;
+ cTerrainShapeGen & m_ShapeGen;
+ cTerrainCompositionGen & m_CompositionGen;
};
-
-
-
-
diff --git a/src/Generating/DistortedHeightmap.cpp b/src/Generating/DistortedHeightmap.cpp
index 11c873967..a0732287b 100644
--- a/src/Generating/DistortedHeightmap.cpp
+++ b/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
diff --git a/src/Generating/DistortedHeightmap.h b/src/Generating/DistortedHeightmap.h
index bc6d079ba..f523b8109 100644
--- a/src/Generating/DistortedHeightmap.h
+++ b/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;
diff --git a/src/Generating/DungeonRoomsFinisher.cpp b/src/Generating/DungeonRoomsFinisher.cpp
index 4196e16ee..96dd28333 100644
--- a/src/Generating/DungeonRoomsFinisher.cpp
+++ b/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));
}
-
-
-
-
diff --git a/src/Generating/DungeonRoomsFinisher.h b/src/Generating/DungeonRoomsFinisher.h
index 72ac5cb51..bd5380448 100644
--- a/src/Generating/DungeonRoomsFinisher.h
+++ b/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;
} ;
-
-
-
-
diff --git a/src/Generating/HeiGen.cpp b/src/Generating/HeiGen.cpp
index 4efb89be5..2e4b4fb3c 100644
--- a/src/Generating/HeiGen.cpp
+++ b/src/Generating/HeiGen.cpp
@@ -106,8 +106,8 @@ void cHeiGenFlat::InitializeHeightGen(cIniFile & a_IniFile)
////////////////////////////////////////////////////////////////////////////////
// cHeiGenCache:
-cHeiGenCache::cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_CacheSize) :
- m_HeiGenToCache(std::move(a_HeiGenToCache)),
+cHeiGenCache::cHeiGenCache(cTerrainHeightGen & a_HeiGenToCache, size_t a_CacheSize) :
+ 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):
- m_NumSubCaches(a_NumSubCaches)
+cHeiGenMultiCache::cHeiGenMultiCache(std::unique_ptr<cTerrainHeightGen> a_HeiGenToCache, size_t a_SubCacheSize, size_t 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:
diff --git a/src/Generating/HeiGen.h b/src/Generating/HeiGen.h
index ebdfef70f..6f2101043 100644
--- a/src/Generating/HeiGen.h
+++ b/src/Generating/HeiGen.h
@@ -28,8 +28,7 @@ class cHeiGenCache :
public cTerrainHeightGen
{
public:
- cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_CacheSize);
- virtual ~cHeiGenCache() override = default;
+ cHeiGenCache(cTerrainHeightGen & a_HeiGenToCache, size_t a_CacheSize);
// 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;
- cBiomeGenPtr m_BiomeGen;
+ cNoise m_Noise;
+ 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);
} ;
-
-
-
-
diff --git a/src/Generating/Noise3DGenerator.cpp b/src/Generating/Noise3DGenerator.cpp
index 362c6d9a2..ecf135a26 100644
--- a/src/Generating/Noise3DGenerator.cpp
+++ b/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
}
-
-
-
-
-
diff --git a/src/Generating/Noise3DGenerator.h b/src/Generating/Noise3DGenerator.h
index 43245bebd..9aceffc1d 100644
--- a/src/Generating/Noise3DGenerator.h
+++ b/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); }
} ;
-
-
-
-
diff --git a/src/Generating/PiecePool.h b/src/Generating/PiecePool.h
index 0849f4ebc..8beaf0c31 100644
--- a/src/Generating/PiecePool.h
+++ b/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;
-
-
-
-
-
diff --git a/src/Generating/PieceStructuresGen.cpp b/src/Generating/PieceStructuresGen.cpp
index dbfe16b47..56890597a 100644
--- a/src/Generating/PieceStructuresGen.cpp
+++ b/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_HeightGen(std::move(a_HeightGen)),
+ m_BiomeGen(a_BiomeGen),
+ 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);
}
}
-
-
-
-
-
diff --git a/src/Generating/PieceStructuresGen.h b/src/Generating/PieceStructuresGen.h
index c3d7c4ee3..224e6b262 100644
--- a/src/Generating/PieceStructuresGen.h
+++ b/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;
};
-
-
-
-
diff --git a/src/Generating/PrefabPiecePool.cpp b/src/Generating/PrefabPiecePool.cpp
index 28355660c..88e670026 100644
--- a/src/Generating/PrefabPiecePool.cpp
+++ b/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
}
-
-
-
-
diff --git a/src/Generating/PrefabPiecePool.h b/src/Generating/PrefabPiecePool.h
index 6bbb7ac13..708b9be57 100644
--- a/src/Generating/PrefabPiecePool.h
+++ b/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;
diff --git a/src/Generating/PrefabStructure.cpp b/src/Generating/PrefabStructure.cpp
index 127cd0018..9814610b4 100644
--- a/src/Generating/PrefabStructure.cpp
+++ b/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);
}
-
-
-
-
diff --git a/src/Generating/PrefabStructure.h b/src/Generating/PrefabStructure.h
index e102b4863..8b489d866 100644
--- a/src/Generating/PrefabStructure.h
+++ b/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);
};
-
-
-
-
diff --git a/src/Generating/ShapeGen.cpp b/src/Generating/ShapeGen.cpp
index 1efbf1010..f46c0c8e9 100644
--- a/src/Generating/ShapeGen.cpp
+++ b/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;
}
-
-
-
-
diff --git a/src/Generating/SinglePieceStructuresGen.cpp b/src/Generating/SinglePieceStructuresGen.cpp
index 84b246715..fb6dcd67d 100644
--- a/src/Generating/SinglePieceStructuresGen.cpp
+++ b/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_HeightGen(std::move(a_HeightGen)),
+ m_BiomeGen(a_BiomeGen),
+ 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, "|");
diff --git a/src/Generating/SinglePieceStructuresGen.h b/src/Generating/SinglePieceStructuresGen.h
index c14757738..386d0f9ae 100644
--- a/src/Generating/SinglePieceStructuresGen.h
+++ b/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:
diff --git a/src/Generating/StructGen.cpp b/src/Generating/StructGen.cpp
index fd78ceb3e..3bdf94d1c 100644
--- a/src/Generating/StructGen.cpp
+++ b/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_ShapeGen->GenShape ({BaseX, BaseZ}, workerShape);
- WorkerDesc.SetHeightFromShape (workerShape);
- m_CompositionGen->ComposeTerrain(WorkerDesc, workerShape);
+ m_BiomeGen.GenBiomes ({BaseX, BaseZ}, WorkerDesc.GetBiomeMap());
+ m_ShapeGen.GenShape ({BaseX, BaseZ}, workerShape);
+ WorkerDesc.SetHeightFromShape (workerShape);
+ m_CompositionGen.ComposeTerrain(WorkerDesc, workerShape);
}
else
{
@@ -575,7 +575,3 @@ void cStructGenDistortedMembraneOverhangs::GenFinish(cChunkDesc & a_ChunkDesc)
} // for x
} // for z
}
-
-
-
-
diff --git a/src/Generating/StructGen.h b/src/Generating/StructGen.h
index ae7626873..ec3ed89f6 100644
--- a/src/Generating/StructGen.h
+++ b/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_ShapeGen(std::move(a_ShapeGen)),
- m_CompositionGen(std::move(a_CompositionGen))
+ m_BiomeGen(a_BiomeGen),
+ m_ShapeGen(a_ShapeGen),
+ m_CompositionGen(a_CompositionGen)
{}
protected:
int m_Seed;
cNoise m_Noise;
- cBiomeGenPtr m_BiomeGen;
- cTerrainShapeGenPtr m_ShapeGen;
- cTerrainCompositionGenPtr m_CompositionGen;
+ cBiomeGen & m_BiomeGen;
+ cTerrainShapeGen & m_ShapeGen;
+ 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;
- int m_Seed;
- BLOCKTYPE m_Fluid;
- cTerrainShapeGenPtr m_ShapeGen;
+ cNoise m_Noise;
+ int m_Seed;
+ BLOCKTYPE m_Fluid;
+ 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;
} ;
-
-
-
-
diff --git a/src/Generating/TwoHeights.cpp b/src/Generating/TwoHeights.cpp
index 377127c00..91c67608c 100644
--- a/src/Generating/TwoHeights.cpp
+++ b/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);
}
-
-
-
-
diff --git a/src/Generating/TwoHeights.h b/src/Generating/TwoHeights.h
index 7dcf47c77..fbdcfdcfd 100644
--- a/src/Generating/TwoHeights.h
+++ b/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);
diff --git a/src/Generating/VerticalLimit.cpp b/src/Generating/VerticalLimit.cpp
index f6b1b456c..b3e8ea35d 100644
--- a/src/Generating/VerticalLimit.cpp
+++ b/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;
}
-
-
-
-
diff --git a/src/Generating/VerticalStrategy.cpp b/src/Generating/VerticalStrategy.cpp
index 0651958f9..9fd11865b 100644
--- a/src/Generating/VerticalStrategy.cpp
+++ b/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;
}
-
-
-
-
diff --git a/src/Generating/VillageGen.cpp b/src/Generating/VillageGen.cpp
index d46c0d64a..6575b2f3a 100644
--- a/src/Generating/VillageGen.cpp
+++ b/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,
- cTerrainHeightGenPtr a_HeightGen,
+ cBiomeGen & a_BiomeGen,
+ 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_HeightGen(std::move(a_HeightGen))
+ m_BiomeGen(a_BiomeGen),
+ 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));
}
-
-
-
-
diff --git a/src/Generating/VillageGen.h b/src/Generating/VillageGen.h
index 42c5b7bb0..c59c089d3 100644
--- a/src/Generating/VillageGen.h
+++ b/src/Generating/VillageGen.h
@@ -38,8 +38,8 @@ public:
int a_MaxDepth,
int a_MaxSize,
int a_MinDensity, int a_MaxDensity,
- cBiomeGenPtr a_BiomeGen,
- cTerrainHeightGenPtr a_HeightGen,
+ cBiomeGen & a_BiomeGen,
+ 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;
} ;
-
-
-
-