VerticalStrategy.cpp

Go to the documentation of this file.

 
// VerticalStrategy.cpp
 
// Implements the various classes descending from cPiece::cVerticalStrategy
 
#include "Globals.h"
#include "VerticalStrategy.h"
#include "../Noise/Noise.h"
 
 
 
 
 
// Constant that is added to random seed
static const int SEED_OFFSET = 135;
 
 
 
// Globals:
 
namespace VerticalStrategy
{
    static bool ParseRange(const AString & a_Params, int & a_Min, int & a_Range, bool a_LogWarnings)
    {
        auto params = StringSplitAndTrim(a_Params, "|");
        if (params.size() == 0)
        {
            // No params, generate directly on top:
            return true;
        }
        if (!StringToInteger(params[0], a_Min))
        {
            // Failed to parse the min rel height:
            CONDWARNING(a_LogWarnings, "Cannot parse minimum height from string \"%s\"!", params[0].c_str());
            return false;
        }
        if (params.size() == 1)
        {
            // Only one param was given, there's no range
            return true;
        }
        int maxHeight = a_Min;
        if (!StringToInteger(params[1], maxHeight))
        {
            CONDWARNING(a_LogWarnings, "Cannot parse maximum height from string \"%s\"!", params[1].c_str());
            return false;
        }
        if (maxHeight < a_Min)
        {
            std::swap(maxHeight, a_Min);
        }
        a_Range = maxHeight - a_Min + 1;
        return true;
    }
}
 
 
 
 
 
 
class cVerticalStrategyFixed:
    public cPiece::cVerticalStrategy
{
public:
    cVerticalStrategyFixed(void):
        m_Height(-1000)  // Default to "unassigned" height
    {
    }
 
 
    virtual int GetVerticalPlacement(int a_BlockX, int a_BlockZ) override
    {
        return m_Height;
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Params: "<Height>", compulsory
        if (!StringToInteger(a_Params, m_Height))
        {
            CONDWARNING(a_LogWarnings, "Cannot parse the fixed height from string \"%s\"!", a_Params.c_str());
            return false;
        }
        return true;
    }
 
protected:
    int m_Height;
};
 
 
 
 
 
 
class cVerticalStrategyRange:
    public cPiece::cVerticalStrategy
{
public:
    cVerticalStrategyRange(void):
        m_Seed(0),
        m_Min(-1),  // Default to "unassigned" height
        m_Range(1)
    {
    }
 
 
    virtual int GetVerticalPlacement(int a_BlockX, int a_BlockZ) override
    {
        cNoise Noise(m_Seed);
        return m_Min + (Noise.IntNoise2DInt(a_BlockX, a_BlockZ) / 7) % m_Range;
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Params: "<MinHeight>|<MaxHeight>", all compulsory
        auto params = StringSplitAndTrim(a_Params, "|");
        if (params.size() != 2)
        {
            CONDWARNING(a_LogWarnings, "Cannot parse the range parameters from string \"%s\"!", a_Params.c_str());
            return false;
        }
        int Max = 0;
        if (!StringToInteger(params[0], m_Min) || !StringToInteger(params[1], Max))
        {
            CONDWARNING(a_LogWarnings, "Cannot parse the minimum or maximum height from string \"%s\"!", a_Params.c_str());
            return false;
        }
        if (m_Min > Max)
        {
            std::swap(m_Min, Max);
        }
        m_Range = Max - m_Min + 1;
        return true;
    }
 
 
    virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
    {
        m_Seed = a_Seed + SEED_OFFSET;
    }
 
protected:
    int m_Seed;
 
    int m_Min, m_Range;
};
 
 
 
 
 
 
class cVerticalStrategyTerrainTop:
    public cPiece::cVerticalStrategy
{
public:
 
    virtual int GetVerticalPlacement(int a_BlockX, int a_BlockZ) override
    {
        ASSERT(m_HeightGen != nullptr);
 
        int ChunkX, ChunkZ;
        cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
        cChunkDef::HeightMap HeightMap;
        m_HeightGen->GenHeightMap({ChunkX, ChunkZ}, HeightMap);
        cNoise noise(m_Seed);
        int rel = m_MinRelHeight + (noise.IntNoise2DInt(a_BlockX, a_BlockZ) / 7) % m_RelHeightRange + 1;
        return cChunkDef::GetHeight(HeightMap, a_BlockX - ChunkX * cChunkDef::Width, a_BlockZ - ChunkZ * cChunkDef::Width) + rel;
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Params: "<MinRelativeHeight>|<MaxRelativeHeight>", all optional
        m_MinRelHeight = 0;
        m_RelHeightRange = 1;
        return VerticalStrategy::ParseRange(a_Params, m_MinRelHeight, m_RelHeightRange, a_LogWarnings);
    }
 
 
    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;
    }
 
