dd/de9/a01182_source.html

 // HeiGen.cpp

 // Implements the various terrain height generators

 #include "Globals.h"
 #include "HeiGen.h"
 #include "../LinearUpscale.h"
 #include "../IniFile.h"
 #include "DistortedHeightmap.h"
 #include "EndGen.h"
 #include "Noise3DGenerator.h"
 #include "ProtIntGen.h"


 // cHeiGenSteppy:

 class cHeiGenSteppy:
     public cTerrainHeightGen
 {
 public:
     cHeiGenSteppy(int a_Seed) :
         m_Seed(a_Seed)
     {
         m_Gen =
             std::make_shared<cProtIntGenWeightAvg<16, 1, 0>>(
             std::make_shared<cProtIntGenSmooth>             (a_Seed + 1,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 2,
             std::make_shared<cProtIntGenSmooth>             (a_Seed + 3,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 4,
             std::make_shared<cProtIntGenAddRnd>             (a_Seed + 5, 1,
             std::make_shared<cProtIntGenSmooth>             (a_Seed + 6,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 7,
             std::make_shared<cProtIntGenRndBetween>         (a_Seed + 8, 60,
             std::make_shared<cProtIntGenAddRnd>             (a_Seed + 9, 1,
             std::make_shared<cProtIntGenSmooth>             (a_Seed + 1,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 2,
             std::make_shared<cProtIntGenRndBetween>         (a_Seed + 3, 60,
             std::make_shared<cProtIntGenSmooth>             (a_Seed + 4,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 5,
             std::make_shared<cProtIntGenRndBetween>         (a_Seed + 6, 60,
             std::make_shared<cProtIntGenRndChoice>          (a_Seed + 7, 10, 50, 50,
             std::make_shared<cProtIntGenSmooth>             (a_Seed + 8,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 9,
             std::make_shared<cProtIntGenRndChoice>          (a_Seed + 1, 10, 50, 50,
             std::make_shared<cProtIntGenAddRnd>             (a_Seed + 2, 2,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 3,
             std::make_shared<cProtIntGenZoom>               (a_Seed + 4,
             std::make_shared<cProtIntGenChoice>             (a_Seed + 5, 10)
         )))))))))))))))))))))));
     }

     // cTerrainHeightGen overrides:
     virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap) override
     {
         int heights[cChunkDef::Width * cChunkDef::Width];
         m_Gen->GetInts(
             a_ChunkCoords.m_ChunkX * cChunkDef::Width, a_ChunkCoords.m_ChunkZ * cChunkDef::Width,
             static_cast<size_t>(cChunkDef::Width), static_cast<size_t>(cChunkDef::Width), heights
         );
         for (size_t i = 0; i < ARRAYCOUNT(heights); i++)
         {
             a_HeightMap[i] = static_cast<HEIGHTTYPE>(std::max(std::min(60 + heights[i], cChunkDef::Height - 60), 40));
         }
     }

 protected:
     int m_Seed;

     std::shared_ptr<cProtIntGen> m_Gen;
 };


 // cHeiGenFlat:

 void cHeiGenFlat::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap)
 {
     UNUSED(a_ChunkCoords);
     for (size_t i = 0; i < ARRAYCOUNT(a_HeightMap); i++)
     {
         a_HeightMap[i] = m_Height;
     }
 }


 void cHeiGenFlat::InitializeHeightGen(cIniFile & a_IniFile)
 {
     m_Height = static_cast<HEIGHTTYPE>(a_IniFile.GetValueSetI("Generator", "FlatHeight", m_Height));
 }


 // cHeiGenCache:

 cHeiGenCache::cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_CacheSize) :
     m_HeiGenToCache(a_HeiGenToCache),
     m_CacheSize(a_CacheSize),
     m_NumHits(0),
     m_NumMisses(0),
     m_TotalChain(0)
 {
     m_CacheOrder.resize(a_CacheSize);
     m_CacheData.resize(a_CacheSize);
     for (size_t i = 0; i < m_CacheSize; i++)
     {
         m_CacheOrder[i] = i;
     }
 }


 void cHeiGenCache::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap)
 {
     /*
     if (((m_NumHits + m_NumMisses) % 1024) == 10)
     {
         LOGD("HeiGenCache: %d hits, %d misses, saved %.2f %%", m_NumHits, m_NumMisses, 100.0 * m_NumHits / (m_NumHits + m_NumMisses));
         LOGD("HeiGenCache: Avg cache chain length: %.2f", static_cast<double>(m_TotalChain) / m_NumHits);
     }
     //*/

     for (size_t i = 0; i < m_CacheSize; i++)
     {
         if (m_CacheData[m_CacheOrder[i]].m_Coords != a_ChunkCoords)
         {
             continue;
         }
         // Found it in the cache
         auto Idx = m_CacheOrder[i];

         // Move to front:
         for (size_t j = i; j > 0; j--)
         {
             m_CacheOrder[j] = m_CacheOrder[j - 1];
         }
         m_CacheOrder[0] = Idx;

         // Use the cached data:
         memcpy(a_HeightMap, m_CacheData[Idx].m_HeightMap, sizeof(a_HeightMap));

         m_NumHits++;
         m_TotalChain += i;
         return;
     }  // for i - cache

     // Not in the cache:
     m_NumMisses++;
     m_HeiGenToCache->GenHeightMap(a_ChunkCoords, a_HeightMap);

     // Insert it as the first item in the MRU order:
     auto Idx = m_CacheOrder[m_CacheSize - 1];
     for (auto i = m_CacheSize - 1; i > 0; i--)
     {
         m_CacheOrder[i] = m_CacheOrder[i - 1];
     }  // for i - m_CacheOrder[]
     m_CacheOrder[0] = Idx;
     memcpy(m_CacheData[Idx].m_HeightMap, a_HeightMap, sizeof(a_HeightMap));
     m_CacheData[Idx].m_Coords = a_ChunkCoords;
 }


 HEIGHTTYPE cHeiGenCache::GetHeightAt(int a_BlockX, int a_BlockZ)
 {
     // First try if the chunk is already in the cache:
     int chunkX, chunkZ;
     cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, chunkX, chunkZ);
     HEIGHTTYPE res;
     if (GetHeightAt(chunkX, chunkZ, a_BlockX - chunkX * cChunkDef::Width, a_BlockZ - chunkZ * cChunkDef::Width, res))
     {
         return res;
     }

     // Chunk not in cache, generate the chunk and ask again:
     cChunkDef::HeightMap heightMap;
     GenHeightMap({chunkX, chunkZ}, heightMap);
     return cChunkDef::GetHeight(heightMap, a_BlockX - chunkX * cChunkDef::Width, a_BlockZ - chunkZ * cChunkDef::Width);
 }


 bool cHeiGenCache::GetHeightAt(int a_ChunkX, int a_ChunkZ, int a_RelX, int a_RelZ, HEIGHTTYPE & a_Height)
 {
     for (size_t i = 0; i < m_CacheSize; i++)
     {
         if ((m_CacheData[i].m_Coords.m_ChunkX == a_ChunkX) && (m_CacheData[i].m_Coords.m_ChunkZ == a_ChunkZ))
         {
             a_Height = cChunkDef::GetHeight(m_CacheData[i].m_HeightMap, a_RelX, a_RelZ);
             return true;
         }
     }  // for i - m_CacheData[]
     return false;
 }


 // cHeiGenMultiCache:

 cHeiGenMultiCache::cHeiGenMultiCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches):
     m_NumSubCaches(a_NumSubCaches)
 {
     // Create the individual sub-caches:
     m_SubCaches.reserve(a_NumSubCaches);
     for (size_t i = 0; i < a_NumSubCaches; i++)
     {
         m_SubCaches.push_back(std::make_shared<cHeiGenCache>(a_HeiGenToCache, a_SubCacheSize));
     }
 }


 void cHeiGenMultiCache::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap)
 {
     // Get the subcache responsible for this chunk:
     const size_t cacheIdx = (static_cast<size_t>(a_ChunkCoords.m_ChunkX) + m_CoeffZ * static_cast<size_t>(a_ChunkCoords.m_ChunkZ)) % m_NumSubCaches;

     // Ask the subcache:
     m_SubCaches[cacheIdx]->GenHeightMap(a_ChunkCoords, a_HeightMap);
 }


 HEIGHTTYPE cHeiGenMultiCache::GetHeightAt(int a_BlockX, int a_BlockZ)
 {
     // First try if the chunk is already in the cache:
     int chunkX, chunkZ;
     cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, chunkX, chunkZ);
     HEIGHTTYPE res;
     if (GetHeightAt(chunkX, chunkZ, a_BlockX - chunkX * cChunkDef::Width, a_BlockZ - chunkZ * cChunkDef::Width, res))
     {
         return res;
     }

     // Chunk not in cache, generate the chunk and ask again:
     cChunkDef::HeightMap heightMap;
     GenHeightMap({chunkX, chunkZ}, heightMap);
     return cChunkDef::GetHeight(heightMap, a_BlockX - chunkX * cChunkDef::Width, a_BlockZ - chunkZ * cChunkDef::Width);
 }


 bool cHeiGenMultiCache::GetHeightAt(int a_ChunkX, int a_ChunkZ, int a_RelX, int a_RelZ, HEIGHTTYPE & a_Height)
 {
     // Get the subcache responsible for this chunk:
     const size_t cacheIdx = (static_cast<size_t>(a_ChunkX) + m_CoeffZ * static_cast<size_t>(a_ChunkZ)) % m_NumSubCaches;

     // Ask the subcache:
     return m_SubCaches[cacheIdx]->GetHeightAt(a_ChunkX, a_ChunkZ, a_RelX, a_RelZ, a_Height);
 }


 // cHeiGenClassic:

 cHeiGenClassic::cHeiGenClassic(int a_Seed) :
     m_Seed(a_Seed),
     m_Noise(a_Seed),
     m_HeightFreq1(1.0f),
     m_HeightAmp1(1.0f),
     m_HeightFreq2(0.5f),
     m_HeightAmp2(0.5f),
     m_HeightFreq3(0.1f),
     m_HeightAmp3(0.1f)
 {
 }


 float cHeiGenClassic::GetNoise(float x, float y)
 {
     float oct1 = m_Noise.CubicNoise2D(x * m_HeightFreq1, y * m_HeightFreq1) * m_HeightAmp1;
     float oct2 = m_Noise.CubicNoise2D(x * m_HeightFreq2, y * m_HeightFreq2) * m_HeightAmp2;
     float oct3 = m_Noise.CubicNoise2D(x * m_HeightFreq3, y * m_HeightFreq3) * m_HeightAmp3;

     float height = m_Noise.CubicNoise2D(x * 0.1f, y * 0.1f) * 2;

     float flatness = ((m_Noise.CubicNoise2D(x * 0.5f, y * 0.5f) + 1.f) * 0.5f) * 1.1f;  // 0 ... 1.5
     flatness *= flatness * flatness;

     return (oct1 + oct2 + oct3) * flatness + height;
 }


 void cHeiGenClassic::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap)
 {
     for (int z = 0; z < cChunkDef::Width; z++)
     {
         const float zz = static_cast<float>(a_ChunkCoords.m_ChunkZ * cChunkDef::Width + z);
         for (int x = 0; x < cChunkDef::Width; x++)
         {
             const float xx = static_cast<float>(a_ChunkCoords.m_ChunkX * cChunkDef::Width + x);

             HEIGHTTYPE hei = static_cast<HEIGHTTYPE>(Clamp(static_cast<int>(64 + (GetNoise(xx * 0.05f, zz * 0.05f) * 16)), 10, 250));
             cChunkDef::SetHeight(a_HeightMap, x, z, hei);
         }  // for x
     }  // for z
 }


 void cHeiGenClassic::InitializeHeightGen(cIniFile & a_IniFile)
 {
     m_HeightFreq1 = static_cast<float>(a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq1", 0.1));
     m_HeightFreq2 = static_cast<float>(a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq2", 1.0));
     m_HeightFreq3 = static_cast<float>(a_IniFile.GetValueSetF("Generator", "ClassicHeightFreq3", 2.0));
     m_HeightAmp1  = static_cast<float>(a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp1",  1.0));
     m_HeightAmp2  = static_cast<float>(a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp2",  0.5));
     m_HeightAmp3  = static_cast<float>(a_IniFile.GetValueSetF("Generator", "ClassicHeightAmp3",  0.5));
 }


 // cHeiGenMountains:

 cHeiGenMountains::cHeiGenMountains(int a_Seed) :
     m_Seed(a_Seed),
     m_MountainNoise(a_Seed + 100),
     m_DitchNoise(a_Seed + 200),
     m_Perlin(a_Seed + 300)
 {
 }


 void cHeiGenMountains::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap)
 {
     NOISE_DATATYPE StartX = static_cast<NOISE_DATATYPE>(a_ChunkCoords.m_ChunkX * cChunkDef::Width);
     NOISE_DATATYPE EndX   = static_cast<NOISE_DATATYPE>(a_ChunkCoords.m_ChunkX * cChunkDef::Width + cChunkDef::Width - 1);
     NOISE_DATATYPE StartZ = static_cast<NOISE_DATATYPE>(a_ChunkCoords.m_ChunkZ * cChunkDef::Width);
     NOISE_DATATYPE EndZ   = static_cast<NOISE_DATATYPE>(a_ChunkCoords.m_ChunkZ * cChunkDef::Width + cChunkDef::Width - 1);
     NOISE_DATATYPE Workspace[16 * 16];
     NOISE_DATATYPE MountainNoise[16 * 16];
     NOISE_DATATYPE DitchNoise[16 * 16];
     NOISE_DATATYPE PerlinNoise[16 * 16];
     m_MountainNoise.Generate2D(MountainNoise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
     m_DitchNoise.Generate2D(DitchNoise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
     m_Perlin.Generate2D(PerlinNoise, 16, 16, StartX, EndX, StartZ, EndZ, Workspace);
     for (int z = 0; z < cChunkDef::Width; z++)
     {
         int IdxZ = z * cChunkDef::Width;
         for (int x = 0; x < cChunkDef::Width; x++)
         {
             int idx = IdxZ + x;
             HEIGHTTYPE hei = static_cast<HEIGHTTYPE>(Clamp(100 - static_cast<int>((MountainNoise[idx] - DitchNoise[idx] + PerlinNoise[idx]) * 15), 10, 250));
             cChunkDef::SetHeight(a_HeightMap, x, z, hei);
         }  // for x
     }  // for z
 }


 void cHeiGenMountains::InitializeHeightGen(cIniFile & a_IniFile)
 {
     // TODO: Read the params from an INI file
     m_MountainNoise.AddOctave(0.1f,  0.2f);
     m_MountainNoise.AddOctave(0.05f, 0.4f);
     m_MountainNoise.AddOctave(0.02f, 1.0f);
     m_DitchNoise.AddOctave(0.1f,  0.2f);
     m_DitchNoise.AddOctave(0.05f, 0.4f);
     m_DitchNoise.AddOctave(0.02f, 1.0f);

     m_Perlin.AddOctave(0.01f, 1.5f);
 }


 // cHeiGenBiomal:

 const cHeiGenBiomal::sGenParam cHeiGenBiomal::m_GenParam[256] =
 {
     /*                        Fast-changing | Middle-changing | Slow-changing | */
     /* Biome               |  Freq1  | Amp1 | Freq2   | Amp2  | Freq3  | Amp3 | BaseHeight */
     /* biOcean               */ { 0.1f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  50},
     /* biPlains              */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  68},
     /* biDesert              */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  68},
     /* biExtremeHills        */ { 0.2f,   4.0f,  0.05f,    20.0f,  0.01f,   16.0f, 100},
     /* biForest              */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},
     /* biTaiga               */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},
     /* biSwampland           */ { 0.1f,   1.1f,  0.05f,     1.5f,  0.02f,    2.5f,  61.5},
     /* biRiver               */ { 0.2f,   0.1f,  0.05f,     0.1f,  0.01f,    0.1f,  56},
     /* biNether              */ { 0.1f,   0.0f,  0.01f,     0.0f,  0.01f,    0.0f,   0},  // Unused, but must be here due to indexing
     /* biSky                 */ { 0.1f,   0.0f,  0.01f,     0.0f,  0.01f,    0.0f,   0},  // Unused, but must be here due to indexing
     /* biFrozenOcean         */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},
     /* biFrozenRiver         */ { 0.2f,   0.1f,  0.05f,     0.1f,  0.01f,    0.1f,  56},
     /* biIcePlains           */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  68},
     /* biIceMountains        */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  80},
     /* biMushroomIsland      */ { 0.1f,   2.0f,  0.05f,     8.0f,  0.01f,    6.0f,  80},
     /* biMushroomShore       */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  64},
     /* biBeach               */ { 0.1f,   0.5f,  0.05f,     1.0f,  0.01f,    1.0f,  64},
     /* biDesertHills         */ { 0.2f,   2.0f,  0.05f,     5.0f,  0.01f,    4.0f,  75},
     /* biForestHills         */ { 0.2f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  80},
     /* biTaigaHills          */ { 0.2f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  80},
     /* biExtremeHillsEdge    */ { 0.2f,   3.0f,  0.05f,    16.0f,  0.01f,   12.0f,  80},
     /* biJungle              */ { 0.1f,   3.0f,  0.05f,     6.0f,  0.01f,    6.0f,  70},
     /* biJungleHills         */ { 0.2f,   3.0f,  0.05f,    12.0f,  0.01f,   10.0f,  80},
     /* biJungleEdge          */ { 0.1f,   3.0f,  0.05f,     6.0f,  0.01f,    6.0f,  70},
     /* biDeepOcean           */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},
     /* biStoneBeach          */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},
     /* biColdBeach           */ { 0.1f,   0.5f,  0.05f,     1.0f,  0.01f,    1.0f,  64},
     /* biBirchForest         */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},
     /* biBirchForestHills    */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  80},
     /* biRoofedForest        */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},
     /* biColdTaiga           */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},
     /* biColdTaigaHills      */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  80},
     /* biMegaTaiga           */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},
     /* biMegaTaigaHills      */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  80},
     /* biExtremeHillsPlus    */ { 0.2f,   4.0f,  0.05f,    20.0f,  0.01f,   16.0f, 120},
     /* biSavanna             */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  68},
     /* biSavannaPlateau      */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  80},
     /* biMesa                */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  70},  // 165
     /* biMesaPlateauF        */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  80},
     /* biMesaPlateau         */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  80},

     // biomes 40 .. 128 are unused, 89 empty placeholders here:
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 40 .. 49
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 50 .. 59
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 60 .. 69
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 70 .. 79
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 80 .. 89
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 90 .. 99
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 100 .. 109
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 110 .. 119
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},                                           // 120 .. 128

     /* biSunflowerPlains      */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},  // 129
     /* biDesertM              */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},  // 130
     /* biExtremeHillsM        */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},  // 131
     /* biFlowerForest         */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},  // 132
     /* biTaigaM               */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},  // 133
     /* biSwamplandM           */ { 1.0f,   3.0f,  1.10f,     7.0f,  0.01f,   0.01f,  60},  // 134

     // Biomes 135 .. 139 unused, 5 empty placeholders here:
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 135 .. 139

     /* biIcePlainsSpikes      */ { 0.1f,   2.0f,  0.05f,    12.0f,  0.01f,   10.0f,  40},  // 140

     // Biomes 141 .. 148 unused, 8 empty placeholders here:
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 141 .. 148

     /* biJungleM              */ { 0.1f,   3.0f,  0.05f,     6.0f,  0.01f,    6.0f,  70},  // 149
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},                                               // 150
     /* biJungleEdgeM          */ { 0.1f,   3.0f,  0.05f,     6.0f,  0.01f,    6.0f,  70},  // 151
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0}, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},  // 152 .. 154
     /* biBirchForestM         */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},  // 155
     /* biBirchForestHillsM    */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  80},  // 156
     /* biRoofedForestM        */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},  // 157
     /* biColdTaigaM           */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},  // 158
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0},                                               // 159
     /* biMegaSpruceTaiga      */ { 0.1f,   1.0f,  0.05f,     2.0f,  0.01f,    4.0f,  70},  // 160
     /* biMegaSpruceTaigaHills */ { 0.2f,   2.0f,  0.05f,    10.0f,  0.01f,    8.0f,  80},  // 161
     /* biExtremeHillsPlusM    */ { 0.2f,   4.0f,  0.05f,    20.0f,  0.01f,   16.0f, 120},  // 162
     /* biSavannaM             */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  68},  // 163
     /* biSavannaPlateauM      */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  80},  // 164
     /* biMesaBryce            */ { 0.2f,   2.0f,  0.1f,     30.0f,  0.01f,    8.0f,  80},
     /* biMesaPlateauFM        */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  80},  // 166
     /* biMesaPlateauM         */ { 0.1f,   1.0f,  0.05f,     1.5f,  0.01f,    4.0f,  80},  // 167
 } ;


 void cHeiGenBiomal::GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap)
 {
     // Generate a 3x3 chunk area of biomes around this chunk:
     BiomeNeighbors Biomes;
     for (int z = -1; z <= 1; z++)
     {
         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]);
         }  // for x
     }  // for z

     // Linearly interpolate 4x4 blocks of heightmap:
     // Must be done on a floating point datatype, otherwise the results are ugly!
     const int STEPZ = 4;  // Must be a divisor of 16
     const int STEPX = 4;  // Must be a divisor of 16
     NOISE_DATATYPE Height[17 * 17];
     for (int z = 0; z < 17; z += STEPZ)
     {
         for (int x = 0; x < 17; x += STEPX)
         {
             Height[x + 17 * z] = GetHeightAt(x, z, a_ChunkCoords.m_ChunkX, a_ChunkCoords.m_ChunkZ, Biomes);
         }
     }
     LinearUpscale2DArrayInPlace<17, 17, STEPX, STEPZ>(Height);

     // Copy into the heightmap
     for (int z = 0; z < cChunkDef::Width; z++)
     {
         for (int x = 0; x < cChunkDef::Width; x++)
         {
             cChunkDef::SetHeight(a_HeightMap, x, z, static_cast<HEIGHTTYPE>(Height[x + 17 * z]));
         }
     }
 }


 void cHeiGenBiomal::InitializeHeightGen(cIniFile & a_IniFile)
 {
     // No user-settable params
 }


 NOISE_DATATYPE cHeiGenBiomal::GetHeightAt(int a_RelX, int a_RelZ, int a_ChunkX, int a_ChunkZ, const cHeiGenBiomal::BiomeNeighbors & a_BiomeNeighbors)
 {
     // Sum up how many biomes of each type there are in the neighborhood:
     int BiomeCounts[256];
     memset(BiomeCounts, 0, sizeof(BiomeCounts));
     int Sum = 0;
     for (int z = -8; z <= 8; z++)
     {
         int FinalZ = a_RelZ + z + cChunkDef::Width;
         int IdxZ = FinalZ / cChunkDef::Width;
         int ModZ = FinalZ % cChunkDef::Width;
         int WeightZ = 9 - abs(z);
         for (int x = -8; x <= 8; x++)
         {
             int FinalX = a_RelX + x + cChunkDef::Width;
             int IdxX = FinalX / cChunkDef::Width;
             int ModX = FinalX % cChunkDef::Width;
             EMCSBiome Biome = cChunkDef::GetBiome(a_BiomeNeighbors[IdxX][IdxZ], ModX, ModZ);
             int WeightX = 9 - abs(x);
             BiomeCounts[Biome] += WeightX + WeightZ;
             Sum += WeightX + WeightZ;
         }  // for x
     }  // for z

     // For each biome type that has a nonzero count, calc its height and add it:
     if (Sum > 0)
     {
         NOISE_DATATYPE Height = 0;
         int BlockX = a_ChunkX * cChunkDef::Width + a_RelX;
         int BlockZ = a_ChunkZ * cChunkDef::Width + a_RelZ;
         for (size_t i = 0; i < ARRAYCOUNT(BiomeCounts); i++)
         {
             if (BiomeCounts[i] == 0)
             {
                 continue;
             }

             /*
             // Sanity checks for biome parameters, enable them to check the biome param table in runtime (slow):
             ASSERT(m_GenParam[i].m_HeightFreq1 >= 0);
             ASSERT(m_GenParam[i].m_HeightFreq1 < 1000);
             ASSERT(m_GenParam[i].m_HeightFreq2 >= 0);
             ASSERT(m_GenParam[i].m_HeightFreq2 < 1000);
             ASSERT(m_GenParam[i].m_HeightFreq3 >= 0);
             ASSERT(m_GenParam[i].m_HeightFreq3 < 1000);
             */

             NOISE_DATATYPE oct1 = m_Noise.CubicNoise2D(BlockX * m_GenParam[i].m_HeightFreq1, BlockZ * m_GenParam[i].m_HeightFreq1) * m_GenParam[i].m_HeightAmp1;
             NOISE_DATATYPE oct2 = m_Noise.CubicNoise2D(BlockX * m_GenParam[i].m_HeightFreq2, BlockZ * m_GenParam[i].m_HeightFreq2) * m_GenParam[i].m_HeightAmp2;
             NOISE_DATATYPE oct3 = m_Noise.CubicNoise2D(BlockX * m_GenParam[i].m_HeightFreq3, BlockZ * m_GenParam[i].m_HeightFreq3) * m_GenParam[i].m_HeightAmp3;
             Height += BiomeCounts[i] * (m_GenParam[i].m_BaseHeight + oct1 + oct2 + oct3);
         }
         NOISE_DATATYPE res = Height / Sum;
         return std::min(static_cast<NOISE_DATATYPE>(250), std::max(res, static_cast<NOISE_DATATYPE>(5)));
     }

     // No known biome around? Weird. Return a bogus value:
     ASSERT(!"cHeiGenBiomal: Biome sum failed, no known biome around");
     return 5;
 }


 // cHeiGenMinMax:

 class cHeiGenMinMax:
     public cTerrainHeightGen
 {
     typedef cTerrainHeightGen Super;

     static const int AVERAGING_SIZE = 4;

 public:
     cHeiGenMinMax(int a_Seed, cBiomeGenPtr a_BiomeGen):
         m_Noise(a_Seed),
         m_BiomeGen(a_BiomeGen),
         m_TotalWeight(0)
     {
         // Initialize the weights:
         for (int z = 0; z <= AVERAGING_SIZE * 2; z++)
         {
             for (int x = 0; x <= AVERAGING_SIZE * 2; x++)
             {
                 m_Weights[z][x] = 1 + 2 * AVERAGING_SIZE - std::abs(x - AVERAGING_SIZE) - std::abs(z - AVERAGING_SIZE);
                 m_TotalWeight += m_Weights[z][x];
             }
         }

         // Initialize the Perlin generator:
         m_Perlin.AddOctave(0.04f,   0.2f);
         m_Perlin.AddOctave(0.02f,   0.1f);
         m_Perlin.AddOctave(0.01f,   0.05f);
     }


     virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap & a_HeightMap) override
     {
         // Generate the biomes for the 3 * 3 neighbors:
         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]);
         }

         // Get the min and max heights based on the biomes:
         double minHeight[cChunkDef::Width * cChunkDef::Width];
         double maxHeight[cChunkDef::Width * cChunkDef::Width];
         for (int z = 0; z < cChunkDef::Width; z++)
         {
             for (int x = 0; x < cChunkDef::Width; x++)
             {
                 // For each column, sum the min and max values of the neighborhood around it:
                 double min = 0, max = 0;
                 for (int relz = 0; relz <= AVERAGING_SIZE * 2; relz++)
                 {
                     int bz = z + 16 + relz - AVERAGING_SIZE;  // Biome Z coord relative to the neighborBiomes start
                     int cz = bz / 16;                         // Chunk Z coord relative to the neighborBiomes start
                     bz = bz % 16;                             // Biome Z coord relative to cz in neighborBiomes
                     for (int relx = 0; relx <= AVERAGING_SIZE * 2; relx++)
                     {
                         int bx = x + 16 + relx - AVERAGING_SIZE;  // Biome X coord relative to the neighborBiomes start
                         int cx = bx / 16;                         // Chunk X coord relative to the neighborBiomes start
                         bx = bx % 16;                             // Biome X coord relative to cz in neighborBiomes

                         // Get the biome's min and max heights:
                         double bmin, bmax;
                         getBiomeMinMax(cChunkDef::GetBiome(neighborBiomes[cz][cx], bx, bz), bmin, bmax);

                         // Add them to the total, with the weight depending on their relative position to the column:
                         min += bmin * m_Weights[relz][relx];
                         max += bmax * m_Weights[relz][relx];
                     }  // for relx
                 }  // for relz
                 minHeight[x + z * cChunkDef::Width] = min / m_TotalWeight;
                 maxHeight[x + z * cChunkDef::Width] = max / m_TotalWeight;
             }  // for x
         }  // for z

         // Generate the base noise:
         NOISE_DATATYPE noise[cChunkDef::Width * cChunkDef::Width];
         NOISE_DATATYPE workspace[cChunkDef::Width * cChunkDef::Width];
         NOISE_DATATYPE startX = static_cast<float>(a_ChunkCoords.m_ChunkX * cChunkDef::Width);
         NOISE_DATATYPE endX = startX + cChunkDef::Width - 1;
         NOISE_DATATYPE startZ = static_cast<float>(a_ChunkCoords.m_ChunkZ * cChunkDef::Width);
         NOISE_DATATYPE endZ = startZ + cChunkDef::Width - 1;
         m_Perlin.Generate2D(noise, 16, 16, startX, endX, startZ, endZ, workspace);

         // Make the height by ranging the noise between min and max:
         for (int z = 0; z < cChunkDef::Width; z++)
         {
             for (int x = 0; x < cChunkDef::Width; x++)
             {
                 double min = minHeight[x + z * cChunkDef::Width];
                 double max = maxHeight[x + z * cChunkDef::Width];
                 double h = (max + min) / 2 + noise[x + z * cChunkDef::Width] * (max - min);
                 cChunkDef::SetHeight(a_HeightMap, x, z, static_cast<HEIGHTTYPE>(h));
             }
         }
     }


     virtual void InitializeHeightGen(cIniFile & a_IniFile) override
     {
         // No settings available
     }

 protected:
     cNoise m_Noise;

     cPerlinNoise m_Perlin;

     cBiomeGenPtr m_BiomeGen;

     double m_Weights[AVERAGING_SIZE * 2 + 1][AVERAGING_SIZE * 2 + 1];

     double m_TotalWeight;


     void getBiomeMinMax(EMCSBiome a_Biome, double & a_Min, double & a_Max)
     {
         switch (a_Biome)
         {
             case biBeach:                a_Min = 61; a_Max = 64; break;
             case biBirchForest:          a_Min = 63; a_Max = 75; break;
             case biBirchForestHills:     a_Min = 63; a_Max = 90; break;
             case biBirchForestHillsM:    a_Min = 63; a_Max = 90; break;
             case biBirchForestM:         a_Min = 63; a_Max = 75; break;
             case biColdBeach:            a_Min = 61; a_Max = 64; break;
             case biColdTaiga:            a_Min = 63; a_Max = 75; break;
             case biColdTaigaHills:       a_Min = 63; a_Max = 90; break;
             case biColdTaigaM:           a_Min = 63; a_Max = 75; break;
             case biDeepOcean:            a_Min = 30; a_Max = 60; break;
             case biDesert:               a_Min = 63; a_Max = 70; break;
             case biDesertHills:          a_Min = 63; a_Max = 85; break;
             case biDesertM:              a_Min = 63; a_Max = 70; break;
             case biEnd:                  a_Min = 10; a_Max = 100; break;
             case biExtremeHills:         a_Min = 60; a_Max = 120; break;
             case biExtremeHillsEdge:     a_Min = 63; a_Max = 100; break;
             case biExtremeHillsM:        a_Min = 60; a_Max = 120; break;
             case biExtremeHillsPlus:     a_Min = 60; a_Max = 140; break;
             case biExtremeHillsPlusM:    a_Min = 60; a_Max = 140; break;
             case biFlowerForest:         a_Min = 63; a_Max = 75; break;
             case biForest:               a_Min = 63; a_Max = 75; break;
             case biForestHills:          a_Min = 63; a_Max = 90; break;
             case biFrozenOcean:          a_Min = 45; a_Max = 64; break;
             case biFrozenRiver:          a_Min = 60; a_Max = 62; break;
             case biIceMountains:         a_Min = 63; a_Max = 90; break;
             case biIcePlains:            a_Min = 63; a_Max = 70; break;
             case biIcePlainsSpikes:      a_Min = 60; a_Max = 70; break;
             case biJungle:               a_Min = 60; a_Max = 80; break;
             case biJungleEdge:           a_Min = 62; a_Max = 75; break;
             case biJungleEdgeM:          a_Min = 62; a_Max = 75; break;
             case biJungleHills:          a_Min = 60; a_Max = 90; break;
             case biJungleM:              a_Min = 60; a_Max = 75; break;
             case biMegaSpruceTaiga:      a_Min = 63; a_Max = 75; break;
             case biMegaSpruceTaigaHills: a_Min = 63; a_Max = 90; break;
             case biMegaTaiga:            a_Min = 63; a_Max = 75; break;
             case biMegaTaigaHills:       a_Min = 63; a_Max = 90; break;
             case biMesa:                 a_Min = 63; a_Max = 90; break;
             case biMesaBryce:            a_Min = 60; a_Max = 67; break;
             case biMesaPlateau:          a_Min = 75; a_Max = 85; break;
             case biMesaPlateauF:         a_Min = 80; a_Max = 90; break;
             case biMesaPlateauFM:        a_Min = 80; a_Max = 90; break;
             case biMesaPlateauM:         a_Min = 75; a_Max = 85; break;
             case biMushroomIsland:       a_Min = 63; a_Max = 90; break;
             case biMushroomShore:        a_Min = 60; a_Max = 75; break;
             case biNether:               a_Min = 10; a_Max = 100; break;
             case biOcean:                a_Min = 45; a_Max = 64; break;
             case biPlains:               a_Min = 63; a_Max = 70; break;
             case biRiver:                a_Min = 60; a_Max = 62; break;
             case biRoofedForest:         a_Min = 63; a_Max = 75; break;
             case biRoofedForestM:        a_Min = 63; a_Max = 75; break;
             case biSavanna:              a_Min = 63; a_Max = 75; break;
             case biSavannaM:             a_Min = 63; a_Max = 80; break;
             case biSavannaPlateau:       a_Min = 75; a_Max = 100; break;
             case biSavannaPlateauM:      a_Min = 80; a_Max = 160; break;
             case biStoneBeach:           a_Min = 60; a_Max = 64; break;
             case biSunflowerPlains:      a_Min = 63; a_Max = 70; break;
             case biSwampland:            a_Min = 60; a_Max = 67; break;
             case biSwamplandM:           a_Min = 61; a_Max = 67; break;
             case biTaiga:                a_Min = 63; a_Max = 75; break;
             case biTaigaHills:           a_Min = 63; a_Max = 90; break;
             case biTaigaM:               a_Min = 63; a_Max = 80; break;
             case biInvalidBiome:
             case biNumBiomes:
             case biVariant:
             case biNumVariantBiomes:
             {
                 ASSERT(!"Unknown biome");
                 a_Min = 10;
                 a_Max = 10;
                 break;
             }
         }
     }
 };


 // cTerrainHeightGen:

 cTerrainHeightGenPtr cTerrainHeightGen::CreateHeightGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, int a_Seed, bool & a_CacheOffByDefault)
 {
     AString HeightGenName = a_IniFile.GetValueSet("Generator", "HeightGen", "");
     if (HeightGenName.empty())
     {
         LOGWARN("[Generator] HeightGen value not set in world.ini, using \"Biomal\".");
         HeightGenName = "Biomal";
     }

     a_CacheOffByDefault = false;
     cTerrainHeightGenPtr res;
     if (NoCaseCompare(HeightGenName, "Flat") == 0)
     {
         res = std::make_shared<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);
     }
     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();
     }
     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();
     }
     else if (NoCaseCompare(HeightGenName, "MinMax") == 0)
     {
         res = std::make_shared<cHeiGenMinMax>(a_Seed, a_BiomeGen);
     }
     else if (NoCaseCompare(HeightGenName, "Mountains") == 0)
     {
         res = std::make_shared<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();
     }
     else if (NoCaseCompare(HeightGenName, "Steppy") == 0)
     {
         res = std::make_shared<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();
     }
     else if (NoCaseCompare(HeightGenName, "Biomal") == 0)
     {
         res = std::make_shared<cHeiGenBiomal>(a_Seed, a_BiomeGen);

         /*
         // Performance-testing:
         LOGINFO("Measuring performance of cHeiGenBiomal...");
         clock_t BeginTick = clock();
         for (int x = 0; x < 500; x++)
         {
             cChunkDef::HeightMap Heights;
             res->GenHeightMap(x * 5, x * 5, Heights);
         }
         clock_t Duration = clock() - BeginTick;
         LOGINFO("HeightGen for 500 chunks took %d ticks (%.02f sec)", Duration, (double)Duration / CLOCKS_PER_SEC);
         //*/
     }
     else
     {
         // No match found, force-set the default and retry
         LOGWARN("Unknown HeightGen \"%s\", using \"Biomal\" instead.", HeightGenName.c_str());
         a_IniFile.SetValue("Generator", "HeightGen", "Biomal");
         return CreateHeightGen(a_IniFile, a_BiomeGen, a_Seed, a_CacheOffByDefault);
     }

     // Read the settings:
     res->InitializeHeightGen(a_IniFile);

     return res;
 }


