path: root/src/Generating/ProtIntGen.h

// ProtIntGen.h

// Declares the prototyping integer generators - cProtIntGen class and its descendants

/*
These classes generate 2D arrays of integers that have various interpretations. The main purpose of these
classes is to provide fast prototyping for cIntGen classes - unlike cIntGen classes, these are not
template-based and so they take care of the underlying sizes automatically. This makes them easier to chain
and re-chain, since the size parameters don't need to be adjusted after each such case. Their performance is,
however, slightly worse, which is why we use cIntGen classes in the final generator.

Because there is no SizeX / SizeZ template param, the generators would have to either alloc memory for each
underlying generator's values, or use a maximum-size buffer. We chose the latter, to avoid memory allocation
overhead; this however means that there's (an arbitrary) limit to the size of the generated data.
*/





#pragma once

// We need the biome group constants defined there:
#include "IntGen.h"





/** Interface that all the generator classes provide. */
class cProtIntGen
{
protected:
	/** Maximum size of the generated area.
	Adjust the constant if you need larger areas, these are just so that we can use fixed-size buffers. */
	static const int m_BufferSize = 900;

public:

	/** Type of the generic interface used for storing links to the underlying generators. */
	typedef std::shared_ptr<cProtIntGen> Underlying;


	/** Force a virtual destructor in all descendants.
	Descendants contain virtual functions and are referred to via pointer-to-base, so they need a virtual destructor. */
	virtual ~cProtIntGen() {}

	/** Generates the array of specified size into a_Values, based on given min coords. */
	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) = 0;
};





/** Provides additional cNoise member and its helper functions. */
class cProtIntGenWithNoise :
	public cProtIntGen
{
	typedef cProtIntGen super;

public:
	cProtIntGenWithNoise(int a_Seed) :
		m_Noise(a_Seed)
	{
	}

protected:
	cNoise m_Noise;

	/** Chooses one of a_Val1 or a_Val2, based on m_Noise and the coordinates for querying the noise. */
	int ChooseRandomOne(int a_RndX, int a_RndZ, int a_Val1, int a_Val2)
	{
		int rnd = m_Noise.IntNoise2DInt(a_RndX, a_RndZ) / 7;
		return ((rnd & 1) == 0) ? a_Val1 : a_Val2;
	}

	/** Chooses one of a_ValN, based on m_Noise and the coordinates for querying the noise. */
	int ChooseRandomOne(int a_RndX, int a_RndZ, int a_Val1, int a_Val2, int a_Val3, int a_Val4)
	{
		int rnd = m_Noise.IntNoise2DInt(a_RndX, a_RndZ) / 7;
		switch (rnd % 4)
		{
			case 0:  return a_Val1;
			case 1:  return a_Val2;
			case 2:  return a_Val3;
			default: return a_Val4;
		}
	}
};






/** Generates a 2D array of random integers in the specified range [0 .. Range). */
class cProtIntGenChoice :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenChoice(int a_Seed, int a_Range) :
		super(a_Seed),
		m_Range(a_Range)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		for (int z = 0; z < a_SizeZ; z++)
		{
			int BaseZ = a_MinZ + z;
			for (int x = 0; x < a_SizeX; x++)
			{
				a_Values[x + a_SizeX * z] = (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7) % m_Range;
			}
		}  // for z
	}

protected:
	int m_Range;
};






/** Decides between the ocean and landmass biomes.
Has a threshold (in percent) of how much land, the larger the threshold, the more land.
Generates 0 for ocean, biome group ID for landmass. */
class cProtIntGenLandOcean :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenLandOcean(int a_Seed, int a_Threshold) :
		super(a_Seed),
		m_Threshold(a_Threshold)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		for (int z = 0; z < a_SizeZ; z++)
		{
			int BaseZ = a_MinZ + z;
			for (int x = 0; x < a_SizeX; x++)
			{
				int rnd = (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7);
				a_Values[x + a_SizeX * z] = ((rnd % 100) < m_Threshold) ? ((rnd / 128) % bgLandOceanMax + 1) : 0;
			}
		}

		// If the centerpoint of the world is within the area, set it to bgTemperate, always:
		if ((a_MinX <= 0) && (a_MinZ <= 0) && (a_MinX + a_SizeX > 0) && (a_MinZ + a_SizeZ > 0))
		{
			a_Values[-a_MinX - a_MinZ * a_SizeX] = bgTemperate;
		}
	}

