path: root/src/Generating/VerticalLimit.cpp

// VerticalLimit.cpp

#include "Globals.h"
#include "VerticalLimit.h"


////////////////////////////////////////////////////////////////////////////////
// Globals:

/** Parses a string containing a range in which both values are optional ("<MinHeight>|<MaxHeight>") into Min, Max.
Returns true if successful, false on failure.
If a_LogWarnings is true, outputs failure reasons to console.
The range is returned in a_Min and a_Max.
If no value is in the string, both values are left unchanged.
If only the minimum is in the string, it is assigned to both a_Min and a_Max. */
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;
	}
}





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts any height. The default for all pieces. */
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;
		}
};





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts heights above the specified minimum fixed height. */
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:
	/** The minimum accepted height. */
	int m_MinHeight;
};





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts heights that are a specified number of blocks above terrain. */
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:
	/** The underlying height generator. */
	cTerrainHeightGen * m_TerrainHeightGen;

	/** How many blocks above the terrain level do we accept on minimum. */
	int m_MinBlocksAbove;

	/** How many blocks above the terrain level do we accept on maximum. */
	int m_MaxBlocksAbove;
};





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts heights that are a specified number of blocks above terrain and sealevel, whichever is higher. */
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:
	/** The underlying height generator. */
	cTerrainHeightGen * m_TerrainHeightGen;

	/** The sealevel for the current world. */
	int m_SeaLevel;

	/** How many blocks above the terrain level / ocean do we accept on minimum. */
	int m_MinBlocksAbove;

	/** How many blocks above the terrain level / ocean do we accept on maximum. */
	int m_MaxBlocksAbove;
};





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts heights below the specified fixed height.
NOTE that the query height is the BOTTOM of the piece. */
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:
	/** The maximum accepted height. */
	int m_MaxHeight;
};





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts heights that are within a specified range below terrain.
NOTE that the query height is the BOTTOM of the piece. */
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:
	/** The underlying height generator. */
	cTerrainHeightGen * m_TerrainHeightGen;

	/** How many blocks below the terrain level do we accept on minimum. */
	int m_MinBlocksBelow;

	/** How many blocks below the terrain level do we accept on maximum. */
	int m_MaxBlocksBelow;
};





////////////////////////////////////////////////////////////////////////////////
/** Limit that accepts heights that are a specified number of blocks below terrain or sealevel, whichever is higher. */
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:
	/** The underlying height generator. */
	cTerrainHeightGen * m_TerrainHeightGen;

	/** The sealevel for the current world. */
	int m_SeaLevel;

	/** How many blocks below the terrain level do we accept on minimum. */
	int m_MinBlocksBelow;

	/** How many blocks below the terrain level do we accept on maximum. */
	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;
}