biExtremeHillsM
Definition: BiomeDef.h:83

cHeiGenCache::m_CacheOrder
std::vector< size_t > m_CacheOrder
Definition: HeiGen.h:58

biFrozenRiver
Definition: BiomeDef.h:39

cHeiGenMultiCache::m_CoeffZ
static const size_t m_CoeffZ
The coefficient used to turn Z coords into index (x + Coeff * z).
Definition: HeiGen.h:91

biNether
Definition: BiomeDef.h:35

biTaigaM
Definition: BiomeDef.h:85

biColdTaigaHills
Definition: BiomeDef.h:62

biForestHills
Definition: BiomeDef.h:47

cHeiGenBiomal::InitializeHeightGen
virtual void InitializeHeightGen(cIniFile &a_IniFile) override
Initializes the generator, reading its parameters from the INI file.
Definition: HeiGen.cpp:552

biRoofedForestM
Definition: BiomeDef.h:92

biFlowerForest
Definition: BiomeDef.h:84

cHeiGenFlat::InitializeHeightGen
virtual void InitializeHeightGen(cIniFile &a_IniFile) override
Initializes the generator, reading its parameters from the INI file.
Definition: HeiGen.cpp:97

biIceMountains
Definition: BiomeDef.h:42

cHeiGenClassic::m_HeightAmp3
float m_HeightAmp3
Definition: HeiGen.h:135

