2012-06-14 09:06:06 -04:00
|
|
|
|
|
|
|
// FinishGen.h
|
|
|
|
|
|
|
|
/* Interfaces to the various finishing generators:
|
|
|
|
- cFinishGenSnow
|
|
|
|
- cFinishGenIce
|
|
|
|
- cFinishGenSprinkleFoliage
|
2012-07-27 17:00:11 -04:00
|
|
|
- cFinishGenLilypads
|
|
|
|
- cFinishGenBottomLava
|
2012-11-11 10:35:49 -05:00
|
|
|
- cFinishGenPreSimulator
|
|
|
|
- cFinishGenDeadBushes
|
2012-06-14 09:06:06 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-01-25 05:12:29 -05:00
|
|
|
#include "ComposableGenerator.h"
|
2014-11-18 06:07:08 -05:00
|
|
|
#include "../Noise/Noise.h"
|
2013-03-14 05:52:57 -04:00
|
|
|
#include "../ProbabDistrib.h"
|
2014-12-02 04:37:17 -05:00
|
|
|
#include "../Mobs/Monster.h"
|
2012-06-14 09:06:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class cFinishGenSnow :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2012-06-14 09:06:06 -04:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class cFinishGenIce :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2012-06-14 09:06:06 -04:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-11-11 10:35:49 -05:00
|
|
|
|
2014-01-18 08:17:26 -05:00
|
|
|
class cFinishGenNetherClumpFoliage :
|
2014-01-10 10:31:45 -05:00
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2014-01-18 11:03:31 -05:00
|
|
|
cFinishGenNetherClumpFoliage(int a_Seed) :
|
2014-01-10 10:31:45 -05:00
|
|
|
m_Noise(a_Seed),
|
2014-01-18 11:03:31 -05:00
|
|
|
m_Seed(a_Seed)
|
2014-01-10 10:31:45 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
cNoise m_Noise;
|
|
|
|
int m_Seed;
|
|
|
|
|
2014-01-18 08:16:07 -05:00
|
|
|
void TryPlaceClump(cChunkDesc & a_ChunkDesc, int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_Block);
|
2014-01-10 10:31:45 -05:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-04-19 13:45:18 -04:00
|
|
|
class cFinishGenGlowStone :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
cFinishGenGlowStone(int a_Seed) :
|
2015-04-19 14:08:51 -04:00
|
|
|
m_Noise(a_Seed),
|
|
|
|
m_Seed(a_Seed)
|
2015-04-19 13:45:18 -04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
cNoise m_Noise;
|
|
|
|
int m_Seed;
|
|
|
|
|
|
|
|
void TryPlaceGlowstone(cChunkDesc & a_ChunkDesc, int a_RelX, int a_RelY, int a_RelZ, int a_Size, int a_NumStrings);
|
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-07-20 13:22:41 -04:00
|
|
|
class cFinishGenTallGrass :
|
2014-07-20 10:23:45 -04:00
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2014-07-20 13:22:41 -04:00
|
|
|
cFinishGenTallGrass(int a_Seed) : m_Noise(a_Seed), m_Seed(a_Seed) {}
|
2014-07-20 10:23:45 -04:00
|
|
|
|
|
|
|
protected:
|
|
|
|
cNoise m_Noise;
|
|
|
|
int m_Seed;
|
|
|
|
|
|
|
|
// cFinishGen override:
|
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
|
|
|
|
2014-07-20 16:43:31 -04:00
|
|
|
int GetBiomeDensity(EMCSBiome a_Biome)
|
2014-07-20 10:23:45 -04:00
|
|
|
{
|
|
|
|
switch (a_Biome)
|
|
|
|
{
|
2014-07-21 04:58:13 -04:00
|
|
|
case biSavanna:
|
|
|
|
case biSavannaM:
|
|
|
|
case biSavannaPlateau:
|
|
|
|
case biSavannaPlateauM:
|
|
|
|
case biPlains:
|
|
|
|
{
|
|
|
|
return 70;
|
|
|
|
}
|
2014-07-23 05:23:35 -04:00
|
|
|
|
|
|
|
case biExtremeHillsEdge:
|
|
|
|
case biExtremeHillsPlus:
|
|
|
|
case biExtremeHills:
|
|
|
|
case biExtremeHillsPlusM:
|
|
|
|
case biExtremeHillsM:
|
|
|
|
case biIceMountains:
|
|
|
|
{
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
2014-07-21 04:58:13 -04:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
return 20;
|
|
|
|
}
|
2014-07-20 10:23:45 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-02-28 16:37:33 -05:00
|
|
|
class cFinishGenVines :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2015-03-01 14:09:44 -05:00
|
|
|
cFinishGenVines(int a_Seed, int a_Level) :
|
2015-02-28 16:40:13 -05:00
|
|
|
m_Noise(a_Seed),
|
|
|
|
m_Level(a_Level)
|
2015-02-28 16:37:33 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsJungleVariant(EMCSBiome a_Biome);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
cNoise m_Noise;
|
2015-02-28 16:40:13 -05:00
|
|
|
int m_Level;
|
2015-02-28 16:37:33 -05:00
|
|
|
|
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-12-01 10:36:48 -05:00
|
|
|
class cFinishGenSoulsandRims :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2014-12-02 04:58:30 -05:00
|
|
|
cFinishGenSoulsandRims(int a_Seed) :
|
2014-12-01 10:36:48 -05:00
|
|
|
m_Noise(a_Seed)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
cNoise m_Noise;
|
|
|
|
|
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
class cFinishGenSprinkleFoliage :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2013-03-17 13:55:03 -04:00
|
|
|
cFinishGenSprinkleFoliage(int a_Seed) : m_Noise(a_Seed), m_Seed(a_Seed) {}
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
protected:
|
2013-03-17 13:55:03 -04:00
|
|
|
cNoise m_Noise;
|
|
|
|
int m_Seed;
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2015-07-31 10:49:10 -04:00
|
|
|
/** Tries to place sugarcane at the coords specified, returns true if successful */
|
2013-03-17 13:55:03 -04:00
|
|
|
bool TryAddSugarcane(cChunkDesc & a_ChunkDesc, int a_RelX, int a_RelY, int a_RelZ);
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2014-12-01 20:28:46 -05:00
|
|
|
// Returns true is the specified biome is a desert or its variant
|
|
|
|
static bool IsDesertVariant(EMCSBiome a_biome);
|
2014-12-01 14:44:20 -05:00
|
|
|
|
2012-06-14 09:06:06 -04:00
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2012-06-14 09:06:06 -04:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-07-03 15:16:09 -04:00
|
|
|
|
2013-03-17 13:55:03 -04:00
|
|
|
/** This class adds a single top block in random positions in the specified biome on top of specified allowed blocks.
|
|
|
|
Used for:
|
|
|
|
- Lilypads finisher
|
2015-07-31 10:49:10 -04:00
|
|
|
- DeadBushes finisher */
|
2014-07-28 08:23:29 -04:00
|
|
|
class cFinishGenSingleTopBlock :
|
2012-07-03 15:16:09 -04:00
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2014-07-28 08:23:29 -04:00
|
|
|
typedef std::vector<BLOCKTYPE> BlockList;
|
2014-07-28 10:53:01 -04:00
|
|
|
bool m_IsAllowedBelow[256];
|
|
|
|
|
2014-07-28 08:23:29 -04:00
|
|
|
typedef std::vector<EMCSBiome> BiomeList;
|
2014-07-28 10:53:01 -04:00
|
|
|
bool m_IsBiomeAllowed[256];
|
|
|
|
|
2014-07-28 08:23:29 -04:00
|
|
|
|
|
|
|
cFinishGenSingleTopBlock(
|
|
|
|
int a_Seed, BLOCKTYPE a_BlockType, BiomeList a_Biomes, int a_Amount,
|
|
|
|
BlockList a_AllowedBelow
|
2013-03-17 13:55:03 -04:00
|
|
|
) :
|
|
|
|
m_Noise(a_Seed),
|
|
|
|
m_BlockType(a_BlockType),
|
2014-07-28 10:53:01 -04:00
|
|
|
m_Amount(a_Amount)
|
2014-07-29 11:01:15 -04:00
|
|
|
{
|
2014-07-29 07:13:23 -04:00
|
|
|
// Initialize all the block types.
|
2014-07-30 01:08:29 -04:00
|
|
|
for (size_t idx = 0; idx < ARRAYCOUNT(m_IsAllowedBelow); ++idx)
|
2014-07-29 07:13:23 -04:00
|
|
|
{
|
|
|
|
m_IsAllowedBelow[idx] = false;
|
|
|
|
}
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2014-07-28 10:53:01 -04:00
|
|
|
// Load the allowed blocks into m_IsAllowedBelow
|
|
|
|
for (BlockList::iterator itr = a_AllowedBelow.begin(); itr != a_AllowedBelow.end(); ++itr)
|
|
|
|
{
|
|
|
|
m_IsAllowedBelow[*itr] = true;
|
|
|
|
}
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2014-07-29 07:13:23 -04:00
|
|
|
// Initialize all the biome types.
|
2014-07-30 01:08:29 -04:00
|
|
|
for (size_t idx = 0; idx < ARRAYCOUNT(m_IsBiomeAllowed); ++idx)
|
2014-07-29 07:13:23 -04:00
|
|
|
{
|
|
|
|
m_IsBiomeAllowed[idx] = false;
|
|
|
|
}
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2014-07-28 10:53:01 -04:00
|
|
|
// Load the allowed biomes into m_IsBiomeAllowed
|
|
|
|
for (BiomeList::iterator itr = a_Biomes.begin(); itr != a_Biomes.end(); ++itr)
|
|
|
|
{
|
|
|
|
m_IsBiomeAllowed[*itr] = true;
|
|
|
|
}
|
2012-07-03 15:16:09 -04:00
|
|
|
}
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2012-07-03 15:16:09 -04:00
|
|
|
protected:
|
|
|
|
cNoise m_Noise;
|
2013-03-17 13:55:03 -04:00
|
|
|
BLOCKTYPE m_BlockType;
|
2015-07-31 10:49:10 -04:00
|
|
|
|
|
|
|
/** Relative amount of blocks to try adding. 1 = one block per 256 biome columns. */
|
|
|
|
int m_Amount;
|
|
|
|
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2013-03-17 13:55:03 -04:00
|
|
|
int GetNumToGen(const cChunkDef::BiomeMap & a_BiomeMap);
|
2014-07-28 08:23:29 -04:00
|
|
|
|
2015-07-31 10:49:10 -04:00
|
|
|
/** Returns true if the given biome is a biome that is allowed. */
|
2014-07-28 10:53:01 -04:00
|
|
|
inline bool IsAllowedBiome(EMCSBiome a_Biome)
|
2014-07-28 08:23:29 -04:00
|
|
|
{
|
2014-07-28 10:53:01 -04:00
|
|
|
return m_IsBiomeAllowed[a_Biome];
|
2014-07-28 08:23:29 -04:00
|
|
|
}
|
|
|
|
|
2015-07-31 10:49:10 -04:00
|
|
|
/** Returns true if the given blocktype may be below m_BlockType */
|
2014-07-28 10:53:01 -04:00
|
|
|
inline bool IsAllowedBlockBelow(BLOCKTYPE a_BlockBelow)
|
2014-07-28 08:23:29 -04:00
|
|
|
{
|
2014-07-28 10:53:01 -04:00
|
|
|
return m_IsAllowedBelow[a_BlockBelow];
|
2014-07-28 08:23:29 -04:00
|
|
|
}
|
|
|
|
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2012-07-03 15:16:09 -04:00
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2012-07-03 15:16:09 -04:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-07-27 17:00:11 -04:00
|
|
|
class cFinishGenBottomLava :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
cFinishGenBottomLava(int a_Level) :
|
|
|
|
m_Level(a_Level)
|
|
|
|
{
|
|
|
|
}
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2014-01-10 10:31:45 -05:00
|
|
|
int GetLevel(void) const { return m_Level; }
|
2012-07-27 17:00:11 -04:00
|
|
|
protected:
|
|
|
|
int m_Level;
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2012-07-27 17:00:11 -04:00
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2012-07-27 17:00:11 -04:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-10-21 16:06:31 -04:00
|
|
|
class cFinishGenPreSimulator :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2014-07-30 07:06:48 -04:00
|
|
|
cFinishGenPreSimulator(bool a_PreSimulateFallingBlocks, bool a_PreSimulateWater, bool a_PreSimulateLava);
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2012-10-21 16:06:31 -04:00
|
|
|
protected:
|
2014-07-30 07:06:48 -04:00
|
|
|
|
|
|
|
bool m_PreSimulateFallingBlocks;
|
|
|
|
bool m_PreSimulateWater;
|
|
|
|
bool m_PreSimulateLava;
|
|
|
|
|
2015-07-31 10:49:10 -04:00
|
|
|
/** Drops hanging sand and gravel down to the ground, recalculates heightmap */
|
2012-10-21 16:06:31 -04:00
|
|
|
void CollapseSandGravel(
|
|
|
|
cChunkDef::BlockTypes & a_BlockTypes, // Block types to read and change
|
2012-10-21 17:15:44 -04:00
|
|
|
cChunkDef::HeightMap & a_HeightMap // Height map to update by the current data
|
2012-10-21 16:06:31 -04:00
|
|
|
);
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2012-10-21 17:15:44 -04:00
|
|
|
/** For each fluid block:
|
|
|
|
- if all surroundings are of the same fluid, makes it stationary; otherwise makes it flowing (excl. top)
|
2015-07-31 10:49:10 -04:00
|
|
|
- all fluid on the chunk's edge is made flowing */
|
2012-10-21 17:15:44 -04:00
|
|
|
void StationarizeFluid(
|
|
|
|
cChunkDef::BlockTypes & a_BlockTypes, // Block types to read and change
|
|
|
|
cChunkDef::HeightMap & a_HeightMap, // Height map to read
|
|
|
|
BLOCKTYPE a_Fluid,
|
|
|
|
BLOCKTYPE a_StationaryFluid
|
|
|
|
);
|
|
|
|
|
2012-10-21 16:06:31 -04:00
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2012-11-11 10:35:49 -05:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-03-14 05:52:57 -04:00
|
|
|
class cFinishGenFluidSprings :
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
public:
|
2014-01-10 16:22:54 -05:00
|
|
|
cFinishGenFluidSprings(int a_Seed, BLOCKTYPE a_Fluid, cIniFile & a_IniFile, eDimension a_Dimension);
|
2014-12-03 03:26:15 -05:00
|
|
|
|
2013-03-14 05:52:57 -04:00
|
|
|
protected:
|
|
|
|
|
|
|
|
cNoise m_Noise;
|
|
|
|
cProbabDistrib m_HeightDistribution;
|
|
|
|
BLOCKTYPE m_Fluid;
|
|
|
|
int m_Chance; ///< Chance, [0..100], that a spring will be generated in a chunk
|
|
|
|
|
|
|
|
// cFinishGen override:
|
2013-03-17 13:55:03 -04:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2013-03-14 05:52:57 -04:00
|
|
|
|
2014-12-05 16:46:46 -05:00
|
|
|
/** Tries to place a spring at the specified coords, checks neighbors. Returns true if successful. */
|
2013-03-19 04:32:02 -04:00
|
|
|
bool TryPlaceSpring(cChunkDesc & a_ChunkDesc, int x, int y, int z);
|
2013-03-14 05:52:57 -04:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-12-02 04:37:17 -05:00
|
|
|
|
2014-12-04 04:18:55 -05:00
|
|
|
/** This class populates generated chunks with packs of biome-dependant animals
|
2014-12-05 16:46:46 -05:00
|
|
|
Animals: cows, sheep, pigs, mooshrooms, squid, horses, wolves, ocelots */
|
2014-12-02 04:37:17 -05:00
|
|
|
class cFinishGenPassiveMobs :
|
2014-12-02 04:58:30 -05:00
|
|
|
public cFinishGen
|
2014-12-02 04:37:17 -05:00
|
|
|
{
|
|
|
|
public:
|
2016-02-05 16:45:45 -05:00
|
|
|
|
2014-12-02 04:58:30 -05:00
|
|
|
cFinishGenPassiveMobs(int a_Seed, cIniFile & a_IniFile, eDimension a_Dimension);
|
2014-12-02 04:37:17 -05:00
|
|
|
|
|
|
|
protected:
|
|
|
|
|
2014-12-05 16:46:46 -05:00
|
|
|
/** The noise used as the source of randomness */
|
|
|
|
cNoise m_Noise;
|
|
|
|
|
|
|
|
/** Chance, [0..100], that an animal pack will be generated in a chunk */
|
|
|
|
int m_AnimalProbability;
|
|
|
|
|
2014-12-02 04:37:17 -05:00
|
|
|
|
2014-12-04 04:08:17 -05:00
|
|
|
// cFinishGen override:
|
2014-12-02 04:58:30 -05:00
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
2014-12-02 04:37:17 -05:00
|
|
|
|
2014-12-05 16:46:46 -05:00
|
|
|
/** Returns false if an animal cannot spawn at given coords, else adds it to the chunk's entity list and returns true */
|
2014-12-02 04:58:30 -05:00
|
|
|
bool TrySpawnAnimals(cChunkDesc & a_ChunkDesc, int x, int y, int z, eMonsterType AnimalToSpawn);
|
2014-12-02 04:37:17 -05:00
|
|
|
|
2014-12-05 16:46:46 -05:00
|
|
|
/** Picks a random animal from biome-dependant list for a random position in the chunk.
|
|
|
|
Returns the chosen mob type, or mtInvalid if no mob chosen. */
|
2014-12-02 04:58:30 -05:00
|
|
|
eMonsterType GetRandomMob(cChunkDesc & a_ChunkDesc);
|
2014-12-02 04:37:17 -05:00
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-11-25 03:22:13 -05:00
|
|
|
|
|
|
|
/** Base class for generators that have an ore list attached to them.
|
|
|
|
Provides the storage and parsing for the ore list, as well as the generic plumbing for generating individual ores.
|
|
|
|
Descendants should override GenerateOre() to provide the specific ore generation technique.
|
|
|
|
Note that this class uses the "Nest" terminology for individual packs of ore, it doesn't imply any shape or algorithm. */
|
|
|
|
class cFinishGenOres:
|
|
|
|
public cFinishGen
|
|
|
|
{
|
|
|
|
typedef cFinishGen Super;
|
|
|
|
|
|
|
|
public:
|
|
|
|
struct OreInfo
|
|
|
|
{
|
|
|
|
BLOCKTYPE m_BlockType; // The type of the nest.
|
|
|
|
NIBBLETYPE m_BlockMeta; // The block meta
|
|
|
|
int m_MaxHeight; // The highest possible a nest can occur
|
|
|
|
int m_NumNests; // How many nests per chunk
|
|
|
|
int m_NestSize; // The amount of blocks a nest can have.
|
|
|
|
|
|
|
|
OreInfo() :
|
|
|
|
m_BlockType(0),
|
|
|
|
m_BlockMeta(0),
|
|
|
|
m_MaxHeight(0),
|
|
|
|
m_NumNests(0),
|
|
|
|
m_NestSize(0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
OreInfo(BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta, int a_MaxHeight, int a_NumNests, int a_NestSize) :
|
|
|
|
m_BlockType(a_OreType),
|
|
|
|
m_BlockMeta(a_OreMeta),
|
|
|
|
m_MaxHeight(a_MaxHeight),
|
|
|
|
m_NumNests(a_NumNests),
|
|
|
|
m_NestSize(a_NestSize)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::vector<OreInfo> OreInfos;
|
|
|
|
|
|
|
|
cFinishGenOres(int a_Seed, const OreInfos & a_OreInfos):
|
|
|
|
m_Noise(a_Seed),
|
|
|
|
m_OreInfos(a_OreInfos)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// cFinishGen overrides:
|
|
|
|
virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
|
|
|
|
|
|
|
|
/** Returns a vector of OreInfo structures describing the default Overworld ores, usable in the constructor. */
|
|
|
|
static const OreInfos & DefaultOverworldOres(void);
|
|
|
|
|
|
|
|
/** Returns a vector of OreInfo structures describing the default Nether ores, usable in the constructor. */
|
|
|
|
static const OreInfos & DefaultNetherOres(void);
|
|
|
|
|
|
|
|
/** Returns a vector of OreInfo structures describing the default Overworld non-ore pockets (dirt, diorite etc), usable in the constructor. */
|
|
|
|
static const OreInfos & DefaultNaturalPatches(void);
|
|
|
|
|
2015-11-25 09:06:32 -05:00
|
|
|
/** Parses the parameter string into OreInfos array.
|
|
|
|
See OreInfosToString() for the complementary function.
|
|
|
|
Used for loading configuration from INI files. */
|
|
|
|
static OreInfos OreInfosFromString(const AString & a_OreInfosString);
|
|
|
|
|
|
|
|
/** Returns a string that represents the OreInfos given as the parameter.
|
|
|
|
See OreInfosFromString() for the complementary function.
|
|
|
|
Used for storing defaults in the INI file. */
|
|
|
|
static AString OreInfosToString(const OreInfos & a_OreInfos);
|
|
|
|
|
|
|
|
/** (Re-)sets the seed used by the internal generating mechanisms. */
|
|
|
|
void SetSeed(int a_Seed);
|
|
|
|
|
2015-11-25 03:22:13 -05:00
|
|
|
protected:
|
|
|
|
/** The noise used for generating. */
|
|
|
|
cNoise m_Noise;
|
|
|
|
|
|
|
|
/** All the ores enabled in this generator. */
|
|
|
|
OreInfos m_OreInfos;
|
|
|
|
|
|
|
|
|
|
|
|
/** Generates a single ore in the specified chunk image.
|
|
|
|
a_Seq is the sequencing number (used as a complement to seed to make each ore in the same chunk have different nests) */
|
|
|
|
virtual void GenerateOre(
|
|
|
|
cChunkDesc & a_ChunkDesc,
|
|
|
|
BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta,
|
|
|
|
int a_MaxHeight, int a_NumNests, int a_NestSize,
|
|
|
|
int a_Seq
|
|
|
|
) = 0;
|
|
|
|
|
|
|
|
// TODO: Helper function to parse a config string into m_OreInfos
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class cFinishGenOreNests :
|
|
|
|
public cFinishGenOres
|
|
|
|
{
|
|
|
|
typedef cFinishGenOres Super;
|
|
|
|
|
|
|
|
public:
|
|
|
|
cFinishGenOreNests(int a_Seed, const OreInfos & a_OreInfos):
|
|
|
|
Super(a_Seed, a_OreInfos)
|
|
|
|
{}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
// cFinishGenOreClumps overrides:
|
|
|
|
virtual void GenerateOre(
|
|
|
|
cChunkDesc & a_ChunkDesc,
|
|
|
|
BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta,
|
|
|
|
int a_MaxHeight, int a_NumNests, int a_NestSize,
|
|
|
|
int a_Seq
|
|
|
|
) override;
|
|
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class cFinishGenOrePockets:
|
|
|
|
public cFinishGenOres
|
|
|
|
{
|
|
|
|
typedef cFinishGenOres Super;
|
|
|
|
|
|
|
|
public:
|
|
|
|
cFinishGenOrePockets(int a_Seed, const OreInfos & a_OreInfos):
|
|
|
|
Super(a_Seed, a_OreInfos)
|
|
|
|
{}
|
|
|
|
|
|
|
|
/** Reads the configuration from the specified INI file.
|
2015-11-25 09:06:32 -05:00
|
|
|
a_GenName is the name of the generator (this class may be used for OrePockets and DirtPockets, each has a different default).
|
2015-11-25 03:22:13 -05:00
|
|
|
Returns true on success, false and logs errors to console on failure. */
|
2015-11-25 09:06:32 -05:00
|
|
|
bool Initialize(cIniFile & a_IniFile, const AString & a_GenName);
|
2015-11-25 03:22:13 -05:00
|
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
// cFinishGenOreClumps overrides:
|
|
|
|
virtual void GenerateOre(
|
|
|
|
cChunkDesc & a_ChunkDesc,
|
|
|
|
BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta,
|
|
|
|
int a_MaxNestHeight, int a_NumNests, int a_NestSize,
|
|
|
|
int a_Seq
|
|
|
|
) override;
|
|
|
|
|
|
|
|
/** Calculates the pockets for the specified chunk and imprints them into the specified ChunkDesc (not necessarily the same chunk).
|
|
|
|
a_Seq is the sequence number of the ore, to provide another source of randomness. */
|
|
|
|
void imprintChunkOrePockets(
|
|
|
|
int a_ChunkX, int a_ChunkZ,
|
|
|
|
cChunkDesc & a_ChunkDesc,
|
|
|
|
BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta,
|
|
|
|
int a_MaxHeight, int a_NumNests, int a_NestSize,
|
|
|
|
int a_Seq
|
|
|
|
);
|
|
|
|
|
|
|
|
/** Imprints a single pocket of the specified ore at the specified coords into the chunk.
|
|
|
|
The pocket shape has its minimum X and Z coords specified, Y can be anywhere around the specified Y coord.
|
|
|
|
a_Seq is the sequence number of the ore, to provide another source of randomness. */
|
|
|
|
void imprintPocket(
|
|
|
|
cChunkDesc & a_ChunkDesc,
|
|
|
|
int a_MinPocketX, int a_PocketY, int a_MinPocketZ,
|
|
|
|
int a_NestSize, int a_Seq,
|
|
|
|
BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta
|
|
|
|
);
|
|
|
|
|
|
|
|
/** Imprints a single sphere of the specified ore at the specified coords. */
|
|
|
|
void imprintSphere(
|
|
|
|
cChunkDesc & a_ChunkDesc,
|
|
|
|
double a_SphereX, double a_SphereY, double a_SphereZ, double a_Radius,
|
|
|
|
BLOCKTYPE a_OreType, NIBBLETYPE a_OreMeta
|
|
|
|
);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|