protected:
    int m_Seed;
 
    cTerrainHeightGen * m_HeightGen;
 
    int m_MinRelHeight;
 
    int m_RelHeightRange;
};
 
 
 
 
 
 
class cVerticalStrategyTerrainOrOceanTop:
    public cPiece::cVerticalStrategy
{
public:
 
    virtual int GetVerticalPlacement(int a_BlockX, int a_BlockZ) override
    {
        ASSERT(m_HeightGen != nullptr);
 
        int ChunkX, ChunkZ;
        cChunkDef::BlockToChunk(a_BlockX, a_BlockZ, ChunkX, ChunkZ);
        cChunkDef::HeightMap HeightMap;
        m_HeightGen->GenHeightMap({ChunkX, ChunkZ}, HeightMap);
        int terrainHeight = static_cast<int>(cChunkDef::GetHeight(HeightMap, a_BlockX - ChunkX * cChunkDef::Width, a_BlockZ - ChunkZ * cChunkDef::Width));
        terrainHeight = std::max(1 + terrainHeight, m_SeaLevel);
        cNoise noise(m_Seed);
        int rel = m_MinRelHeight + (noise.IntNoise2DInt(a_BlockX, a_BlockZ) / 7) % m_RelHeightRange + 1;
        return terrainHeight + rel;
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Params: "<MinRelativeHeight>|<MaxRelativeHeight>", all optional
        m_MinRelHeight = 0;
        m_RelHeightRange = 1;
        return VerticalStrategy::ParseRange(a_Params, m_MinRelHeight, m_RelHeightRange, a_LogWarnings);
    }
 
 
    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_SeaLevel = a_SeaLevel;
    }
 
protected:
    int m_Seed;
 
    cTerrainHeightGen * m_HeightGen;
 
    int m_SeaLevel;
 
    int m_MinRelHeight;
 
    int m_RelHeightRange;
};
 
 
 
 
 
// CreateVerticalStrategyFromString:
 
cPiece::cVerticalStrategyPtr CreateVerticalStrategyFromString(const AString & a_StrategyDesc, bool a_LogWarnings)
{
    // Break apart the strategy class, the first parameter before the first pipe char:
    auto idxPipe = a_StrategyDesc.find('|');
    if (idxPipe == AString::npos)
    {
        idxPipe = a_StrategyDesc.length();
    }
    AString StrategyClass = a_StrategyDesc.substr(0, idxPipe);
 
    // Create a strategy class based on the class string:
    cPiece::cVerticalStrategyPtr Strategy;
    if (NoCaseCompare(StrategyClass, "Fixed") == 0)
    {
        Strategy = std::make_shared<cVerticalStrategyFixed>();
    }
    else if (NoCaseCompare(StrategyClass, "Range") == 0)
    {
        Strategy = std::make_shared<cVerticalStrategyRange>();
    }
    else if (NoCaseCompare(StrategyClass, "TerrainTop") == 0)
    {
        Strategy = std::make_shared<cVerticalStrategyTerrainTop>();
    }
    else if (NoCaseCompare(StrategyClass, "TerrainOrOceanTop") == 0)
    {
        Strategy = std::make_shared<cVerticalStrategyTerrainOrOceanTop>();
    }
    else
    {
        return nullptr;
    }
 
    // Initialize the strategy's parameters:
    AString Params;
    if (idxPipe < a_StrategyDesc.length())
    {
        Params = a_StrategyDesc.substr(idxPipe + 1);
    }
    if (!Strategy->InitializeFromString(Params, a_LogWarnings))
    {
        return nullptr;
    }
 
    return Strategy;
}