biJungleEdge
Definition: BiomeDef.h:54

biMesaPlateauM
Definition: BiomeDef.h:101

cIniFile::GetValueSetF
double GetValueSetF(const AString &keyname, const AString &valuename, const double defValue=0.0)
Definition: IniFile.cpp:547

biDesert
Definition: BiomeDef.h:28

cHeiGenMinMax::m_BiomeGen
cBiomeGenPtr m_BiomeGen
The biome generator to query for the underlying biomes.
Definition: HeiGen.cpp:737

biTaiga
Definition: BiomeDef.h:31

DistortedHeightmap.h

biIcePlains
Definition: BiomeDef.h:40

cHeiGenMountains::m_DitchNoise
cRidgedMultiNoise m_DitchNoise
Definition: HeiGen.h:158

biExtremeHillsPlus
Definition: BiomeDef.h:65

cHeiGenMinMax::m_Perlin
cPerlinNoise m_Perlin
Definition: HeiGen.cpp:734

cHeiGenClassic::m_HeightFreq3
float m_HeightFreq3
Definition: HeiGen.h:135

biDesertHills
Definition: BiomeDef.h:46

cTerrainHeightGenPtr
std::shared_ptr< cTerrainHeightGen > cTerrainHeightGenPtr
Definition: ComposableGenerator.h:35

