VerticalLimit.cpp

Go to the documentation of this file.

 
// VerticalLimit.cpp
 
#include "Globals.h"
#include "VerticalLimit.h"
 
 
// Globals:
 
namespace VerticalLimit
{
    static bool ParseRange(const AString & a_Params, int & a_Min, int & a_Max, 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
            a_Max = a_Min;
            return true;
        }
        if (!StringToInteger(params[1], a_Max))
        {
            CONDWARNING(a_LogWarnings, "Cannot parse maximum height from string \"%s\"!", params[1].c_str());
            return false;
        }
        if (a_Max < a_Min)
        {
            std::swap(a_Max, a_Min);
        }
        return true;
    }
}
 
 
 
 
 
 
class cVerticalLimitNone:
    public cPiece::cVerticalLimit
{
public:
        virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
        {
            // Any height is okay
            return true;
        }
 
 
        virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
        {
            // No parameters to read, no checks being done
            return true;
        }
};
 
 
 
 
 
 
class cVerticalLimitAbove:
    public cPiece::cVerticalLimit
{
public:
    virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
    {
        return (a_Height >= m_MinHeight);
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Parameters: "<MinHeight>", compulsory
        if (!StringToInteger(a_Params, m_MinHeight))
        {
            CONDWARNING(a_LogWarnings, "Cannot parse the minimum height from string \"%s\"!", a_Params.c_str());
            return false;
        }
        return true;
    }
 
protected:
    int m_MinHeight;
};
 
 
 
 
 
 
class cVerticalLimitAboveTerrain:
    public cPiece::cVerticalLimit
{
public:
    virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
    {
        ASSERT(m_TerrainHeightGen != nullptr);
        auto terrainHeight = m_TerrainHeightGen->GetHeightAt(a_BlockX, a_BlockZ);
        int compareHeight = a_Height - terrainHeight;
        return (
            (compareHeight >= m_MinBlocksAbove) &&  // Above the minimum
            (compareHeight <= m_MaxBlocksAbove)     // and below the maximum
        );
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Parameters: "<MinBlocksAbove>|<MaxBlocksAbove>", both optional
        m_MinBlocksAbove = 0;
        m_MaxBlocksAbove = 0;
        return VerticalLimit::ParseRange(a_Params, m_MinBlocksAbove, m_MaxBlocksAbove, a_LogWarnings);
    }
 
 
    virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
    {
        m_TerrainHeightGen = &a_TerrainHeightGen;
    }
 
protected:
    cTerrainHeightGen * m_TerrainHeightGen;
 
    int m_MinBlocksAbove;
 
    int m_MaxBlocksAbove;
};
 
 
 
 
 
 
class cVerticalLimitAboveTerrainAndOcean:
    public cPiece::cVerticalLimit
{
public:
    virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
    {
        ASSERT(m_TerrainHeightGen != nullptr);
        int terrainHeight = m_TerrainHeightGen->GetHeightAt(a_BlockX, a_BlockZ);
        int compareHeight = a_Height - std::max(terrainHeight, m_SeaLevel);
        return (
            (compareHeight >= m_MinBlocksAbove) &&  // Above the minimum
            (compareHeight <= m_MaxBlocksAbove)     // and below the maximum
        );
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Parameters: "<MinBlocksAbove>|<MaxBlocksAbove>", both optional
        m_MinBlocksAbove = 0;
        m_MaxBlocksAbove = 0;
        return VerticalLimit::ParseRange(a_Params, m_MinBlocksAbove, m_MaxBlocksAbove, a_LogWarnings);
    }
 
 
    virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
    {
        m_TerrainHeightGen = &a_TerrainHeightGen;
        m_SeaLevel = a_SeaLevel;
    }
 
protected:
    cTerrainHeightGen * m_TerrainHeightGen;
 
    int m_SeaLevel;
 
    int m_MinBlocksAbove;
 
    int m_MaxBlocksAbove;
};
 
 
 
 
 
 
class cVerticalLimitBelow:
    public cPiece::cVerticalLimit
{
public:
    virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
    {
        return (a_Height <= m_MaxHeight);
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Parameters: "<MaxHeight>"
        if (!StringToInteger(a_Params, m_MaxHeight))
        {
            CONDWARNING(a_LogWarnings, "Cannot parse the maximum height from string \"%s\"!", a_Params.c_str());
            return false;
        }
        return true;
    }
 
protected:
    int m_MaxHeight;
};
 
 
 
 
 
 
class cVerticalLimitBelowTerrain:
    public cPiece::cVerticalLimit
{
public:
    virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
    {
        auto terrainHeight = m_TerrainHeightGen->GetHeightAt(a_BlockX, a_BlockZ);
        auto compareHeight = terrainHeight - a_Height;
        return (
            (compareHeight >= m_MinBlocksBelow) &&
            (compareHeight <= m_MaxBlocksBelow)
        );
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Parameters: "<MinBlocksBelow>|<MaxBlocksBelow>", both optional
        m_MinBlocksBelow = 0;
        m_MaxBlocksBelow = 0;
        return VerticalLimit::ParseRange(a_Params, m_MinBlocksBelow, m_MaxBlocksBelow, a_LogWarnings);
    }
 
 
    virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
    {
        m_TerrainHeightGen = &a_TerrainHeightGen;
    }
 
protected:
    cTerrainHeightGen * m_TerrainHeightGen;
 
    int m_MinBlocksBelow;
 
    int m_MaxBlocksBelow;
};
 
 
 
 
 
 
class cVerticalLimitBelowTerrainOrOcean:
    public cPiece::cVerticalLimit
{
public:
    virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) override
    {
        int terrainHeight = m_TerrainHeightGen->GetHeightAt(a_BlockX, a_BlockZ);
        auto compareHeight = std::max(terrainHeight, m_SeaLevel) - a_Height;
        return (
            (compareHeight >= m_MinBlocksBelow) &&
            (compareHeight <= m_MaxBlocksBelow)
        );
    }
 
 
    virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
    {
        // Parameters: "<MinBlocksBelow>|<MaxBlocksBelow>", both optional
        m_MinBlocksBelow = 0;
        m_MaxBlocksBelow = 0;
        return VerticalLimit::ParseRange(a_Params, m_MinBlocksBelow, m_MaxBlocksBelow, a_LogWarnings);
    }
 
 
    virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) override
    {
        m_TerrainHeightGen = &a_TerrainHeightGen;
        m_SeaLevel = a_SeaLevel;
    }
 