protected:
	int m_Threshold;
};





class cProtIntGenZoom :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenZoom(int a_Seed, Underlying a_UnderlyingGen) :
		super(a_Seed),
		m_UnderlyingGen(a_UnderlyingGen)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Get the coords for the lower generator:
		int lowerMinX = a_MinX >> 1;
		int lowerMinZ = a_MinZ >> 1;
		int lowerSizeX = a_SizeX / 2 + 2;
		int lowerSizeZ = a_SizeZ / 2 + 2;
		ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
		ASSERT(lowerSizeX > 0);
		ASSERT(lowerSizeZ > 0);

		// Generate the underlying data with half the resolution:
		int lowerData[m_BufferSize];
		m_UnderlyingGen->GetInts(lowerMinX, lowerMinZ, lowerSizeX, lowerSizeZ, lowerData);
		const int lowStepX = (lowerSizeX - 1) * 2;
		int Cache[m_BufferSize];

		// Discreet-interpolate the values into twice the size:
		for (int z = 0; z < lowerSizeZ - 1; ++z)
		{
			int idx = (z * 2) * lowStepX;
			int PrevZ0 = lowerData[z * lowerSizeX];
			int PrevZ1 = lowerData[(z + 1) * lowerSizeX];

			for (int x = 0; x < lowerSizeX - 1; ++x)
			{
				int ValX1Z0 = lowerData[x + 1 + z * lowerSizeX];
				int ValX1Z1 = lowerData[x + 1 + (z + 1) * lowerSizeX];
				int RndX = (x + lowerMinX) * 2;
				int RndZ = (z + lowerMinZ) * 2;
				Cache[idx] = PrevZ0;
				Cache[idx + lowStepX] = super::ChooseRandomOne(RndX, RndZ, PrevZ0, PrevZ1);
				idx++;
				Cache[idx] = super::ChooseRandomOne(RndX, RndZ, PrevZ0, ValX1Z0);
				Cache[idx + lowStepX] = super::ChooseRandomOne(RndX, RndZ, PrevZ0, ValX1Z0, PrevZ1, ValX1Z1);
				idx++;
				PrevZ0 = ValX1Z0;
				PrevZ1 = ValX1Z1;
			}
		}

		// Copy from Cache into a_Values; take into account the even/odd offsets in a_Min:
		for (int z = 0; z < a_SizeZ; ++z)
		{
			memcpy(a_Values + z * a_SizeX, Cache + (z + (a_MinZ & 1)) * lowStepX + (a_MinX & 1), a_SizeX * sizeof(int));
		}
	}

protected:
	Underlying m_UnderlyingGen;
};





class cProtIntGenSmooth :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenSmooth(int a_Seed, Underlying a_Underlying) :
		super(a_Seed),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Generate the underlying values:
		int lowerSizeX = a_SizeX + 2;
		int lowerSizeZ = a_SizeZ + 2;
		ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
		int lowerData[m_BufferSize];
		m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerData);

		// Smooth - for each square check if the surroundings are the same, if so, expand them diagonally.
		// Also get rid of single-pixel irregularities (A-B-A):
		for (int z = 0; z < a_SizeZ; z++)
		{
			int NoiseZ = a_MinZ + z;
			for (int x = 0; x < a_SizeX; x++)
			{
				int val   = lowerData[x + 1 + (z + 1) * lowerSizeX];
				int Above = lowerData[x + 1 +  z      * lowerSizeX];
				int Below = lowerData[x + 1 + (z + 2) * lowerSizeX];
				int Left  = lowerData[x     + (z + 1) * lowerSizeX];
				int Right = lowerData[x + 2 + (z + 1) * lowerSizeX];

				if ((Left == Right) && (Above == Below))
				{
					if (((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % 2) == 0)
					{
						val = Left;
					}
					else
					{
						val = Above;
					}
				}
				else
				{
					if (Left == Right)
					{
						val = Left;
					}

					if (Above == Below)
					{
						val = Above;
					}
				}

				a_Values[x + z * a_SizeX] = val;
			}
		}
	}

protected:
	Underlying m_Underlying;
};