biMesaPlateauFM
Definition: BiomeDef.h:100

biIcePlainsSpikes
Definition: BiomeDef.h:87

biExtremeHills
Definition: BiomeDef.h:29

biBirchForest
Definition: BiomeDef.h:58

cHeiGenCache::m_NumHits
size_t m_NumHits
Definition: HeiGen.h:62

LOGWARN
#define LOGWARN
Definition: LoggerSimple.h:43

cChunkDef::Width
static const int Width
Definition: ChunkDef.h:134

biInvalidBiome
Definition: BiomeDef.h:23

biBirchForestHillsM
Definition: BiomeDef.h:91

biMegaTaiga
Definition: BiomeDef.h:63

cTerrainHeightGen
The interface that is used to query terrain height from the shape generator.
Definition: ComposableGenerator.h:115

cHeiGenMultiCache::m_NumSubCaches
size_t m_NumSubCaches
Number of sub-caches, pulled out of m_SubCaches.size() for performance reasons.
Definition: HeiGen.h:94

cChunkDef::GetHeight
static HEIGHTTYPE GetHeight(const HeightMap &a_HeightMap, int a_X, int a_Z)
Definition: ChunkDef.h:351

biEnd
Definition: BiomeDef.h:37

biMesa
Definition: BiomeDef.h:68

