2013-07-29 07:13:03 -04:00
|
|
|
|
|
|
|
// ComposableGenerator.cpp
|
|
|
|
|
|
|
|
// Implements the cComposableGenerator class representing the chunk generator that takes the composition approach to generating chunks
|
|
|
|
|
|
|
|
#include "Globals.h"
|
|
|
|
|
|
|
|
#include "ComposableGenerator.h"
|
|
|
|
#include "../World.h"
|
2014-10-23 09:15:10 -04:00
|
|
|
#include "../IniFile.h"
|
2013-07-29 07:13:03 -04:00
|
|
|
#include "../Root.h"
|
|
|
|
|
|
|
|
// Individual composed algorithms:
|
|
|
|
#include "BioGen.h"
|
|
|
|
#include "HeiGen.h"
|
|
|
|
#include "CompoGen.h"
|
|
|
|
#include "StructGen.h"
|
|
|
|
#include "FinishGen.h"
|
|
|
|
|
2014-11-12 15:24:26 -05:00
|
|
|
#include "CompoGenBiomal.h"
|
|
|
|
|
2014-11-13 15:28:50 -05:00
|
|
|
#include "CompositedHeiGen.h"
|
|
|
|
|
2013-07-29 07:13:03 -04:00
|
|
|
#include "Caves.h"
|
|
|
|
#include "DistortedHeightmap.h"
|
2014-08-26 08:16:33 -04:00
|
|
|
#include "DungeonRoomsFinisher.h"
|
2013-07-29 07:13:03 -04:00
|
|
|
#include "EndGen.h"
|
|
|
|
#include "MineShafts.h"
|
|
|
|
#include "Noise3DGenerator.h"
|
|
|
|
#include "Ravines.h"
|
2014-07-26 18:03:26 -04:00
|
|
|
#include "RoughRavines.h"
|
2014-05-14 18:14:06 -04:00
|
|
|
#include "VillageGen.h"
|
2015-11-11 04:32:42 -05:00
|
|
|
#include "PieceStructuresGen.h"
|
2013-07-29 07:13:03 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-07-17 16:15:34 -04:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2014-01-09 04:35:51 -05:00
|
|
|
// cTerrainCompositionGen:
|
2014-05-14 18:14:06 -04:00
|
|
|
|
2014-11-12 15:24:26 -05:00
|
|
|
cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, cTerrainShapeGenPtr a_ShapeGen, int a_Seed)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
|
|
|
AString CompoGenName = a_IniFile.GetValueSet("Generator", "CompositionGen", "");
|
|
|
|
if (CompoGenName.empty())
|
|
|
|
{
|
|
|
|
LOGWARN("[Generator] CompositionGen value not set in world.ini, using \"Biomal\".");
|
|
|
|
CompoGenName = "Biomal";
|
|
|
|
}
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-11-12 15:24:26 -05:00
|
|
|
// Compositor list is alpha-sorted
|
|
|
|
cTerrainCompositionGenPtr res;
|
|
|
|
if (NoCaseCompare(CompoGenName, "Biomal") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
res = CreateCompoGenBiomal(a_Seed);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "BiomalNoise3D") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
// The composition that used to be provided with BiomalNoise3D is now provided by the Biomal compositor:
|
|
|
|
res = CreateCompoGenBiomal(a_Seed);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "Classic") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
res = std::make_shared<cCompoGenClassic>();
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "DebugBiomes") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
res = std::make_shared<cCompoGenDebugBiomes>();
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "DistortedHeightmap") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
// The composition that used to be provided with DistortedHeightmap is now provided by the Biomal compositor:
|
|
|
|
res = CreateCompoGenBiomal(a_Seed);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "End") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
res = std::make_shared<cEndGen>(a_Seed);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "Nether") == 0)
|
2014-11-10 11:00:14 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
res = std::make_shared<cCompoGenNether>(a_Seed);
|
2014-11-10 11:00:14 -05:00
|
|
|
}
|
2014-01-09 04:35:51 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "Noise3D") == 0)
|
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
// The composition that used to be provided with Noise3D is now provided by the Biomal compositor:
|
|
|
|
res = CreateCompoGenBiomal(a_Seed);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
else if (NoCaseCompare(CompoGenName, "SameBlock") == 0)
|
2014-01-09 04:35:51 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
res = std::make_shared<cCompoGenSameBlock>();
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-01-10 10:33:53 -05:00
|
|
|
LOGWARN("Unknown CompositionGen \"%s\", using \"Biomal\" instead.", CompoGenName.c_str());
|
2014-01-09 04:35:51 -05:00
|
|
|
a_IniFile.SetValue("Generator", "CompositionGen", "Biomal");
|
2014-11-12 15:24:26 -05:00
|
|
|
return CreateCompositionGen(a_IniFile, a_BiomeGen, a_ShapeGen, a_Seed);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
2014-10-20 16:55:07 -04:00
|
|
|
ASSERT(res != nullptr);
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-01-09 04:35:51 -05:00
|
|
|
// Read the settings from the ini file:
|
|
|
|
res->InitializeCompoGen(a_IniFile);
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-10-19 08:01:59 -04:00
|
|
|
return cTerrainCompositionGenPtr(res);
|
2014-01-09 04:35:51 -05:00
|
|
|
}
|
|
|
|
|
2013-07-29 07:13:03 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-07-17 16:15:34 -04:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
2014-01-09 04:35:51 -05:00
|
|
|
// cComposableGenerator:
|
2013-07-29 07:13:03 -04:00
|
|
|
|
|
|
|
cComposableGenerator::cComposableGenerator(cChunkGenerator & a_ChunkGenerator) :
|
|
|
|
super(a_ChunkGenerator),
|
2014-10-22 16:58:21 -04:00
|
|
|
m_BiomeGen(),
|
2014-11-12 15:24:26 -05:00
|
|
|
m_ShapeGen(),
|
2014-10-22 16:58:21 -04:00
|
|
|
m_CompositionGen()
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-01-10 16:22:54 -05:00
|
|
|
void cComposableGenerator::Initialize(cIniFile & a_IniFile)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-01-10 16:22:54 -05:00
|
|
|
super::Initialize(a_IniFile);
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2013-07-29 07:13:03 -04:00
|
|
|
InitBiomeGen(a_IniFile);
|
2014-11-12 15:24:26 -05:00
|
|
|
InitShapeGen(a_IniFile);
|
2013-07-29 07:13:03 -04:00
|
|
|
InitCompositionGen(a_IniFile);
|
|
|
|
InitFinishGens(a_IniFile);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cComposableGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap)
|
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
if (m_BiomeGen != nullptr) // Quick fix for generator deinitializing before the world storage finishes loading
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
|
|
|
m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cComposableGenerator::DoGenerate(int a_ChunkX, int a_ChunkZ, cChunkDesc & a_ChunkDesc)
|
|
|
|
{
|
|
|
|
if (a_ChunkDesc.IsUsingDefaultBiomes())
|
|
|
|
{
|
|
|
|
m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, a_ChunkDesc.GetBiomeMap());
|
|
|
|
}
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-11-12 15:24:26 -05:00
|
|
|
cChunkDesc::Shape shape;
|
2013-07-29 07:13:03 -04:00
|
|
|
if (a_ChunkDesc.IsUsingDefaultHeight())
|
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
m_ShapeGen->GenShape(a_ChunkX, a_ChunkZ, shape);
|
|
|
|
a_ChunkDesc.SetHeightFromShape(shape);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Convert the heightmap in a_ChunkDesc into shape:
|
|
|
|
a_ChunkDesc.GetShapeFromHeight(shape);
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-03-28 11:42:32 -04:00
|
|
|
bool ShouldUpdateHeightmap = false;
|
2013-07-29 07:13:03 -04:00
|
|
|
if (a_ChunkDesc.IsUsingDefaultComposition())
|
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
m_CompositionGen->ComposeTerrain(a_ChunkDesc, shape);
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (a_ChunkDesc.IsUsingDefaultFinish())
|
|
|
|
{
|
|
|
|
for (cFinishGenList::iterator itr = m_FinishGens.begin(); itr != m_FinishGens.end(); ++itr)
|
|
|
|
{
|
|
|
|
(*itr)->GenFinish(a_ChunkDesc);
|
|
|
|
} // for itr - m_FinishGens[]
|
2014-03-28 11:42:32 -04:00
|
|
|
ShouldUpdateHeightmap = true;
|
|
|
|
}
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-03-28 11:42:32 -04:00
|
|
|
if (ShouldUpdateHeightmap)
|
|
|
|
{
|
|
|
|
a_ChunkDesc.UpdateHeightmap();
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)
|
|
|
|
{
|
|
|
|
bool CacheOffByDefault = false;
|
2013-11-28 14:15:52 -05:00
|
|
|
m_BiomeGen = cBiomeGen::CreateBiomeGen(a_IniFile, m_ChunkGenerator.GetSeed(), CacheOffByDefault);
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2013-07-29 07:13:03 -04:00
|
|
|
// Add a cache, if requested:
|
2015-11-11 04:32:42 -05:00
|
|
|
// The default is 16 * 128 caches, which is 2 MiB of RAM. Reasonable, for the amount of work this is saving.
|
|
|
|
int CacheSize = a_IniFile.GetValueSetI("Generator", "BiomeGenCacheSize", CacheOffByDefault ? 0 : 16);
|
2014-09-05 16:08:00 -04:00
|
|
|
if (CacheSize <= 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-09-05 16:08:00 -04:00
|
|
|
return;
|
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
int MultiCacheLength = a_IniFile.GetValueSetI("Generator", "BiomeGenMultiCacheLength", 128);
|
2014-09-05 16:08:00 -04:00
|
|
|
if (CacheSize < 4)
|
|
|
|
{
|
|
|
|
LOGWARNING("Biomegen cache size set too low, would hurt performance instead of helping. Increasing from %d to %d",
|
|
|
|
CacheSize, 4
|
|
|
|
);
|
|
|
|
CacheSize = 4;
|
|
|
|
}
|
|
|
|
LOGD("Using a cache for biomegen of size %d.", CacheSize);
|
|
|
|
if (MultiCacheLength > 0)
|
|
|
|
{
|
|
|
|
LOGD("Enabling multicache for biomegen of length %d.", MultiCacheLength);
|
2015-11-11 04:32:42 -05:00
|
|
|
m_BiomeGen = std::make_shared<cBioGenMulticache>(m_BiomeGen, static_cast<size_t>(CacheSize), static_cast<size_t>(MultiCacheLength));
|
2014-09-05 16:08:00 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-11-11 04:32:42 -05:00
|
|
|
m_BiomeGen = std::make_shared<cBioGenCache>(m_BiomeGen, static_cast<size_t>(CacheSize));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-11-12 15:24:26 -05:00
|
|
|
void cComposableGenerator::InitShapeGen(cIniFile & a_IniFile)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
|
|
|
bool CacheOffByDefault = false;
|
2014-11-12 15:24:26 -05:00
|
|
|
m_ShapeGen = cTerrainShapeGen::CreateShapeGen(a_IniFile, m_BiomeGen, m_ChunkGenerator.GetSeed(), CacheOffByDefault);
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-11-12 15:24:26 -05:00
|
|
|
/*
|
|
|
|
// TODO
|
2013-07-29 07:13:03 -04:00
|
|
|
// Add a cache, if requested:
|
2014-11-12 15:24:26 -05:00
|
|
|
int CacheSize = a_IniFile.GetValueSetI("Generator", "ShapeGenCacheSize", CacheOffByDefault ? 0 : 64);
|
2013-07-29 07:13:03 -04:00
|
|
|
if (CacheSize > 0)
|
|
|
|
{
|
|
|
|
if (CacheSize < 4)
|
|
|
|
{
|
2014-07-17 16:50:58 -04:00
|
|
|
LOGWARNING("Heightgen cache size set too low, would hurt performance instead of helping. Increasing from %d to %d",
|
2013-07-29 07:13:03 -04:00
|
|
|
CacheSize, 4
|
|
|
|
);
|
|
|
|
CacheSize = 4;
|
|
|
|
}
|
2013-09-28 15:36:01 -04:00
|
|
|
LOGD("Using a cache for Heightgen of size %d.", CacheSize);
|
2014-10-19 08:01:59 -04:00
|
|
|
m_HeightGen = cTerrainHeightGenPtr(new cHeiGenCache(m_HeightGen, CacheSize));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2014-11-12 15:24:26 -05:00
|
|
|
*/
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cComposableGenerator::InitCompositionGen(cIniFile & a_IniFile)
|
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
m_CompositionGen = cTerrainCompositionGen::CreateCompositionGen(a_IniFile, m_BiomeGen, m_ShapeGen, m_ChunkGenerator.GetSeed());
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-11-13 15:28:50 -05:00
|
|
|
// Add a cache over the composition generator:
|
|
|
|
// Even a cache of size 1 is useful due to the CompositedHeiGen cache after us doing re-composition on its misses
|
2013-07-29 07:13:03 -04:00
|
|
|
int CompoGenCacheSize = a_IniFile.GetValueSetI("Generator", "CompositionGenCacheSize", 64);
|
2014-11-13 15:28:50 -05:00
|
|
|
if (CompoGenCacheSize > 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-11-13 15:28:50 -05:00
|
|
|
m_CompositionGen = std::make_shared<cCompoGenCache>(m_CompositionGen, CompoGenCacheSize);
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2014-11-13 15:28:50 -05:00
|
|
|
|
|
|
|
// Create a cache of the composited heightmaps, so that finishers may use it:
|
2015-11-11 04:32:42 -05:00
|
|
|
m_CompositedHeightCache = std::make_shared<cHeiGenMultiCache>(std::make_shared<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.
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-01 14:56:09 -05:00
|
|
|
void cComposableGenerator::InitFinishGens(cIniFile & a_IniFile)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
|
|
|
int Seed = m_ChunkGenerator.GetSeed();
|
2014-03-01 14:56:09 -05:00
|
|
|
eDimension Dimension = StringToDimension(a_IniFile.GetValue("General", "Dimension", "Overworld"));
|
2015-11-11 04:32:42 -05:00
|
|
|
auto seaLevel = a_IniFile.GetValueI("Generator", "SeaLevel");
|
2014-03-01 14:56:09 -05:00
|
|
|
|
2014-05-31 17:28:51 -04:00
|
|
|
AString Finishers = a_IniFile.GetValueSet("Generator", "Finishers", "");
|
2014-03-01 14:56:09 -05:00
|
|
|
|
|
|
|
// Create all requested finishers:
|
|
|
|
AStringVector Str = StringSplitAndTrim(Finishers, ",");
|
2013-07-29 07:13:03 -04:00
|
|
|
for (AStringVector::const_iterator itr = Str.begin(); itr != Str.end(); ++itr)
|
|
|
|
{
|
2015-11-11 04:32:42 -05:00
|
|
|
auto split = StringSplitAndTrim(*itr, ":");
|
|
|
|
if (split.empty())
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const auto & finisher = split[0];
|
2014-03-01 14:56:09 -05:00
|
|
|
// Finishers, alpha-sorted:
|
2015-11-11 04:32:42 -05:00
|
|
|
if (NoCaseCompare(finisher, "Animals") == 0)
|
2014-12-02 18:55:09 -05:00
|
|
|
{
|
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenPassiveMobs(Seed, a_IniFile, Dimension)));
|
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "BottomLava") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-03-01 14:56:09 -05:00
|
|
|
int DefaultBottomLavaLevel = (Dimension == dimNether) ? 30 : 10;
|
|
|
|
int BottomLavaLevel = a_IniFile.GetValueSetI("Generator", "BottomLavaLevel", DefaultBottomLavaLevel);
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenBottomLava(BottomLavaLevel)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "DeadBushes") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2014-07-28 08:23:29 -04:00
|
|
|
// A list with all the allowed biomes.
|
|
|
|
cFinishGenSingleTopBlock::BiomeList AllowedBiomes;
|
|
|
|
AllowedBiomes.push_back(biDesert);
|
|
|
|
AllowedBiomes.push_back(biDesertHills);
|
|
|
|
AllowedBiomes.push_back(biDesertM);
|
|
|
|
AllowedBiomes.push_back(biMesa);
|
|
|
|
AllowedBiomes.push_back(biMesaBryce);
|
2014-07-28 08:28:16 -04:00
|
|
|
AllowedBiomes.push_back(biMesaPlateau);
|
2014-07-28 08:23:29 -04:00
|
|
|
AllowedBiomes.push_back(biMesaPlateauF);
|
|
|
|
AllowedBiomes.push_back(biMesaPlateauFM);
|
|
|
|
AllowedBiomes.push_back(biMesaPlateauM);
|
|
|
|
|
2014-07-29 11:01:15 -04:00
|
|
|
// A list with all the allowed blocks that can be below the dead bush.
|
2014-07-28 08:23:29 -04:00
|
|
|
cFinishGenSingleTopBlock::BlockList AllowedBlocks;
|
|
|
|
AllowedBlocks.push_back(E_BLOCK_SAND);
|
|
|
|
AllowedBlocks.push_back(E_BLOCK_HARDENED_CLAY);
|
|
|
|
AllowedBlocks.push_back(E_BLOCK_STAINED_CLAY);
|
|
|
|
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSingleTopBlock(Seed, E_BLOCK_DEAD_BUSH, AllowedBiomes, 2, AllowedBlocks)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "DirectOverhangs") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenDirectOverhangs(Seed)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "DirtPockets") == 0)
|
2015-11-25 03:22:13 -05:00
|
|
|
{
|
2015-11-25 09:06:32 -05:00
|
|
|
auto gen = std::make_shared<cFinishGenOrePockets>(Seed + 1, cFinishGenOrePockets::DefaultNaturalPatches());
|
|
|
|
if (gen->Initialize(a_IniFile, "DirtPockets"))
|
|
|
|
{
|
|
|
|
m_FinishGens.push_back(gen);
|
|
|
|
}
|
2015-11-25 03:22:13 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "DistortedMembraneOverhangs") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenDistortedMembraneOverhangs(Seed)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "DualRidgeCaves") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2015-08-04 18:24:59 -04:00
|
|
|
float Threshold = static_cast<float>(a_IniFile.GetValueSetF("Generator", "DualRidgeCavesThreshold", 0.3));
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenDualRidgeCaves(Seed, Threshold)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "DungeonRooms") == 0)
|
2014-08-26 08:16:33 -04:00
|
|
|
{
|
2014-08-27 06:25:27 -04:00
|
|
|
int GridSize = a_IniFile.GetValueSetI("Generator", "DungeonRoomsGridSize", 48);
|
|
|
|
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");
|
2014-11-12 15:24:26 -05:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cDungeonRoomsFinisher(m_ShapeGen, Seed, GridSize, MaxSize, MinSize, HeightDistrib)));
|
2014-08-26 08:16:33 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "GlowStone") == 0)
|
2015-04-19 13:45:18 -04:00
|
|
|
{
|
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenGlowStone(Seed)));
|
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Ice") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenIce));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "LavaLakes") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
|
|
|
int Probability = a_IniFile.GetValueSetI("Generator", "LavaLakesProbability", 10);
|
2014-11-12 15:24:26 -05:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenLakes(Seed * 5 + 16873, E_BLOCK_STATIONARY_LAVA, m_ShapeGen, Probability)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "LavaSprings") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenFluidSprings(Seed, E_BLOCK_LAVA, a_IniFile, Dimension)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Lilypads") == 0)
|
|
|
|
{
|
|
|
|
// A list with all the allowed biomes.
|
|
|
|
cFinishGenSingleTopBlock::BiomeList AllowedBiomes;
|
|
|
|
AllowedBiomes.push_back(biSwampland);
|
|
|
|
AllowedBiomes.push_back(biSwamplandM);
|
|
|
|
|
|
|
|
// A list with all the allowed blocks that can be below the lilypad.
|
|
|
|
cFinishGenSingleTopBlock::BlockList AllowedBlocks;
|
|
|
|
AllowedBlocks.push_back(E_BLOCK_WATER);
|
|
|
|
AllowedBlocks.push_back(E_BLOCK_STATIONARY_WATER);
|
|
|
|
|
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSingleTopBlock(Seed, E_BLOCK_LILY_PAD, AllowedBiomes, 4, AllowedBlocks)));
|
|
|
|
}
|
|
|
|
else if (NoCaseCompare(finisher, "MarbleCaves") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenMarbleCaves(Seed)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "MineShafts") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
|
|
|
int GridSize = a_IniFile.GetValueSetI("Generator", "MineShaftsGridSize", 512);
|
2014-06-16 10:12:50 -04:00
|
|
|
int MaxOffset = a_IniFile.GetValueSetI("Generator", "MineShaftsMaxOffset", 256);
|
2013-07-29 07:13:03 -04:00
|
|
|
int MaxSystemSize = a_IniFile.GetValueSetI("Generator", "MineShaftsMaxSystemSize", 160);
|
|
|
|
int ChanceCorridor = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCorridor", 600);
|
|
|
|
int ChanceCrossing = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceCrossing", 200);
|
|
|
|
int ChanceStaircase = a_IniFile.GetValueSetI("Generator", "MineShaftsChanceStaircase", 200);
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenMineShafts(
|
2014-06-16 10:12:50 -04:00
|
|
|
Seed, GridSize, MaxOffset, MaxSystemSize,
|
2013-07-29 07:13:03 -04:00
|
|
|
ChanceCorridor, ChanceCrossing, ChanceStaircase
|
2014-10-19 08:01:59 -04:00
|
|
|
)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "NaturalPatches") == 0)
|
2014-08-10 05:57:05 -04:00
|
|
|
{
|
2015-11-25 03:22:13 -05:00
|
|
|
m_FinishGens.push_back(std::make_shared<cFinishGenOreNests>(Seed + 1, cFinishGenOreNests::DefaultNaturalPatches()));
|
2014-08-10 05:57:05 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "NetherClumpFoliage") == 0)
|
2014-01-18 11:03:43 -05:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenNetherClumpFoliage(Seed)));
|
2014-01-18 11:03:43 -05:00
|
|
|
}
|
2014-03-28 11:42:32 -04:00
|
|
|
else if (NoCaseCompare(*itr, "NetherForts") == 0)
|
|
|
|
{
|
2015-12-15 12:04:40 -05:00
|
|
|
LOGINFO("The NetherForts finisher is obsolete, you should use \"PieceStructures: NetherFort\" instead.");
|
2015-11-11 04:32:42 -05:00
|
|
|
auto gen = std::make_shared<cPieceStructuresGen>(Seed);
|
2015-12-15 12:04:40 -05:00
|
|
|
if (gen->Initialize("NetherFort", seaLevel, m_BiomeGen, m_CompositedHeightCache))
|
2015-11-11 04:32:42 -05:00
|
|
|
{
|
|
|
|
m_FinishGens.push_back(gen);
|
|
|
|
}
|
2014-03-28 11:42:32 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "NetherOreNests") == 0)
|
2014-08-10 05:48:05 -04:00
|
|
|
{
|
2015-11-25 03:22:13 -05:00
|
|
|
m_FinishGens.push_back(std::make_shared<cFinishGenOreNests>(Seed + 2, cFinishGenOreNests::DefaultNetherOres()));
|
2014-08-10 05:48:05 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "OreNests") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2015-11-25 03:22:13 -05:00
|
|
|
m_FinishGens.push_back(std::make_shared<cFinishGenOreNests>(Seed + 3, cFinishGenOreNests::DefaultOverworldOres()));
|
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "OrePockets") == 0)
|
2015-11-25 03:22:13 -05:00
|
|
|
{
|
|
|
|
auto gen = std::make_shared<cFinishGenOrePockets>(Seed + 2, cFinishGenOrePockets::DefaultOverworldOres());
|
2015-11-25 09:06:32 -05:00
|
|
|
if (gen->Initialize(a_IniFile, "OrePockets"))
|
2015-11-25 03:22:13 -05:00
|
|
|
{
|
|
|
|
m_FinishGens.push_back(gen);
|
|
|
|
}
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2016-03-05 17:56:08 -05:00
|
|
|
else if (NoCaseCompare(finisher, "OverworldClumpFlowers") == 0)
|
|
|
|
{
|
|
|
|
auto flowers = cFinishGenClumpTopBlock::ParseIniFile(a_IniFile, "OverworldClumpFlowers");
|
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenClumpTopBlock(Seed, flowers)));
|
|
|
|
}
|
2015-12-15 12:04:40 -05:00
|
|
|
else if (NoCaseCompare(finisher, "PieceStructures") == 0)
|
2014-03-09 17:04:29 -04:00
|
|
|
{
|
2015-11-11 04:32:42 -05:00
|
|
|
if (split.size() < 2)
|
|
|
|
{
|
2015-12-15 12:04:40 -05:00
|
|
|
LOGWARNING("The PieceStructures generator needs the structures to use. Example: \"PieceStructures: NetherFort\".");
|
2015-11-11 04:32:42 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto gen = std::make_shared<cPieceStructuresGen>(Seed);
|
|
|
|
if (gen->Initialize(split[1], seaLevel, m_BiomeGen, m_CompositedHeightCache))
|
|
|
|
{
|
|
|
|
m_FinishGens.push_back(gen);
|
|
|
|
}
|
2014-03-09 17:04:29 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "PreSimulator") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-07-30 07:06:48 -04:00
|
|
|
// Load the settings
|
|
|
|
bool PreSimulateFallingBlocks = a_IniFile.GetValueSetB("Generator", "PreSimulatorFallingBlocks", true);
|
|
|
|
bool PreSimulateWater = a_IniFile.GetValueSetB("Generator", "PreSimulatorWater", true);
|
|
|
|
bool PreSimulateLava = a_IniFile.GetValueSetB("Generator", "PreSimulatorLava", true);
|
|
|
|
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenPreSimulator(PreSimulateFallingBlocks, PreSimulateWater, PreSimulateLava)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "RainbowRoads") == 0)
|
2014-06-05 17:44:31 -04:00
|
|
|
{
|
2015-11-11 04:32:42 -05:00
|
|
|
LOGINFO("The RainbowRoads finisher is obsolete, you should use \"PieceStructures: RainbowRoads\" instead.");
|
|
|
|
auto gen = std::make_shared<cPieceStructuresGen>(Seed);
|
|
|
|
if (gen->Initialize("RainbowRoads", seaLevel, m_BiomeGen, m_CompositedHeightCache))
|
|
|
|
{
|
|
|
|
m_FinishGens.push_back(gen);
|
|
|
|
}
|
2014-06-05 17:44:31 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Ravines") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenRavines(Seed, 128)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "RoughRavines") == 0)
|
2014-07-26 18:03:26 -04:00
|
|
|
{
|
2014-07-27 13:57:47 -04:00
|
|
|
int GridSize = a_IniFile.GetValueSetI("Generator", "RoughRavinesGridSize", 256);
|
|
|
|
int MaxOffset = a_IniFile.GetValueSetI("Generator", "RoughRavinesMaxOffset", 128);
|
|
|
|
int MaxSize = a_IniFile.GetValueSetI("Generator", "RoughRavinesMaxSize", 128);
|
|
|
|
int MinSize = a_IniFile.GetValueSetI("Generator", "RoughRavinesMinSize", 64);
|
|
|
|
double MaxCenterWidth = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCenterWidth", 8);
|
|
|
|
double MinCenterWidth = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCenterWidth", 2);
|
|
|
|
double MaxRoughness = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxRoughness", 0.2);
|
|
|
|
double MinRoughness = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinRoughness", 0.05);
|
|
|
|
double MaxFloorHeightEdge = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxFloorHeightEdge", 8);
|
|
|
|
double MinFloorHeightEdge = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinFloorHeightEdge", 30);
|
|
|
|
double MaxFloorHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxFloorHeightCenter", 20);
|
|
|
|
double MinFloorHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinFloorHeightCenter", 6);
|
|
|
|
double MaxCeilingHeightEdge = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCeilingHeightEdge", 56);
|
|
|
|
double MinCeilingHeightEdge = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCeilingHeightEdge", 38);
|
|
|
|
double MaxCeilingHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMaxCeilingHeightCenter", 58);
|
|
|
|
double MinCeilingHeightCenter = a_IniFile.GetValueSetF("Generator", "RoughRavinesMinCeilingHeightCenter", 36);
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cRoughRavines(
|
2014-07-27 07:54:27 -04:00
|
|
|
Seed, MaxSize, MinSize,
|
2015-08-04 18:24:59 -04:00
|
|
|
static_cast<float>(MaxCenterWidth),
|
|
|
|
static_cast<float>(MinCenterWidth),
|
|
|
|
static_cast<float>(MaxRoughness),
|
|
|
|
static_cast<float>(MinRoughness),
|
|
|
|
static_cast<float>(MaxFloorHeightEdge),
|
|
|
|
static_cast<float>(MinFloorHeightEdge),
|
|
|
|
static_cast<float>(MaxFloorHeightCenter),
|
|
|
|
static_cast<float>(MinFloorHeightCenter),
|
|
|
|
static_cast<float>(MaxCeilingHeightEdge),
|
|
|
|
static_cast<float>(MinCeilingHeightEdge),
|
|
|
|
static_cast<float>(MaxCeilingHeightCenter),
|
|
|
|
static_cast<float>(MinCeilingHeightCenter),
|
2014-07-27 07:54:27 -04:00
|
|
|
GridSize, MaxOffset
|
2014-10-19 08:01:59 -04:00
|
|
|
)));
|
2014-07-26 18:03:26 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "SoulsandRims") == 0)
|
2014-12-01 10:36:48 -05:00
|
|
|
{
|
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSoulsandRims(Seed)));
|
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Snow") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSnow));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "SprinkleFoliage") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenSprinkleFoliage(Seed)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "TallGrass") == 0)
|
2014-07-20 13:22:41 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenTallGrass(Seed)));
|
2014-07-20 13:22:41 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Trees") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2014-11-12 15:24:26 -05:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenTrees(Seed, m_BiomeGen, m_ShapeGen, m_CompositionGen)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "UnderwaterBases") == 0)
|
2014-05-31 16:06:14 -04:00
|
|
|
{
|
2015-11-11 04:32:42 -05:00
|
|
|
LOGINFO("The UnderwaterBases finisher is obsolete, you should use \"PieceStructures: UnderwaterBases\" instead.");
|
|
|
|
auto gen = std::make_shared<cPieceStructuresGen>(Seed);
|
|
|
|
if (gen->Initialize("UnderwaterBases", seaLevel, m_BiomeGen, m_CompositedHeightCache))
|
|
|
|
{
|
|
|
|
m_FinishGens.push_back(gen);
|
|
|
|
}
|
2014-05-31 16:06:14 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Villages") == 0)
|
2014-05-14 18:14:06 -04:00
|
|
|
{
|
2014-05-22 15:47:56 -04:00
|
|
|
int GridSize = a_IniFile.GetValueSetI("Generator", "VillageGridSize", 384);
|
2014-06-16 10:12:50 -04:00
|
|
|
int MaxOffset = a_IniFile.GetValueSetI("Generator", "VillageMaxOffset", 128);
|
2014-05-22 15:47:56 -04:00
|
|
|
int MaxDepth = a_IniFile.GetValueSetI("Generator", "VillageMaxDepth", 2);
|
|
|
|
int MaxSize = a_IniFile.GetValueSetI("Generator", "VillageMaxSize", 128);
|
|
|
|
int MinDensity = a_IniFile.GetValueSetI("Generator", "VillageMinDensity", 50);
|
|
|
|
int MaxDensity = a_IniFile.GetValueSetI("Generator", "VillageMaxDensity", 80);
|
2015-06-20 09:37:41 -04:00
|
|
|
AString PrefabList = a_IniFile.GetValueSet("Generator", "VillagePrefabs", "PlainsVillage, SandVillage");
|
|
|
|
auto Prefabs = StringSplitAndTrim(PrefabList, ",");
|
2015-11-11 04:32:42 -05:00
|
|
|
m_FinishGens.push_back(std::make_shared<cVillageGen>(Seed, GridSize, MaxOffset, MaxDepth, MaxSize, MinDensity, MaxDensity, m_BiomeGen, m_CompositedHeightCache, seaLevel, Prefabs));
|
2014-05-14 18:14:06 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "Vines") == 0)
|
2015-02-28 16:37:33 -05:00
|
|
|
{
|
2015-02-28 16:40:13 -05:00
|
|
|
int Level = a_IniFile.GetValueSetI("Generator", "VinesLevel", 40);
|
2015-03-01 14:06:44 -05:00
|
|
|
m_FinishGens.push_back(std::make_shared<cFinishGenVines>(Seed, Level));
|
2015-02-28 16:37:33 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "WaterLakes") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
|
|
|
int Probability = a_IniFile.GetValueSetI("Generator", "WaterLakesProbability", 25);
|
2014-11-12 15:24:26 -05:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenLakes(Seed * 3 + 652, E_BLOCK_STATIONARY_WATER, m_ShapeGen, Probability)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "WaterSprings") == 0)
|
2013-07-29 07:13:03 -04:00
|
|
|
{
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cFinishGenFluidSprings(Seed, E_BLOCK_WATER, a_IniFile, Dimension)));
|
2013-07-29 07:13:03 -04:00
|
|
|
}
|
2015-11-11 04:32:42 -05:00
|
|
|
else if (NoCaseCompare(finisher, "WormNestCaves") == 0)
|
2014-03-01 14:56:09 -05:00
|
|
|
{
|
2014-06-16 10:12:50 -04:00
|
|
|
int Size = a_IniFile.GetValueSetI("Generator", "WormNestCavesSize", 64);
|
|
|
|
int Grid = a_IniFile.GetValueSetI("Generator", "WormNestCavesGrid", 96);
|
|
|
|
int MaxOffset = a_IniFile.GetValueSetI("Generator", "WormNestMaxOffset", 32);
|
2014-10-19 08:01:59 -04:00
|
|
|
m_FinishGens.push_back(cFinishGenPtr(new cStructGenWormNestCaves(Seed, Size, Grid, MaxOffset)));
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-11-11 04:32:42 -05:00
|
|
|
LOGWARNING("Unknown Finisher in the [Generator] section: \"%s\". Ignoring.", finisher.c_str());
|
2014-03-01 14:56:09 -05:00
|
|
|
}
|
2013-07-29 07:13:03 -04:00
|
|
|
} // for itr - Str[]
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|