protected:
    cTerrainHeightGen * m_TerrainHeightGen;
 
    int m_SeaLevel;
 
    int m_MinBlocksBelow;
 
    int m_MaxBlocksBelow;
};
 
 
 
 
 
// CreateVerticalLimitFromString:
 
cPiece::cVerticalLimitPtr CreateVerticalLimitFromString(const AString & a_LimitDesc, bool a_LogWarnings)
{
    // Break apart the limit class, the first parameter before the first pipe char:
    auto idxPipe = a_LimitDesc.find('|');
    if (idxPipe == AString::npos)
    {
        idxPipe = a_LimitDesc.length();
    }
    AString LimitClass = a_LimitDesc.substr(0, idxPipe);
 
    // Create a strategy class based on the class string:
    cPiece::cVerticalLimitPtr Limit;
    if ((LimitClass == "") || (NoCaseCompare(LimitClass, "None") == 0))
    {
        Limit = std::make_shared<cVerticalLimitNone>();
    }
    else if (NoCaseCompare(LimitClass, "Above") == 0)
    {
        Limit = std::make_shared<cVerticalLimitAbove>();
    }
    else if (NoCaseCompare(LimitClass, "AboveTerrain") == 0)
    {
        Limit = std::make_shared<cVerticalLimitAboveTerrain>();
    }
    else if (NoCaseCompare(LimitClass, "AboveTerrainAndOcean") == 0)
    {
        Limit = std::make_shared<cVerticalLimitAboveTerrainAndOcean>();
    }
    else if (NoCaseCompare(LimitClass, "Below") == 0)
    {
        Limit = std::make_shared<cVerticalLimitBelow>();
    }
    else if (NoCaseCompare(LimitClass, "BelowTerrain") == 0)
    {
        Limit = std::make_shared<cVerticalLimitBelowTerrain>();
    }
    else if (NoCaseCompare(LimitClass, "BelowTerrainOrOcean") == 0)
    {
        Limit = std::make_shared<cVerticalLimitBelowTerrainOrOcean>();
    }
    else
    {
        return nullptr;
    }
 
    // Initialize the limit's parameters:
    AString Params;
    if (idxPipe < a_LimitDesc.length())
    {
        Params = a_LimitDesc.substr(idxPipe + 1);
    }
    if (!Limit->InitializeFromString(Params, a_LogWarnings))
    {
        return nullptr;
    }
 
    return Limit;
}