cHeiGenMultiCache::cHeiGenMultiCache
cHeiGenMultiCache(cTerrainHeightGenPtr a_HeightGenToCache, size_t a_SubCacheSize, size_t a_NumSubCaches)
Definition: HeiGen.cpp:222

biMushroomShore
Definition: BiomeDef.h:44

biSwamplandM
Definition: BiomeDef.h:86

biSwampland
Definition: BiomeDef.h:32

biMesaPlateauF
Definition: BiomeDef.h:69

cHeiGenMultiCache::m_SubCaches
cHeiGenCachePtrs m_SubCaches
The individual sub-caches.
Definition: HeiGen.h:97

ProtIntGen.h

biSavanna
Definition: BiomeDef.h:66

Noise3DGenerator.h

biJungle
Definition: BiomeDef.h:50

EMCSBiome
EMCSBiome
Biome IDs The first batch corresponds to the clientside biomes, used by MineCraft.
Definition: BiomeDef.h:21

biMegaTaigaHills
Definition: BiomeDef.h:64

biSavannaPlateauM
Definition: BiomeDef.h:98

HEIGHTTYPE
unsigned char HEIGHTTYPE
The type used by the heightmap.
Definition: ChunkDef.h:48

biColdTaiga
Definition: BiomeDef.h:61