class cProtIntGenBeaches :
	public cProtIntGen
{
	typedef cProtIntGen super;

public:
	cProtIntGenBeaches(Underlying a_Underlying) :
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Map for biome -> its beach:
		static const int ToBeach[] =
		{
			/* biOcean            */ biOcean,
			/* biPlains           */ biBeach,
			/* biDesert           */ biBeach,
			/* biExtremeHills     */ biStoneBeach,
			/* biForest           */ biBeach,
			/* biTaiga            */ biColdBeach,
			/* biSwampland        */ biSwampland,
			/* biRiver            */ biRiver,
			/* biNether           */ biNether,
			/* biEnd              */ biEnd,
			/* biFrozenOcean      */ biColdBeach,
			/* biFrozenRiver      */ biColdBeach,
			/* biIcePlains        */ biColdBeach,
			/* biIceMountains     */ biColdBeach,
			/* biMushroomIsland   */ biMushroomShore,
			/* biMushroomShore    */ biMushroomShore,
			/* biBeach            */ biBeach,
			/* biDesertHills      */ biBeach,
			/* biForestHills      */ biBeach,
			/* biTaigaHills       */ biColdBeach,
			/* biExtremeHillsEdge */ biStoneBeach,
			/* biJungle           */ biBeach,
			/* biJungleHills      */ biBeach,
			/* biJungleEdge       */ biBeach,
			/* biDeepOcean        */ biOcean,
			/* biStoneBeach       */ biStoneBeach,
			/* biColdBeach        */ biColdBeach,
			/* biBirchForest      */ biBeach,
			/* biBirchForestHills */ biBeach,
			/* biRoofedForest     */ biBeach,
			/* biColdTaiga        */ biColdBeach,
			/* biColdTaigaHills   */ biColdBeach,
			/* biMegaTaiga        */ biStoneBeach,
			/* biMegaTaigaHills   */ biStoneBeach,
			/* biExtremeHillsPlus */ biStoneBeach,
			/* biSavanna          */ biBeach,
			/* biSavannaPlateau   */ biBeach,
			/* biMesa             */ biMesa,
			/* biMesaPlateauF     */ biMesa,
			/* biMesaPlateau      */ biMesa,
		};

		// Generate the underlying values:
		int lowerSizeX = a_SizeX + 2;
		int lowerSizeZ = a_SizeZ + 2;
		ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
		int lowerValues[m_BufferSize];
		m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);

		// Add beaches between ocean and biomes:
		for (int z = 0; z < a_SizeZ; z++)
		{
			for (int x = 0; x < a_SizeX; x++)
			{
				int val   = lowerValues[x + 1 + (z + 1) * lowerSizeX];
				int Above = lowerValues[x + 1 + z       * lowerSizeX];
				int Below = lowerValues[x + 1 + (z + 2) * lowerSizeX];
				int Left  = lowerValues[x     + (z + 1) * lowerSizeX];
				int Right = lowerValues[x + 2 + (z + 1) * lowerSizeX];
				if (!IsBiomeOcean(val))
				{
					if (IsBiomeOcean(Above) || IsBiomeOcean(Below) || IsBiomeOcean(Left) || IsBiomeOcean(Right))
					{
						val = ToBeach[(val % 128) % ARRAYCOUNT(ToBeach)];
					}
				}
				a_Values[x + z * a_SizeX] = val;
			}
		}
	}

protected:
	Underlying m_Underlying;
};





/** Generates the underlying numbers and then randomly changes some zeroes into nonzeroes. */
class cProtIntGenAddIslands :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	typedef std::shared_ptr<cProtIntGen> Underlying;


	cProtIntGenAddIslands(int a_Seed, int a_Threshold, Underlying a_Underlying) :
		super(a_Seed),
		m_Threshold(a_Threshold),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
		for (int z = 0; z < a_SizeZ; z++)
		{
			for (int x = 0; x < a_SizeX; x++)
			{
				if (a_Values[x + z * a_SizeX] == bgOcean)
				{
					int rnd = super::m_Noise.IntNoise2DInt(a_MinX + x, a_MinZ + z) / 7;
					if (rnd % 100 < m_Threshold)
					{
						a_Values[x + z * a_SizeX] = (rnd / 100) % bgLandOceanMax;
					}
				}
			}
		}
	}

protected:
	int m_Threshold;

	Underlying m_Underlying;
};