biPlains
Definition: BiomeDef.h:27

biNumVariantBiomes
Definition: BiomeDef.h:103

biFrozenOcean
Definition: BiomeDef.h:38

cHeiGenClassic::GetNoise
float GetNoise(float x, float y)
Definition: HeiGen.cpp:303

cHeiGenMinMax::InitializeHeightGen
virtual void InitializeHeightGen(cIniFile &a_IniFile) override
Initializes the generator, reading its parameters from the INI file.
Definition: HeiGen.cpp:726

biForest
Definition: BiomeDef.h:30

cChunkDef::Height
static const int Height
Definition: ChunkDef.h:135

cHeiGenCache::m_CacheSize
size_t m_CacheSize
Definition: HeiGen.h:57

biMesaPlateau
Definition: BiomeDef.h:70

cHeiGenMinMax::m_Noise
cNoise m_Noise
Definition: HeiGen.cpp:732

biMegaSpruceTaigaHills
Definition: BiomeDef.h:95

cChunkDef::BlockToChunk
static void BlockToChunk(int a_X, int a_Z, int &a_ChunkX, int &a_ChunkZ)
Converts absolute block coords to chunk coords:
Definition: ChunkDef.h:234

cHeiGenBiomal::BiomeNeighbors
cChunkDef::BiomeMap BiomeNeighbors[3][3]
Definition: HeiGen.h:192

cHeiGenSteppy::m_Seed
int m_Seed
Definition: HeiGen.cpp:72

biJungleHills
Definition: BiomeDef.h:51

cHeiGenMinMax::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:660

cHeiGenClassic::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:321

biMesaBryce
Definition: BiomeDef.h:99

cHeiGenClassic::m_HeightAmp2
float m_HeightAmp2
Definition: HeiGen.h:134

biMushroomIsland
Definition: BiomeDef.h:43

biColdBeach
Definition: BiomeDef.h:57

cIniFile::SetValue
bool SetValue(const int keyID, const int valueID, const AString &value)
Definition: IniFile.cpp:393

NoCaseCompare
int NoCaseCompare(const AString &s1, const AString &s2)
Case-insensitive string comparison.
Definition: StringUtils.cpp:289

biDeepOcean
Definition: BiomeDef.h:55

cHeiGenCache::GetHeightAt
virtual HEIGHTTYPE GetHeightAt(int a_BlockX, int a_BlockZ) override
Returns the height at the specified column.
Definition: HeiGen.cpp:181

biColdTaigaM
Definition: BiomeDef.h:93

cHeiGenBiomal::m_GenParam
static const sGenParam m_GenParam[256]
Definition: HeiGen.h:205

biStoneBeach
Definition: BiomeDef.h:56

cHeiGenMinMax::m_TotalWeight
double m_TotalWeight
Sum of all the m_Weights items.
Definition: HeiGen.cpp:743

cTerrainHeightGen::CreateHeightGen
static cTerrainHeightGenPtr CreateHeightGen(cIniFile &a_IniFile, cBiomeGenPtr a_BiomeGen, int a_Seed, bool &a_CacheOffByDefault)
Creates a cTerrainHeightGen descendant based on the INI file settings.
Definition: HeiGen.cpp:833

cHeiGenMultiCache::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:237

cHeiGenMountains::cHeiGenMountains
cHeiGenMountains(int a_Seed)
Definition: HeiGen.cpp:357

NOISE_DATATYPE
float NOISE_DATATYPE
The datatype used by all the noise generators.
Definition: Noise.h:9

cHeiGenMountains::m_Perlin
cPerlinNoise m_Perlin
Definition: HeiGen.h:159

biRoofedForest
Definition: BiomeDef.h:60

biSunflowerPlains
Definition: BiomeDef.h:81

cHeiGenCache::m_CacheData
std::vector< sCacheData > m_CacheData
Definition: HeiGen.h:59

biNumBiomes
Definition: BiomeDef.h:73

ASSERT
#define ASSERT(x)
Definition: Globals.h:335

cHeiGenCache::cHeiGenCache
cHeiGenCache(cTerrainHeightGenPtr a_HeiGenToCache, size_t a_CacheSize)
Definition: HeiGen.cpp:109

cHeiGenClassic::InitializeHeightGen
virtual void InitializeHeightGen(cIniFile &a_IniFile) override
Initializes the generator, reading its parameters from the INI file.
Definition: HeiGen.cpp:340

cHeiGenSteppy::m_Gen
std::shared_ptr< cProtIntGen > m_Gen
Definition: HeiGen.cpp:74

cHeiGenMinMax
Definition: HeiGen.cpp:629