/** A filter that adds an edge biome group between two biome groups that need an edge between them. */
class cProtIntGenBiomeGroupEdges :
	public cProtIntGen
{
	typedef cProtIntGen super;

public:
	cProtIntGenBiomeGroupEdges(Underlying a_Underlying) :
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values)
	{
		// Generate the underlying biome groups:
		int lowerSizeX = a_SizeX + 2;
		int lowerSizeZ = a_SizeZ + 2;
		ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
		int lowerValues[m_BufferSize];
		m_Underlying->GetInts(a_MinX, a_MinZ, lowerSizeX, lowerSizeZ, lowerValues);

		// Change the biomes on incompatible edges into an edge biome:
		for (int z = 0; z < a_SizeZ; z++)
		{
			for (int x = 0; x < a_SizeX; x++)
			{
				int val   = lowerValues[x + 1 + (z + 1) * lowerSizeX];
				int Above = lowerValues[x + 1 + z       * lowerSizeX];
				int Below = lowerValues[x + 1 + (z + 2) * lowerSizeX];
				int Left  = lowerValues[x     + (z + 1) * lowerSizeX];
				int Right = lowerValues[x + 2 + (z + 1) * lowerSizeX];
				switch (val)
				{
					// Desert should neighbor only oceans, desert and temperates; change to temperate when another:
					case bgDesert:
					{
						if (
							!isDesertCompatible(Above) ||
							!isDesertCompatible(Below) ||
							!isDesertCompatible(Left) ||
							!isDesertCompatible(Right)
						)
						{
							val = bgTemperate;
						}
						break;
					}  // case bgDesert

					// Ice should not neighbor deserts; change to temperate:
					case bgIce:
					{
						if (
							(Above == bgDesert) ||
							(Below == bgDesert) ||
							(Left  == bgDesert) ||
							(Right == bgDesert)
						)
						{
							val = bgTemperate;
						}
						break;
					}  // case bgIce

					// Jungle should not neighbor Desert or Ice; change to temperate:
					case bgJungle:
					{
						if (
							!isJungleCompatible(Above) ||
							!isJungleCompatible(Below) ||
							!isJungleCompatible(Left) ||
							!isJungleCompatible(Right)
						)
						{
							val = bgTemperate;
						}
					}  // case bgJungle

					// Mesa should neighbor only oceans and deserts; change to desert when another:
					case bgMesa:
					{
						if (
							!isMesaCompatible(Above) ||
							!isMesaCompatible(Below) ||
							!isMesaCompatible(Left) ||
							!isMesaCompatible(Right)
						)
						{
							val = bgDesert;
						}
						break;
					}  // case bgDesert
				}
				a_Values[x + z * a_SizeX] = val;
			}  // for x
		}  // for z
	}

protected:
	Underlying m_Underlying;


	inline bool isDesertCompatible(int a_BiomeGroup)
	{
		switch (a_BiomeGroup)
		{
			case bgOcean:
			case bgDesert:
			case bgTemperate:
			case bgMesa:
			{
				return true;
			}
			default:
			{
				return false;
			}
		}
	}

	inline bool isJungleCompatible(int a_BiomeGroup)
	{
		return ((a_BiomeGroup != bgDesert) && (a_BiomeGroup != bgMesa) && (a_BiomeGroup != bgIce));
	}

	inline bool isMesaCompatible(int a_BiomeGroup)
	{
		return ((a_BiomeGroup == bgOcean) || (a_BiomeGroup == bgDesert));
	}
};





/** Turns biome group indices into real biomes.
For each pixel, takes its biome group and chooses a random biome from that group; replaces the value with
that biome. */
class cProtIntGenBiomes :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenBiomes(int a_Seed, Underlying a_Underlying) :
		super(a_Seed),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Define the per-biome-group biomes:
		static const int oceanBiomes[] =
		{
			biOcean, // biDeepOcean,
		};

		static const int desertBiomes[] =
		{
			biDesert, biDesert, biDesert, biDesert, biDesert, biDesert, biSavanna, biSavanna, biPlains,
		};

		static const int temperateBiomes[] =
		{
			biForest, biForest, biRoofedForest, biExtremeHills, biPlains, biBirchForest, biSwampland,
		};

		static const int mountainBiomes[] =
		{
			biExtremeHills, biForest, biTaiga, biPlains,
		};

		static const int jungleBiomes[] =
		{
			biJungle, biJungle, biJungle, biForest,
		};

		static const int iceBiomes[] =
		{
			biIcePlains, biIcePlains, biIcePlains, biIcePlains, biColdTaiga,
		};

		static const int mesaBiomes[] =
		{
			biMesa, biMesaPlateau,
		};

		static const cBiomesInGroups BiomesInGroups[] =
		{
			/* bgOcean */     { static_cast<int>(ARRAYCOUNT(oceanBiomes)),     oceanBiomes},
			/* bgDesert */    { static_cast<int>(ARRAYCOUNT(desertBiomes)),    desertBiomes},
			/* bgTemperate */ { static_cast<int>(ARRAYCOUNT(temperateBiomes)), temperateBiomes},
			/* bgMountains */ { static_cast<int>(ARRAYCOUNT(mountainBiomes)),  mountainBiomes},
			/* bgJungle */    { static_cast<int>(ARRAYCOUNT(jungleBiomes)),    jungleBiomes},
			/* bgIce */       { static_cast<int>(ARRAYCOUNT(iceBiomes)),       iceBiomes},
			/* bgMesa */      { static_cast<int>(ARRAYCOUNT(mesaBiomes)),      mesaBiomes},
		};

		// Generate the underlying values, representing biome groups:
		m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);

		// Overwrite each biome group with a random biome from that group:
		for (int z = 0; z < a_SizeZ; z++)
		{
			int IdxZ = z * a_SizeX;
			for (int x = 0; x < a_SizeX; x++)
			{
				int val = a_Values[x + IdxZ];
				const cBiomesInGroups & Biomes = BiomesInGroups[val % ARRAYCOUNT(BiomesInGroups)];
				int rnd = (super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7);
				a_Values[x + IdxZ] = Biomes.Biomes[rnd % Biomes.Count];
			}
		}
	}

protected:

	struct cBiomesInGroups
	{
		const int Count;
		const int * Biomes;
	};


	/** The underlying int generator */
	Underlying m_Underlying;
};





class cProtIntGenReplaceRandomly :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	typedef std::shared_ptr<cProtIntGen> Underlying;


	cProtIntGenReplaceRandomly(int a_From, int a_To, int a_Chance, int a_Seed, Underlying a_Underlying) :
		super(a_Seed),
		m_From(a_From),
		m_To(a_To),
		m_Chance(a_Chance),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Generate the underlying values:
		m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);

		// Replace some of the values:
		for (int z = 0; z < a_SizeZ; z++)
		{
			int idxZ = z * a_SizeX;
			for (int x = 0; x < a_SizeX; x++)
			{
				int idx = x + idxZ;
				if (a_Values[idx] == m_From)
				{
					int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
					if (rnd % 100 < m_Chance)
					{
						a_Values[idx] = m_To;
					}
				}
			}
		}  // for z
	}


protected:
	int m_From;
	int m_To;
	int m_Chance;
	Underlying m_Underlying;
};





/** Mixer that joins together finalized biomes and rivers.
It first checks for oceans; if there's no ocean, it checks for a river. */
class cProtIntGenMixRivers:
	public cProtIntGen
{
	typedef cProtIntGen super;

public:
	cProtIntGenMixRivers(Underlying a_Biomes, Underlying a_Rivers):
		m_Biomes(a_Biomes),
		m_Rivers(a_Rivers)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Generate the underlying data:
		ASSERT(a_SizeX * a_SizeZ <= m_BufferSize);
		m_Biomes->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
		int riverData[m_BufferSize];
		m_Rivers->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, riverData);

		// Mix the values:
		for (int z = 0; z < a_SizeZ; z++)
		{
			int idxZ = z * a_SizeX;
			for (int x = 0; x < a_SizeX; x++)
			{
				int idx = x + idxZ;
				if (IsBiomeOcean(a_Values[idx]))
				{
					// Oceans are kept without any changes
					continue;
				}
				if (riverData[idx] != biRiver)
				{
					// There's no river, keep the current value
					continue;
				}

				// There's a river, change the output to a river or a frozen river, based on the original biome:
				if (IsBiomeVeryCold((EMCSBiome)a_Values[idx]))
				{
					a_Values[idx] = biFrozenRiver;
				}
				else
				{
					a_Values[idx] = biRiver;
				}
			}  // for x
		}  // for z
	}

protected:
	Underlying m_Biomes;
	Underlying m_Rivers;
};