cHeiGenClassic::m_HeightFreq1
float m_HeightFreq1
Definition: HeiGen.h:133

biSavannaPlateau
Definition: BiomeDef.h:67

cHeiGenClassic::m_Seed
int m_Seed
Definition: HeiGen.h:131

biBirchForestHills
Definition: BiomeDef.h:59

HeiGen.h

cOctavedNoise< cCubicNoise >

cChunkCoords::m_ChunkZ
int m_ChunkZ
Definition: ChunkDef.h:60

UNUSED
#define UNUSED
Definition: Globals.h:152

cNoise
Definition: Noise.h:19

cHeiGenMountains::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:369

biDesertM
Definition: BiomeDef.h:82

cHeiGenSteppy
Definition: HeiGen.cpp:22

cHeiGenClassic::m_Noise
cNoise m_Noise
Definition: HeiGen.h:132

Clamp
T Clamp(T a_Value, T a_Min, T a_Max)
Clamp X to the specified range.
Definition: Globals.h:351

cHeiGenBiomal::GetHeightAt
virtual HEIGHTTYPE GetHeightAt(int a_BlockX, int a_BlockZ) override
Returns the height at the specified column.
Definition: HeiGen.h:184

cHeiGenCache::m_HeiGenToCache
cTerrainHeightGenPtr m_HeiGenToCache
The terrain height generator that is being cached.
Definition: HeiGen.h:54

cHeiGenMountains::m_MountainNoise
cRidgedMultiNoise m_MountainNoise
Definition: HeiGen.h:157

cChunkDef::SetHeight
static void SetHeight(HeightMap &a_HeightMap, int a_X, int a_Z, HEIGHTTYPE a_Height)
Definition: ChunkDef.h:359

biRiver
Definition: BiomeDef.h:33

biOcean
Definition: BiomeDef.h:26

cChunkCoords::m_ChunkX
int m_ChunkX
Definition: ChunkDef.h:59

cHeiGenMinMax::getBiomeMinMax
void getBiomeMinMax(EMCSBiome a_Biome, double &a_Min, double &a_Max)
Returns the minimum and maximum heights for the given biome.
Definition: HeiGen.cpp:747

AString
std::string AString
Definition: StringUtils.h:13

cHeiGenMountains::InitializeHeightGen
virtual void InitializeHeightGen(cIniFile &a_IniFile) override
Initializes the generator, reading its parameters from the INI file.
Definition: HeiGen.cpp:398

cHeiGenClassic::cHeiGenClassic
cHeiGenClassic(int a_Seed)
Definition: HeiGen.cpp:287

cHeiGenCache::m_NumMisses
size_t m_NumMisses
Definition: HeiGen.h:63

Globals.h

biMegaSpruceTaiga
Definition: BiomeDef.h:94

biBeach
Definition: BiomeDef.h:45

cOctavedNoise::AddOctave
void AddOctave(NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude)
Adds a new octave to the list of octaves that compose this noise.
Definition: OctavedNoise.h:38

cHeiGenBiomal::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:512

cHeiGenBiomal::sGenParam
Definition: HeiGen.h:198

cIniFile::GetValueSetI
int GetValueSetI(const AString &keyname, const AString &valuename, const int defValue=0) override
Definition: IniFile.cpp:558

cHeiGenMinMax::cHeiGenMinMax
cHeiGenMinMax(int a_Seed, cBiomeGenPtr a_BiomeGen)
Definition: HeiGen.cpp:638

cHeiGenSteppy::cHeiGenSteppy
cHeiGenSteppy(int a_Seed)
Definition: HeiGen.cpp:26

cHeiGenClassic::m_HeightFreq2
float m_HeightFreq2
Definition: HeiGen.h:134

cOctavedNoise::Generate2D
void Generate2D(NOISE_DATATYPE *a_Array, int a_SizeX, int a_SizeY, NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX, NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY, NOISE_DATATYPE *a_Workspace=nullptr) const
Fills a 2D array with the values of the noise.
Definition: OctavedNoise.h:45

cHeiGenSteppy::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:58

biJungleEdgeM
Definition: BiomeDef.h:89

biVariant
Definition: BiomeDef.h:77

biSavannaM
Definition: BiomeDef.h:97

biJungleM
Definition: BiomeDef.h:88

cHeiGenMinMax::Super
cTerrainHeightGen Super
Definition: HeiGen.cpp:632

cHeiGenFlat::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:84

cHeiGenClassic::m_HeightAmp1
float m_HeightAmp1
Definition: HeiGen.h:133

biTaigaHills
Definition: BiomeDef.h:48

cChunkDef::HeightMap
HEIGHTTYPE HeightMap[Width *Width]
The type used for any heightmap operations and storage; idx = x + Width * z; Height points to the hig...
Definition: ChunkDef.h:142

cNoise::CubicNoise2D
NOISE_DATATYPE CubicNoise2D(NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y) const
Definition: Noise.cpp:593

cChunkDef::BiomeMap
EMCSBiome BiomeMap[Width *Width]
The type used for any biomemap operations and storage inside Cuberite, using Cuberite biomes (need no...
Definition: ChunkDef.h:147

cHeiGenMultiCache::GetHeightAt
virtual HEIGHTTYPE GetHeightAt(int a_BlockX, int a_BlockZ) override
Returns the height at the specified column.
Definition: HeiGen.cpp:250

ARRAYCOUNT
#define ARRAYCOUNT(X)
Evaluates to the number of elements in an array (compile-time!)
Definition: Globals.h:290

cTerrainHeightGen::GetHeightAt
virtual HEIGHTTYPE GetHeightAt(int a_BlockX, int a_BlockZ)
Returns the height at the specified column.
Definition: ComposableGenerator.h:129

cHeiGenCache::GenHeightMap
virtual void GenHeightMap(cChunkCoords a_ChunkCoords, cChunkDef::HeightMap &a_HeightMap) override
Retrieves the heightmap for the specified chunk.
Definition: HeiGen.cpp:128

biExtremeHillsPlusM
Definition: BiomeDef.h:96

EndGen.h

cIniFile
Definition: IniFile.h:33

cChunkCoords
Definition: ChunkDef.h:56

biExtremeHillsEdge
Definition: BiomeDef.h:49

biBirchForestM
Definition: BiomeDef.h:90

cHeiGenCache::m_TotalChain
size_t m_TotalChain
Definition: HeiGen.h:64

cChunkDef::GetBiome
static EMCSBiome GetBiome(const BiomeMap &a_BiomeMap, int a_X, int a_Z)
Definition: ChunkDef.h:367

cIniFile::GetValueSet
AString GetValueSet(const AString &keyname, const AString &valuename, const AString &defValue="") override
Gets the value; if not found, write the default to the repository.
Definition: IniFile.cpp:524

cBiomeGenPtr
std::shared_ptr< cBiomeGen > cBiomeGenPtr
Definition: ComposableGenerator.h:32