/** Generates a river based on the underlying data.
This is basically an edge detector over the underlying data. The rivers are the edges where the underlying
data changes from one pixel to its neighbor. */
class cProtIntGenRiver:
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenRiver(int a_Seed, Underlying a_Underlying):
		super(a_Seed),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Generate the underlying data:
		int lowerSizeX = a_SizeX + 2;
		int lowerSizeZ = a_SizeZ + 2;
		ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
		int lowerValues[m_BufferSize];
		m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);

		// Detect the edges:
		for (int z = 0; z < a_SizeZ; z++)
		{
			for (int x = 0; x < a_SizeX; x++)
			{
				int Above = lowerValues[x + 1 + z       * lowerSizeX];
				int Below = lowerValues[x + 1 + (z + 2) * lowerSizeX];
				int Left  = lowerValues[x +     (z + 1) * lowerSizeX];
				int Right = lowerValues[x + 2 + (z + 1) * lowerSizeX];
				int val   = lowerValues[x + 1 + (z + 1) * lowerSizeX];

				if ((val == Above) && (val == Below) && (val == Left) && (val == Right))
				{
					val = 0;
				}
				else
				{
					val = biRiver;
				}
				a_Values[x + z * a_SizeX] = val;
			}  // for x
		}  // for z
	}

protected:
	Underlying m_Underlying;
};





/** Turns some of the oceans into the specified biome. Used for mushroom and deep ocean.
The biome is only placed if at least 3 of its neighbors are ocean and only with the specified chance. */
class cProtIntGenAddToOcean:
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenAddToOcean(int a_Seed, int a_Chance, int a_ToValue, Underlying a_Underlying):
		super(a_Seed),
		m_Chance(a_Chance),
		m_ToValue(a_ToValue),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Generate the underlying data:
		int lowerSizeX = a_SizeX + 2;
		int lowerSizeZ = a_SizeZ + 2;
		ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
		int lowerValues[m_BufferSize];
		m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);

		// Add the mushroom islands:
		for (int z = 0; z < a_SizeZ; z++)
		{
			for (int x = 0; x < a_SizeX; x++)
			{
				int val = lowerValues[x + 1 + (z + 1) * lowerSizeX];
				if (!IsBiomeOcean(val))
				{
					a_Values[x + z * a_SizeX] = val;
					continue;
				}

				// Count the ocean neighbors:
				int Above = lowerValues[x + 1 + z       * lowerSizeX];
				int Below = lowerValues[x + 1 + (z + 2) * lowerSizeX];
				int Left  = lowerValues[x +     (z + 1) * lowerSizeX];
				int Right = lowerValues[x + 2 + (z + 1) * lowerSizeX];
				int NumOceanNeighbors = 0;
				if (IsBiomeOcean(Above))
				{
					NumOceanNeighbors += 1;
				}
				if (IsBiomeOcean(Below))
				{
					NumOceanNeighbors += 1;
				}
				if (IsBiomeOcean(Left))
				{
					NumOceanNeighbors += 1;
				}
				if (IsBiomeOcean(Right))
				{
					NumOceanNeighbors += 1;
				}

				// If at least 3 ocean neighbors and the chance is right, change:
				if (
					(NumOceanNeighbors >= 3) &&
					((super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7) % 1000 < m_Chance)
				)
				{
					a_Values[x + z * a_SizeX] = m_ToValue;
				}
				else
				{
					a_Values[x + z * a_SizeX] = val;
				}
			}  // for x
		}  // for z
	}

protected:
	/** Chance, in permille, of changing the biome. */
	int m_Chance;

	/** The value to change the ocean into. */
	int m_ToValue;

	Underlying m_Underlying;
};





/** Changes random pixels of the underlying data to the specified value. */
class cProtIntGenSetRandomly :
	public cProtIntGenWithNoise
{
	typedef cProtIntGenWithNoise super;

public:
	cProtIntGenSetRandomly(int a_Seed, int a_Chance, int a_ToValue, Underlying a_Underlying) :
		super(a_Seed),
		m_Chance(a_Chance),
		m_ToValue(a_ToValue),
		m_Underlying(a_Underlying)
	{
	}


	virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
	{
		// Generate the underlying data:
		m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);

		// Change random pixels to bgOcean:
		for (int z = 0; z < a_SizeZ; z++)
		{
			for (int x = 0; x < a_SizeX; x++)
			{
				int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
				if (rnd % 1000 < m_Chance)
				{
					a_Values[x + z * a_SizeX] = m_ToValue;
				}
			}
		}
	}

protected:
	/** Chance, in permille, of changing each pixel. */
	int m_Chance;

	/** The value to which to set the pixel. */
	int m_ToValue;

	Underlying m_Underlying;
};