flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

Using Super.

Browse Source
This commit is contained in:
Mattes D
2020-04-13 18:38:06 +02:00
committed by Alexander Harkness
parent f931590bf0
commit 9ee47e5999
399 changed files with 1815 additions and 1381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/Generating/BioGen.cpp
View File

@@ -129,7 +129,7 @@ void cBioGenCache::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::BiomeMap & a
void cBioGenCache::InitializeBiomeGen(cIniFile & a_IniFile)
{
super::InitializeBiomeGen(a_IniFile);
Super::InitializeBiomeGen(a_IniFile);
m_BioGenToCache->InitializeBiomeGen(a_IniFile);
}
@@ -280,7 +280,7 @@ void cBioGenCheckerboard::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::Biome
void cBioGenCheckerboard::InitializeBiomeGen(cIniFile & a_IniFile)
{
super::InitializeBiomeGen(a_IniFile);
Super::InitializeBiomeGen(a_IniFile);
AString Biomes = a_IniFile.GetValueSet ("Generator", "CheckerBoardBiomes", "");
m_BiomeSize = a_IniFile.GetValueSetI("Generator", "CheckerboardBiomeSize", 64);
m_BiomeSize = (m_BiomeSize < 8) ? 8 : m_BiomeSize;
@@ -315,7 +315,7 @@ void cBioGenVoronoi::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::BiomeMap &
void cBioGenVoronoi::InitializeBiomeGen(cIniFile & a_IniFile)
{
super::InitializeBiomeGen(a_IniFile);
Super::InitializeBiomeGen(a_IniFile);
int CellSize = a_IniFile.GetValueSetI("Generator", "VoronoiCellSize", 128);
int JitterSize = a_IniFile.GetValueSetI("Generator", "VoronoiJitterSize", CellSize);
int OddRowOffset = a_IniFile.GetValueSetI("Generator", "VoronoiOddRowOffset", 0);
@@ -364,7 +364,7 @@ void cBioGenDistortedVoronoi::GenBiomes(cChunkCoords a_ChunkCoords, cChunkDef::B
void cBioGenDistortedVoronoi::InitializeBiomeGen(cIniFile & a_IniFile)
{
super::InitializeBiomeGen(a_IniFile);
Super::InitializeBiomeGen(a_IniFile);
m_CellSize = a_IniFile.GetValueSetI("Generator", "DistortedVoronoiCellSize", 96);
m_Voronoi.SetCellSize(m_CellSize);
InitializeBiomes(a_IniFile.GetValueSet("Generator", "DistortedVoronoiBiomes", ""));

42
src/Generating/BioGen.h
View File

@@ -42,10 +42,10 @@ protected:
/** A simple cache that stores N most recently generated chunks' biomes; N being settable upon creation */
class cBioGenCache :
class cBioGenCache:
public cBiomeGen
{
typedef cBiomeGen super;
using Super = cBiomeGen;
public:
@@ -87,11 +87,10 @@ protected:
class cBioGenMulticache :
class cBioGenMulticache:
public cBiomeGen
{
typedef cBiomeGen super;
using Super = cBiomeGen;
public:
/* Creates a new multicache - a cache that divides the caching into several sub-caches based on the chunk coords.
@@ -120,12 +119,13 @@ protected:
/** Base class for generators that use a list of available biomes. This class takes care of the list. */
class cBiomeGenList :
class cBiomeGenList:
public cBiomeGen
{
typedef cBiomeGen super;
using Super = cBiomeGen;
protected:
// List of biomes that the generator is allowed to generate:
typedef std::vector<EMCSBiome> EMCSBiomes;
EMCSBiomes m_Biomes;
@@ -139,12 +139,13 @@ protected:
class cBioGenCheckerboard :
class cBioGenCheckerboard:
public cBiomeGenList
{
typedef cBiomeGenList super;
using Super = cBiomeGenList;
protected:
int m_BiomeSize;
// cBiomeGen overrides:
@@ -156,18 +157,20 @@ protected:
class cBioGenVoronoi :
class cBioGenVoronoi:
public cBiomeGenList
{
typedef cBiomeGenList super;
using Super = cBiomeGenList;
public:
cBioGenVoronoi(int a_Seed) :
m_Voronoi(a_Seed)
{
}
protected:
cVoronoiMap m_Voronoi;
// cBiomeGen overrides:
@@ -181,13 +184,14 @@ protected:
class cBioGenDistortedVoronoi :
class cBioGenDistortedVoronoi:
public cBiomeGenList
{
typedef cBiomeGenList super;
using Super = cBiomeGenList;
public:
cBioGenDistortedVoronoi(int a_Seed) :
cBioGenDistortedVoronoi(int a_Seed):
m_Noise(a_Seed),
m_Voronoi(a_Seed),
m_CellSize(0)
@@ -216,12 +220,13 @@ protected:
class cBioGenMultiStepMap :
class cBioGenMultiStepMap:
public cBiomeGen
{
typedef cBiomeGen super;
using Super = cBiomeGen;
public:
cBioGenMultiStepMap(int a_Seed);
protected:
@@ -276,12 +281,13 @@ protected:
class cBioGenTwoLevel :
class cBioGenTwoLevel:
public cBiomeGen
{
typedef cBiomeGen super;
using Super = cBiomeGen;
public:
cBioGenTwoLevel(int a_Seed);
protected:

7
src/Generating/Caves.cpp
View File

@@ -117,12 +117,13 @@ typedef std::vector<cCaveTunnel *> cCaveTunnels;
/** A collection of connected tunnels, possibly branching. */
class cStructGenWormNestCaves::cCaveSystem :
class cStructGenWormNestCaves::cCaveSystem:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
public:
// The generating block position; is read directly in cStructGenWormNestCaves::GetCavesForChunk()
int m_BlockX;
int m_BlockZ;
@@ -577,7 +578,7 @@ AString cCaveTunnel::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) cons
// cStructGenWormNestCaves::cCaveSystem:
cStructGenWormNestCaves::cCaveSystem::cCaveSystem(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ, int a_MaxOffset, int a_Size, cNoise & a_Noise) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
m_Size(a_Size)
{
int Num = 1 + a_Noise.IntNoise2DInt(a_OriginX, a_OriginZ) % 3;

9
src/Generating/Caves.h
View File

@@ -62,13 +62,15 @@ protected:
class cStructGenWormNestCaves :
class cStructGenWormNestCaves:
public cGridStructGen
{
typedef cGridStructGen super;
using Super = cGridStructGen;
public:
cStructGenWormNestCaves(int a_Seed, int a_Size = 64, int a_Grid = 96, int a_MaxOffset = 128) :
super(a_Seed, a_Grid, a_Grid, a_MaxOffset, a_MaxOffset, a_Size, a_Size, 100),
Super(a_Seed, a_Grid, a_Grid, a_MaxOffset, a_MaxOffset, a_Size, a_Size, 100),
m_Size(a_Size),
m_MaxOffset(a_MaxOffset),
m_Grid(a_Grid)
@@ -76,6 +78,7 @@ public:
}
protected:
class cCaveSystem; // fwd: Caves.cpp
int m_Size; // relative size of the cave systems' caves. Average number of blocks of each initial tunnel

5
src/Generating/ComposableGenerator.h
View File

@@ -200,12 +200,13 @@ typedef std::list<cFinishGenPtr> cFinishGenList;
class cComposableGenerator :
class cComposableGenerator:
public cChunkGenerator
{
typedef cChunkGenerator Super;
using Super = cChunkGenerator;
public:
cComposableGenerator();
// cChunkGenerator::cGenerator overrides:

10
src/Generating/DungeonRoomsFinisher.cpp
View File

@@ -24,10 +24,10 @@ static const int ROOM_HEIGHT = 4;
////////////////////////////////////////////////////////////////////////////////
// cDungeonRoom:
class cDungeonRoom :
class cDungeonRoom:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
public:
@@ -37,8 +37,8 @@ public:
int a_HalfSizeX, int a_HalfSizeZ,
int a_FloorHeight,
cNoise & a_Noise
) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
):
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
m_StartX(a_OriginX - a_HalfSizeX),
m_EndX(a_OriginX + a_HalfSizeX),
m_StartZ(a_OriginZ - a_HalfSizeZ),
@@ -288,7 +288,7 @@ protected:
// cDungeonRoomsFinisher:
cDungeonRoomsFinisher::cDungeonRoomsFinisher(cTerrainShapeGenPtr a_ShapeGen, int a_Seed, int a_GridSize, int a_MaxSize, int a_MinSize, const AString & a_HeightDistrib) :
super(a_Seed + 100, a_GridSize, a_GridSize, a_GridSize, a_GridSize, a_MaxSize, a_MaxSize, 1024),
Super(a_Seed + 100, a_GridSize, a_GridSize, a_GridSize, a_GridSize, a_MaxSize, a_MaxSize, 1024),
m_ShapeGen(a_ShapeGen),
m_MaxHalfSize((a_MaxSize + 1) / 2),
m_MinHalfSize((a_MinSize + 1) / 2),

5
src/Generating/DungeonRoomsFinisher.h
View File

@@ -16,12 +16,13 @@
class cDungeonRoomsFinisher :
class cDungeonRoomsFinisher:
public cGridStructGen
{
typedef cGridStructGen super;
using Super = cGridStructGen;
public:
/** Creates a new dungeon room finisher.
a_ShapeGen is the underlying terrain shape generator, so that the rooms can always be placed under the terrain.
a_MaxSize and a_MinSize are the maximum and minimum sizes of the room's internal (air) area, in blocks across.

11
src/Generating/FinishGen.h
View File

@@ -487,9 +487,10 @@ Note that this class uses the "Nest" terminology for individual packs of ore, it
class cFinishGenOres:
public cFinishGen
{
typedef cFinishGen Super;
using Super = cFinishGen;
public:
struct OreInfo
{
BLOCKTYPE m_BlockType; // The type of the nest.
@@ -574,12 +575,13 @@ protected:
class cFinishGenOreNests :
class cFinishGenOreNests:
public cFinishGenOres
{
typedef cFinishGenOres Super;
using Super = cFinishGenOres;
public:
cFinishGenOreNests(int a_Seed, const OreInfos & a_OreInfos):
Super(a_Seed, a_OreInfos)
{}
@@ -602,9 +604,10 @@ protected:
class cFinishGenOrePockets:
public cFinishGenOres
{
typedef cFinishGenOres Super;
using Super = cFinishGenOres;
public:
cFinishGenOrePockets(int a_Seed, const OreInfos & a_OreInfos):
Super(a_Seed, a_OreInfos)
{}

7
src/Generating/GridStructGen.cpp
View File

@@ -16,14 +16,15 @@
/** A cStructure descendant representing an empty structure.
Used when the generator descended from cGridStructGen doesn't return any structure, to keep at least the
Origin coords so that the structure isn't queried over and over again. */
class cEmptyStructure :
class cEmptyStructure:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
public:
cEmptyStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ)
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ)
{
}

3
src/Generating/HeiGen.cpp
View File

@@ -629,12 +629,13 @@ NOISE_DATATYPE cHeiGenBiomal::GetHeightAt(int a_RelX, int a_RelZ, int a_ChunkX,
class cHeiGenMinMax:
public cTerrainHeightGen
{
typedef cTerrainHeightGen Super;
using Super = cTerrainHeightGen;
/** Size of the averaging process, in columns (for each direction). Must be less than 16. */
static const int AVERAGING_SIZE = 4;
public:
cHeiGenMinMax(int a_Seed, cBiomeGenPtr a_BiomeGen):
m_Noise(a_Seed),
m_BiomeGen(a_BiomeGen),

7
src/Generating/HeiGen.h
View File

@@ -167,13 +167,14 @@ protected:
class cHeiGenBiomal :
class cHeiGenBiomal:
public cTerrainHeightGen
{
typedef cTerrainHeightGen Super;
using Super = cTerrainHeightGen;
public:
cHeiGenBiomal(int a_Seed, cBiomeGenPtr a_BiomeGen) :
cHeiGenBiomal(int a_Seed, cBiomeGenPtr a_BiomeGen):
m_Noise(a_Seed),
m_BiomeGen(a_BiomeGen)
{

235
src/Generating/IntGen.h
View File

@@ -55,14 +55,14 @@ class cIntGen
{
public:
typedef cIntGen<SizeX, SizeZ> IntGenType;
using IntGenType = cIntGen<SizeX, SizeZ>;
/** 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 ~cIntGen() {}
/** Holds the array of values generated by this class (descendant). */
typedef int Values[SizeX * SizeZ];
using Values = int[SizeX * SizeZ];
/** Generates the array of templated size into a_Values, based on given min coords. */
virtual void GetInts(int a_MinX, int a_MinZ, Values & a_Values) = 0;
@@ -84,7 +84,7 @@ struct sGens : sGens<N - 1, N - 1, S...>
template<int... S>
struct sGens<0, S...>
{
typedef sSeq<S...> type;
using type = sSeq<S...>;
};
@@ -94,7 +94,7 @@ class cIntGenFactory
public:
typedef Gen Generator;
using Generator = Gen;
cIntGenFactory(Args&&... a_args) :
m_args(std::make_tuple<Args...>(std::forward<Args>(a_args)...))
@@ -135,13 +135,14 @@ cIntGenFactory<Gen, Args...> MakeIntGen(Args&&... a_Args)
/** Provides additional cNoise member and its helper functions. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenWithNoise :
class cIntGenWithNoise:
public cIntGen<SizeX, SizeZ>
{
typedef cIntGen<SizeX, SizeZ> super;
using Super = cIntGen<SizeX, SizeZ>;
public:
cIntGenWithNoise(int a_Seed) :
cIntGenWithNoise(int a_Seed):
m_Noise(a_Seed)
{
}
@@ -176,26 +177,27 @@ protected:
/** Generates a 2D array of random integers in the specified range [0 .. Range). */
template <int Range, int SizeX, int SizeZ = SizeX>
class cIntGenChoice :
class cIntGenChoice:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
cIntGenChoice(int a_Seed) :
super(a_Seed)
cIntGenChoice(int a_Seed):
Super(a_Seed)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
for (int z = 0; z < SizeZ; z++)
{
int BaseZ = a_MinZ + z;
for (int x = 0; x < SizeX; x++)
{
a_Values[x + SizeX * z] = (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7) % Range;
a_Values[x + SizeX * z] = (Super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7) % Range;
}
} // for z
}
@@ -209,27 +211,28 @@ public:
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. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenLandOcean :
class cIntGenLandOcean:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
cIntGenLandOcean(int a_Seed, int a_Threshold) :
super(a_Seed),
cIntGenLandOcean(int a_Seed, int a_Threshold):
Super(a_Seed),
m_Threshold(a_Threshold)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
for (int z = 0; z < SizeZ; z++)
{
int BaseZ = a_MinZ + z;
for (int x = 0; x < SizeX; x++)
{
int rnd = (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7);
int rnd = (Super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7);
a_Values[x + SizeX * z] = ((rnd % 100) < m_Threshold) ? ((rnd / 101) % bgLandOceanMax + 1) : 0;
}
}
@@ -253,27 +256,29 @@ protected:
This means that the zoome out image is randomly distorted. Applying zoom several times provides all
the distortion that the generators need. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenZoom :
class cIntGenZoom:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
protected:
static const int m_LowerSizeX = (SizeX / 2) + 2;
static const int m_LowerSizeZ = (SizeZ / 2) + 2;
public:
typedef std::shared_ptr<cIntGen<m_LowerSizeX, m_LowerSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<m_LowerSizeX, m_LowerSizeZ>>;
cIntGenZoom(int a_Seed, Underlying a_UnderlyingGen) :
super(a_Seed),
cIntGenZoom(int a_Seed, Underlying a_UnderlyingGen):
Super(a_Seed),
m_UnderlyingGen(a_UnderlyingGen)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying data with half the resolution:
int lowerMinX = a_MinX >> 1;
@@ -298,9 +303,9 @@ public:
int RndX = (x + lowerMinX) * 2;
int RndZ = (z + lowerMinZ) * 2;
cache[idx] = PrevZ0;
cache[idx + lowStepX] = super::ChooseRandomOne(RndX, RndZ + 1, PrevZ0, PrevZ1);
cache[idx + 1] = super::ChooseRandomOne(RndX, RndZ - 1, PrevZ0, ValX1Z0);
cache[idx + 1 + lowStepX] = super::ChooseRandomOne(RndX, RndZ, PrevZ0, ValX1Z0, PrevZ1, ValX1Z1);
cache[idx + lowStepX] = Super::ChooseRandomOne(RndX, RndZ + 1, PrevZ0, PrevZ1);
cache[idx + 1] = Super::ChooseRandomOne(RndX, RndZ - 1, PrevZ0, ValX1Z0);
cache[idx + 1 + lowStepX] = Super::ChooseRandomOne(RndX, RndZ, PrevZ0, ValX1Z0, PrevZ1, ValX1Z1);
idx += 2;
PrevZ0 = ValX1Z0;
PrevZ1 = ValX1Z1;
@@ -325,25 +330,27 @@ protected:
/** Smoothes out some artifacts generated by the zooming - mostly single-pixel values.
Compares each pixel to its neighbors and if the neighbors are equal, changes the pixel to their value. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenSmooth :
class cIntGenSmooth:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
static const int m_LowerSizeX = SizeX + 2;
static const int m_LowerSizeZ = SizeZ + 2;
public:
typedef std::shared_ptr<cIntGen<m_LowerSizeX, m_LowerSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<m_LowerSizeX, m_LowerSizeZ>>;
cIntGenSmooth(int a_Seed, Underlying a_Underlying) :
super(a_Seed),
cIntGenSmooth(int a_Seed, Underlying a_Underlying):
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying values:
int lowerData[m_LowerSizeX * m_LowerSizeZ];
@@ -364,7 +371,7 @@ public:
if ((left == right) && (above == below))
{
if (((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % 2) == 0)
if (((Super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % 2) == 0)
{
val = left;
}
@@ -401,24 +408,26 @@ protected:
/** Converts land biomes at the edge of an ocean into the respective beach biome. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenBeaches :
class cIntGenBeaches:
public cIntGen<SizeX, SizeZ>
{
typedef cIntGen<SizeX, SizeZ> super;
using Super = cIntGen<SizeX, SizeZ>;
static const int m_UnderlyingSizeX = SizeX + 2;
static const int m_UnderlyingSizeZ = SizeZ + 2;
public:
typedef std::shared_ptr<cIntGen<m_UnderlyingSizeX, m_UnderlyingSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<m_UnderlyingSizeX, m_UnderlyingSizeZ>>;
cIntGenBeaches(Underlying a_Underlying) :
cIntGenBeaches(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Map for biome -> its beach:
static const int ToBeach[] =
@@ -503,24 +512,25 @@ protected:
/** Generates the underlying numbers and then randomly changes some ocean group pixels into random land
biome group pixels, based on the predefined chance. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenAddIslands :
class cIntGenAddIslands:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenAddIslands(int a_Seed, int a_Chance, Underlying a_Underlying) :
super(a_Seed),
cIntGenAddIslands(int a_Seed, int a_Chance, Underlying a_Underlying):
Super(a_Seed),
m_Chance(a_Chance),
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
m_Underlying->GetInts(a_MinX, a_MinZ, a_Values);
for (int z = 0; z < SizeZ; z++)
@@ -529,7 +539,7 @@ public:
{
if (a_Values[x + z * SizeX] == bgOcean)
{
int rnd = super::m_Noise.IntNoise2DInt(a_MinX + x, a_MinZ + z) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(a_MinX + x, a_MinZ + z) / 7;
if (rnd % 1000 < m_Chance)
{
a_Values[x + z * SizeX] = (rnd / 1003) % bgLandOceanMax;
@@ -552,25 +562,26 @@ protected:
/** A filter that adds an edge biome group between two biome groups that need an edge between them. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenBiomeGroupEdges :
class cIntGenBiomeGroupEdges:
public cIntGen<SizeX, SizeZ>
{
typedef cIntGen<SizeX, SizeZ> super;
using Super = cIntGen<SizeX, SizeZ>;
static const int m_UnderlyingSizeX = SizeX + 2;
static const int m_UnderlyingSizeZ = SizeZ + 2;
public:
typedef std::shared_ptr<cIntGen<m_UnderlyingSizeX, m_UnderlyingSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<m_UnderlyingSizeX, m_UnderlyingSizeZ>>;
cIntGenBiomeGroupEdges(Underlying a_Underlying) :
cIntGenBiomeGroupEdges(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values)
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values)
{
// Generate the underlying biome groups:
int lowerValues[m_UnderlyingSizeX * m_UnderlyingSizeZ];
@@ -653,23 +664,24 @@ protected:
For each pixel, takes its biome group and chooses a random biome from that group; replaces the value with
that biome. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenBiomes :
class cIntGenBiomes:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenBiomes(int a_Seed, Underlying a_Underlying) :
super(a_Seed),
cIntGenBiomes(int a_Seed, Underlying a_Underlying):
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Define the per-biome-group biomes:
static const int oceanBiomes[] =
@@ -755,7 +767,7 @@ public:
const cBiomesInGroups & Biomes = (val > bgfRare) ?
rareBiomesInGroups[(val & (bgfRare - 1)) % ARRAYCOUNT(rareBiomesInGroups)] :
biomesInGroups[val % ARRAYCOUNT(biomesInGroups)];
int rnd = (super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7);
int rnd = (Super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7);
a_Values[x + IdxZ] = Biomes.Biomes[rnd % Biomes.Count];
}
}
@@ -780,17 +792,18 @@ protected:
/** Randomly replaces pixels of one value to another value, using the given chance. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenReplaceRandomly :
class cIntGenReplaceRandomly:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenReplaceRandomly(int a_From, int a_To, int a_Chance, int a_Seed, Underlying a_Underlying) :
super(a_Seed),
cIntGenReplaceRandomly(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),
@@ -799,7 +812,7 @@ public:
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying values:
m_Underlying->GetInts(a_MinX, a_MinZ, a_Values);
@@ -813,7 +826,7 @@ public:
int idx = x + idxZ;
if (a_Values[idx] == m_From)
{
int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
if (rnd % 1000 < m_Chance)
{
a_Values[idx] = m_To;
@@ -849,10 +862,11 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenMixRivers:
public cIntGen<SizeX, SizeZ>
{
typedef cIntGen<SizeX, SizeZ> super;
using Super = cIntGen<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenMixRivers(Underlying a_Biomes, Underlying a_Rivers):
@@ -862,11 +876,11 @@ public:
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying data:
m_Biomes->GetInts(a_MinX, a_MinZ, a_Values);
typename super::Values riverData;
typename Super::Values riverData;
m_Rivers->GetInts(a_MinX, a_MinZ, riverData);
// Mix the values:
@@ -916,22 +930,24 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenRiver:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
static const int UnderlyingSizeX = SizeX + 2;
static const int UnderlyingSizeZ = SizeZ + 2;
public:
typedef std::shared_ptr<cIntGen<UnderlyingSizeX, UnderlyingSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<UnderlyingSizeX, UnderlyingSizeZ>>;
cIntGenRiver(int a_Seed, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying data:
int Cache[UnderlyingSizeX * UnderlyingSizeZ];
@@ -975,16 +991,18 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenAddToOcean:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
static const int UnderlyingSizeX = SizeX + 2;
static const int UnderlyingSizeZ = SizeZ + 2;
public:
typedef std::shared_ptr<cIntGen<UnderlyingSizeX, UnderlyingSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<UnderlyingSizeX, UnderlyingSizeZ>>;
cIntGenAddToOcean(int a_Seed, int a_Chance, int a_ToValue, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Chance(a_Chance),
m_ToValue(a_ToValue),
m_Underlying(a_Underlying)
@@ -992,7 +1010,7 @@ public:
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying data:
int Cache[UnderlyingSizeX * UnderlyingSizeZ];
@@ -1036,7 +1054,7 @@ public:
// 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)
((Super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7) % 1000 < m_Chance)
)
{
a_Values[x + z * SizeX] = m_ToValue;
@@ -1065,16 +1083,18 @@ protected:
/** Changes random pixels of the underlying data to the specified value. */
template <int SizeX, int SizeZ = SizeX>
class cIntGenSetRandomly :
class cIntGenSetRandomly:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
cIntGenSetRandomly(int a_Seed, int a_Chance, int a_ToValue, Underlying a_Underlying) :
super(a_Seed),
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenSetRandomly(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)
@@ -1082,7 +1102,7 @@ public:
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying data:
m_Underlying->GetInts(a_MinX, a_MinZ, a_Values);
@@ -1092,7 +1112,7 @@ public:
{
for (int x = 0; x < SizeX; x++)
{
int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
if (rnd % 1000 < m_Chance)
{
a_Values[x + z * SizeX] = m_ToValue;
@@ -1120,21 +1140,22 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenRareBiomeGroups:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenRareBiomeGroups(int a_Seed, int a_Chance, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Chance(a_Chance),
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying data:
m_Underlying->GetInts(a_MinX, a_MinZ, a_Values);
@@ -1144,7 +1165,7 @@ public:
{
for (int x = 0; x < SizeX; x++)
{
int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
if (rnd % 1000 < m_Chance)
{
int idx = x + SizeX * z;
@@ -1172,25 +1193,26 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenAlternateBiomes:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenAlternateBiomes(int a_Seed, Underlying a_Alterations, Underlying a_BaseBiomes):
super(a_Seed),
Super(a_Seed),
m_Alterations(a_Alterations),
m_BaseBiomes(a_BaseBiomes)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the base biomes and the alterations:
m_BaseBiomes->GetInts(a_MinX, a_MinZ, a_Values);
typename super::Values alterations;
typename Super::Values alterations;
m_Alterations->GetInts(a_MinX, a_MinZ, alterations);
// Change the biomes into their alternate versions:
@@ -1240,22 +1262,24 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenBiomeEdges:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
static const int m_LowerSizeX = SizeX + 2;
static const int m_LowerSizeZ = SizeZ + 2;
public:
typedef std::shared_ptr<cIntGen<m_LowerSizeX, m_LowerSizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<m_LowerSizeX, m_LowerSizeZ>>;
cIntGenBiomeEdges(int a_Seed, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying biomes:
typename Underlying::element_type::Values lowerValues;
@@ -1402,25 +1426,26 @@ template <int SizeX, int SizeZ = SizeX>
class cIntGenMBiomes:
public cIntGenWithNoise<SizeX, SizeZ>
{
typedef cIntGenWithNoise<SizeX, SizeZ> super;
using Super = cIntGenWithNoise<SizeX, SizeZ>;
public:
typedef std::shared_ptr<cIntGen<SizeX, SizeZ>> Underlying;
using Underlying = std::shared_ptr<cIntGen<SizeX, SizeZ>>;
cIntGenMBiomes(int a_Seed, Underlying a_Alteration, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Underlying(a_Underlying),
m_Alteration(a_Alteration)
{
}
virtual void GetInts(int a_MinX, int a_MinZ, typename super::Values & a_Values) override
virtual void GetInts(int a_MinX, int a_MinZ, typename Super::Values & a_Values) override
{
// Generate the underlying biomes and the alterations:
m_Underlying->GetInts(a_MinX, a_MinZ, a_Values);
typename super::Values alterations;
typename Super::Values alterations;
m_Alteration->GetInts(a_MinX, a_MinZ, alterations);
// Wherever alterations are nonzero, change into alternate biome, if available:

45
src/Generating/MineShafts.cpp
View File

@@ -81,18 +81,19 @@ public:
virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) = 0;
} ;
typedef std::vector<cMineShaft *> cMineShafts;
using cMineShafts = std::vector<cMineShaft *>;
class cMineShaftDirtRoom :
class cMineShaftDirtRoom:
public cMineShaft
{
typedef cMineShaft super;
using Super = cMineShaft;
public:
cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise);
// cMineShaft overrides:
@@ -104,16 +105,16 @@ public:
class cMineShaftCorridor :
class cMineShaftCorridor:
public cMineShaft
{
typedef cMineShaft super;
using Super = cMineShaft;
public:
/** Creates a new Corridor attached to the specified pivot point and direction.
Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
May return nullptr if cannot fit.
*/
May return nullptr if cannot fit. */
static cMineShaft * CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
@@ -157,16 +158,16 @@ protected:
class cMineShaftCrossing :
class cMineShaftCrossing:
public cMineShaft
{
typedef cMineShaft super;
using Super = cMineShaft;
public:
/** Creates a new Crossing attached to the specified pivot point and direction.
Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
May return nullptr if cannot fit.
*/
May return nullptr if cannot fit. */
static cMineShaft * CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
@@ -185,12 +186,13 @@ protected:
class cMineShaftStaircase :
class cMineShaftStaircase:
public cMineShaft
{
typedef cMineShaft super;
using Super = cMineShaft;
public:
enum eSlope
{
sUp,
@@ -228,12 +230,13 @@ protected:
class cStructGenMineShafts::cMineShaftSystem :
class cStructGenMineShafts::cMineShaftSystem:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
public:
int m_GridSize; ///< Maximum offset of the dirtroom from grid center, * 2, in each direction
int m_MaxRecursion; ///< Maximum recursion level (initialized from cStructGenMineShafts::m_MaxRecursion)
int m_ProbLevelCorridor; ///< Probability level of a branch object being the corridor
@@ -283,7 +286,7 @@ cStructGenMineShafts::cMineShaftSystem::cMineShaftSystem(
int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
m_GridSize(a_GridSize),
m_MaxRecursion(8), // TODO: settable
m_ProbLevelCorridor(a_ProbLevelCorridor),
@@ -404,7 +407,7 @@ bool cStructGenMineShafts::cMineShaftSystem::CanAppend(const cCuboid & a_Boundin
// cMineShaftDirtRoom:
cMineShaftDirtRoom::cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise) :
super(a_Parent, mskDirtRoom)
Super(a_Parent, mskDirtRoom)
{
// Make the room of random size, min 10 x 4 x 10; max 18 x 12 x 18:
int rnd = a_Noise.IntNoise3DInt(a_Parent.m_OriginX, 0, a_Parent.m_OriginZ) / 7;
@@ -500,7 +503,7 @@ cMineShaftCorridor::cMineShaftCorridor(
const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,
cNoise & a_Noise
) :
super(a_ParentSystem, mskCorridor, a_BoundingBox),
Super(a_ParentSystem, mskCorridor, a_BoundingBox),
m_NumSegments(a_NumSegments),
m_Direction(a_Direction),
m_ChestPosition(-1),
@@ -973,7 +976,7 @@ void cMineShaftCorridor::PlaceTorches(cChunkDesc & a_ChunkDesc)
// cMineShaftCrossing:
cMineShaftCrossing::cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox) :
super(a_ParentSystem, mskCrossing, a_BoundingBox)
Super(a_ParentSystem, mskCrossing, a_BoundingBox)
{
}
@@ -1113,7 +1116,7 @@ cMineShaftStaircase::cMineShaftStaircase(
eDirection a_Direction,
eSlope a_Slope
) :
super(a_ParentSystem, mskStaircase, a_BoundingBox),
Super(a_ParentSystem, mskStaircase, a_BoundingBox),
m_Direction(a_Direction),
m_Slope(a_Slope)
{
@@ -1289,7 +1292,7 @@ cStructGenMineShafts::cStructGenMineShafts(
int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxSystemSize,
int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
) :
super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSystemSize, a_MaxSystemSize, 100),
Super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSystemSize, a_MaxSystemSize, 100),
m_GridSize(a_GridSize),
m_MaxSystemSize(a_MaxSystemSize),
m_ProbLevelCorridor(std::max(0, a_ChanceCorridor)),

2
src/Generating/MineShafts.h
View File

@@ -18,7 +18,7 @@
class cStructGenMineShafts :
public cGridStructGen
{
typedef cGridStructGen super;
typedef cGridStructGen Super;
public:
cStructGenMineShafts(

5
src/Generating/Noise3DGenerator.h
View File

@@ -20,12 +20,13 @@
class cNoise3DGenerator :
class cNoise3DGenerator:
public cChunkGenerator
{
typedef cChunkGenerator Super;
using Super = cChunkGenerator;
public:
cNoise3DGenerator();
virtual ~cNoise3DGenerator() override;

3
src/Generating/PieceStructuresGen.cpp
View File

@@ -17,9 +17,10 @@
class cPieceStructuresGen::cGen:
public cGridStructGen
{
typedef cGridStructGen Super;
using Super = cGridStructGen;
public:
cGen(int a_Seed, cBiomeGenPtr a_BiomeGen, cTerrainHeightGenPtr a_HeightGen, int a_SeaLevel, const AString & a_Name):
Super(a_Seed),
m_BiomeGen(a_BiomeGen),

5
src/Generating/PieceStructuresGen.h
View File

@@ -21,12 +21,13 @@ cPieceGenerator instance.
class cPieceStructuresGen :
class cPieceStructuresGen:
public cFinishGen
{
typedef cFinishGen Super;
using Super = cFinishGen;
public:
cPieceStructuresGen(int a_Seed);
/** Initializes the generator based on the specified prefab sets.

3
src/Generating/PrefabStructure.h
View File

@@ -19,9 +19,10 @@
class cPrefabStructure:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure Super;
using Super = cGridStructGen::cStructure;
public:
cPrefabStructure(
int a_GridX, int a_GridZ,
int a_OriginX, int a_OriginZ,

225
src/Generating/ProtIntGen.h
View File

@@ -51,7 +51,7 @@ protected:
public:
/** Type of the generic interface used for storing links to the underlying generators. */
typedef std::shared_ptr<cProtIntGen> Underlying;
using Underlying = std::shared_ptr<cProtIntGen>;
/** Force a virtual destructor in all descendants.
@@ -67,13 +67,14 @@ public:
/** Provides additional cNoise member and its helper functions. */
class cProtIntGenWithNoise :
class cProtIntGenWithNoise:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenWithNoise(int a_Seed) :
cProtIntGenWithNoise(int a_Seed):
m_Noise(a_Seed)
{
}
@@ -107,14 +108,15 @@ protected:
/** Generates a 2D array of random integers in the specified range [0 .. Range). */
class cProtIntGenChoice :
class cProtIntGenChoice:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenChoice(int a_Seed, int a_Range) :
super(a_Seed),
cProtIntGenChoice(int a_Seed, int a_Range):
Super(a_Seed),
m_Range(a_Range)
{
}
@@ -127,7 +129,7 @@ public:
int BaseZ = a_MinZ + static_cast<int>(z);
for (size_t x = 0; x < a_SizeX; x++)
{
a_Values[x + a_SizeX * z] = (super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7) % m_Range;
a_Values[x + a_SizeX * z] = (Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7) % m_Range;
}
} // for z
}
@@ -143,14 +145,15 @@ protected:
/** 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 :
class cProtIntGenLandOcean:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenLandOcean(int a_Seed, int a_Threshold) :
super(a_Seed),
cProtIntGenLandOcean(int a_Seed, int a_Threshold):
Super(a_Seed),
m_Threshold(a_Threshold)
{
}
@@ -163,7 +166,7 @@ public:
int BaseZ = a_MinZ + static_cast<int>(z);
for (size_t x = 0; x < a_SizeX; x++)
{
int rnd = (super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7);
int rnd = (Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7);
a_Values[x + a_SizeX * z] = ((rnd % 100) < m_Threshold) ? ((rnd / 101) % bgLandOceanMax + 1) : 0;
}
}
@@ -186,14 +189,15 @@ protected:
/** Zooms the underlying value array to twice the size. Uses random-neighbor for the pixels in-between.
This means that the zoome out image is randomly distorted. Applying zoom several times provides all
the distortion that the generators need. */
class cProtIntGenZoom :
class cProtIntGenZoom:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenZoom(int a_Seed, Underlying a_UnderlyingGen) :
super(a_Seed),
cProtIntGenZoom(int a_Seed, Underlying a_UnderlyingGen):
Super(a_Seed),
m_UnderlyingGen(a_UnderlyingGen)
{
}
@@ -230,9 +234,9 @@ public:
int RndX = (static_cast<int>(x) + lowerMinX) * 2;
int RndZ = (static_cast<int>(z) + lowerMinZ) * 2;
cache[idx] = PrevZ0;
cache[idx + lowStepX] = super::chooseRandomOne(RndX, RndZ + 1, PrevZ0, PrevZ1);
cache[idx + 1] = super::chooseRandomOne(RndX, RndZ - 1, PrevZ0, ValX1Z0);
cache[idx + 1 + lowStepX] = super::chooseRandomOne(RndX, RndZ, PrevZ0, ValX1Z0, PrevZ1, ValX1Z1);
cache[idx + lowStepX] = Super::chooseRandomOne(RndX, RndZ + 1, PrevZ0, PrevZ1);
cache[idx + 1] = Super::chooseRandomOne(RndX, RndZ - 1, PrevZ0, ValX1Z0);
cache[idx + 1 + lowStepX] = Super::chooseRandomOne(RndX, RndZ, PrevZ0, ValX1Z0, PrevZ1, ValX1Z1);
idx += 2;
PrevZ0 = ValX1Z0;
PrevZ1 = ValX1Z1;
@@ -256,14 +260,15 @@ protected:
/** Smoothes out some artifacts generated by the zooming - mostly single-pixel values.
Compares each pixel to its neighbors and if the neighbors are equal, changes the pixel to their value. */
class cProtIntGenSmooth :
class cProtIntGenSmooth:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenSmooth(int a_Seed, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenSmooth(int a_Seed, Underlying a_Underlying):
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
@@ -293,7 +298,7 @@ public:
if ((left == right) && (above == below))
{
if (((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 2) == 0)
if (((Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 2) == 0)
{
val = left;
}
@@ -329,13 +334,14 @@ protected:
/** Averages the values of the underlying 2 * 2 neighbors. */
class cProtIntGenAvgValues :
class cProtIntGenAvgValues:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenAvgValues(Underlying a_Underlying) :
cProtIntGenAvgValues(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
@@ -373,13 +379,14 @@ protected:
/** Averages the values of the underlying 4 * 4 neighbors. */
class cProtIntGenAvg4Values :
class cProtIntGenAvg4Values:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenAvg4Values(Underlying a_Underlying) :
cProtIntGenAvg4Values(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
@@ -423,13 +430,14 @@ protected:
/** Averages the values of the underlying 3 * 3 neighbors with custom weight. */
template <int WeightCenter, int WeightCardinal, int WeightDiagonal>
class cProtIntGenWeightAvg :
class cProtIntGenWeightAvg:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenWeightAvg(Underlying a_Underlying) :
cProtIntGenWeightAvg(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
@@ -470,14 +478,15 @@ protected:
/** Replaces random values of the underlying data with random integers in the specified range [Min .. Min + Range). */
class cProtIntGenRndChoice :
class cProtIntGenRndChoice:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenRndChoice(int a_Seed, int a_ChancePct, int a_Min, int a_Range, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenRndChoice(int a_Seed, int a_ChancePct, int a_Min, int a_Range, Underlying a_Underlying):
Super(a_Seed),
m_ChancePct(a_ChancePct),
m_Min(a_Min),
m_Range(a_Range),
@@ -497,9 +506,9 @@ public:
int BaseZ = a_MinZ + static_cast<int>(z);
for (size_t x = 0; x < a_SizeX; x++)
{
if (((super::m_Noise.IntNoise2DInt(BaseZ, a_MinX + static_cast<int>(x)) / 13) % 101) < m_ChancePct)
if (((Super::m_Noise.IntNoise2DInt(BaseZ, a_MinX + static_cast<int>(x)) / 13) % 101) < m_ChancePct)
{
a_Values[x + a_SizeX * z] = m_Min + (super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7) % m_Range;
a_Values[x + a_SizeX * z] = m_Min + (Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7) % m_Range;
}
} // for x
} // for z
@@ -517,14 +526,15 @@ protected:
/** Adds a random value in range [-a_HalfRange, +a_HalfRange] to each of the underlying values. */
class cProtIntGenAddRnd :
class cProtIntGenAddRnd:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenAddRnd(int a_Seed, int a_HalfRange, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenAddRnd(int a_Seed, int a_HalfRange, Underlying a_Underlying):
Super(a_Seed),
m_Range(a_HalfRange * 2 + 1),
m_HalfRange(a_HalfRange),
m_Underlying(a_Underlying)
@@ -543,7 +553,7 @@ public:
int NoiseZ = a_MinZ + static_cast<int>(z);
for (size_t x = 0; x < a_SizeX; x++)
{
int noiseVal = ((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % m_Range) - m_HalfRange;
int noiseVal = ((Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % m_Range) - m_HalfRange;
a_Values[x + z * a_SizeX] += noiseVal;
}
}
@@ -560,14 +570,15 @@ protected:
/** Replaces random underlying values with the average of the neighbors. */
class cProtIntGenRndAvg :
class cProtIntGenRndAvg:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenRndAvg(int a_Seed, int a_AvgChancePct, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenRndAvg(int a_Seed, int a_AvgChancePct, Underlying a_Underlying):
Super(a_Seed),
m_AvgChancePct(a_AvgChancePct),
m_Underlying(a_Underlying)
{
@@ -590,7 +601,7 @@ public:
for (size_t x = 0; x < a_SizeX; x++)
{
size_t idxLower = x + 1 + lowerSizeX * (z + 1);
if (((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 100) > m_AvgChancePct)
if (((Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 100) > m_AvgChancePct)
{
// Average the 4 neighbors:
a_Values[x + z * a_SizeX] = (
@@ -617,14 +628,15 @@ protected:
/** Replaces random underlying values with a random value in between the max and min of the neighbors. */
class cProtIntGenRndBetween :
class cProtIntGenRndBetween:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenRndBetween(int a_Seed, int a_AvgChancePct, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenRndBetween(int a_Seed, int a_AvgChancePct, Underlying a_Underlying):
Super(a_Seed),
m_AvgChancePct(a_AvgChancePct),
m_Underlying(a_Underlying)
{
@@ -647,12 +659,12 @@ public:
for (size_t x = 0; x < a_SizeX; x++)
{
size_t idxLower = x + 1 + lowerSizeX * (z + 1);
if (((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 100) > m_AvgChancePct)
if (((Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 100) > m_AvgChancePct)
{
// Chose a value in between the min and max neighbor:
int min = std::min(std::min(lowerData[idxLower - 1], lowerData[idxLower + 1]), std::min(lowerData[idxLower - lowerSizeX], lowerData[idxLower + lowerSizeX]));
int max = std::max(std::max(lowerData[idxLower - 1], lowerData[idxLower + 1]), std::max(lowerData[idxLower - lowerSizeX], lowerData[idxLower + lowerSizeX]));
a_Values[x + z * a_SizeX] = min + ((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ + 10) / 7) % (max - min + 1));
a_Values[x + z * a_SizeX] = min + ((Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ + 10) / 7) % (max - min + 1));
}
else
{
@@ -673,13 +685,14 @@ protected:
/** Converts land biomes at the edge of an ocean into the respective beach biome. */
class cProtIntGenBeaches :
class cProtIntGenBeaches:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenBeaches(Underlying a_Underlying) :
cProtIntGenBeaches(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
@@ -772,17 +785,18 @@ protected:
/** Generates the underlying numbers and then randomly changes some ocean group pixels into random land
biome group pixels, based on the predefined chance. */
class cProtIntGenAddIslands :
class cProtIntGenAddIslands:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
typedef std::shared_ptr<cProtIntGen> Underlying;
using Underlying = std::shared_ptr<cProtIntGen>;
cProtIntGenAddIslands(int a_Seed, int a_Chance, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenAddIslands(int a_Seed, int a_Chance, Underlying a_Underlying):
Super(a_Seed),
m_Chance(a_Chance),
m_Underlying(a_Underlying)
{
@@ -798,7 +812,7 @@ public:
{
if (a_Values[x + z * a_SizeX] == bgOcean)
{
int rnd = super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), a_MinZ + static_cast<int>(z)) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), a_MinZ + static_cast<int>(z)) / 7;
if (rnd % 1000 < m_Chance)
{
a_Values[x + z * a_SizeX] = (rnd / 1003) % bgLandOceanMax;
@@ -820,13 +834,14 @@ protected:
/** A filter that adds an edge biome group between two biome groups that need an edge between them. */
class cProtIntGenBiomeGroupEdges :
class cProtIntGenBiomeGroupEdges:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenBiomeGroupEdges(Underlying a_Underlying) :
cProtIntGenBiomeGroupEdges(Underlying a_Underlying):
m_Underlying(a_Underlying)
{
}
@@ -917,14 +932,15 @@ protected:
/** 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 :
class cProtIntGenBiomes:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenBiomes(int a_Seed, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenBiomes(int a_Seed, Underlying a_Underlying):
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
@@ -1017,7 +1033,7 @@ public:
const cBiomesInGroups & Biomes = (val > bgfRare) ?
rareBiomesInGroups[(val & (bgfRare - 1)) % ARRAYCOUNT(rareBiomesInGroups)] :
biomesInGroups[static_cast<size_t>(val) % ARRAYCOUNT(biomesInGroups)];
int rnd = (super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7);
int rnd = (Super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7);
a_Values[x + IdxZ] = Biomes.Biomes[rnd % Biomes.Count];
}
}
@@ -1041,17 +1057,18 @@ protected:
/** Randomly replaces pixels of one value to another value, using the given chance. */
class cProtIntGenReplaceRandomly :
class cProtIntGenReplaceRandomly:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
typedef std::shared_ptr<cProtIntGen> Underlying;
using Underlying = std::shared_ptr<cProtIntGen>;
cProtIntGenReplaceRandomly(int a_Seed, int a_From, int a_To, int a_Chance, Underlying a_Underlying) :
super(a_Seed),
cProtIntGenReplaceRandomly(int a_Seed, int a_From, int a_To, int a_Chance, Underlying a_Underlying):
Super(a_Seed),
m_From(a_From),
m_To(a_To),
m_Chance(a_Chance),
@@ -1074,7 +1091,7 @@ public:
size_t idx = x + idxZ;
if (a_Values[idx] == m_From)
{
int rnd = super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
if (rnd % 1000 < m_Chance)
{
a_Values[idx] = m_To;
@@ -1109,9 +1126,10 @@ regular river or frozen river, based on the biome. */
class cProtIntGenMixRivers:
public cProtIntGen
{
typedef cProtIntGen super;
using Super = cProtIntGen;
public:
cProtIntGenMixRivers(Underlying a_Biomes, Underlying a_Rivers):
m_Biomes(a_Biomes),
m_Rivers(a_Rivers)
@@ -1173,11 +1191,12 @@ data changes from one pixel to its neighbor. */
class cProtIntGenRiver:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenRiver(int a_Seed, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
@@ -1229,11 +1248,12 @@ The biome is only placed if at least 3 of its neighbors are ocean and only with
class cProtIntGenAddToOcean:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenAddToOcean(int a_Seed, int a_Chance, int a_ToValue, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Chance(a_Chance),
m_ToValue(a_ToValue),
m_Underlying(a_Underlying)
@@ -1288,7 +1308,7 @@ public:
// If at least 3 ocean neighbors and the chance is right, change:
if (
(NumOceanNeighbors >= 3) &&
((super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7) % 1000 < m_Chance)
((Super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7) % 1000 < m_Chance)
)
{
a_Values[x + z * a_SizeX] = m_ToValue;
@@ -1316,14 +1336,15 @@ protected:
/** Changes random pixels of the underlying data to the specified value. */
class cProtIntGenSetRandomly :
class cProtIntGenSetRandomly:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenSetRandomly(int a_Seed, int a_Chance, int a_ToValue, Underlying a_Underlying) :
super(a_Seed),
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)
@@ -1341,7 +1362,7 @@ public:
{
for (size_t x = 0; x < a_SizeX; x++)
{
int rnd = super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
if (rnd % 1000 < m_Chance)
{
a_Values[x + z * a_SizeX] = m_ToValue;
@@ -1368,11 +1389,12 @@ protected:
class cProtIntGenRareBiomeGroups:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenRareBiomeGroups(int a_Seed, int a_Chance, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Chance(a_Chance),
m_Underlying(a_Underlying)
{
@@ -1389,7 +1411,7 @@ public:
{
for (size_t x = 0; x < a_SizeX; x++)
{
int rnd = super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
int rnd = Super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
if (rnd % 1000 < m_Chance)
{
size_t idx = x + a_SizeX * z;
@@ -1416,11 +1438,12 @@ that have their alterations set. */
class cProtIntGenAlternateBiomes:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenAlternateBiomes(int a_Seed, Underlying a_Alterations, Underlying a_BaseBiomes):
super(a_Seed),
Super(a_Seed),
m_Alterations(a_Alterations),
m_BaseBiomes(a_BaseBiomes)
{
@@ -1481,11 +1504,12 @@ protected:
class cProtIntGenBiomeEdges:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenBiomeEdges(int a_Seed, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Underlying(a_Underlying)
{
}
@@ -1640,11 +1664,12 @@ have their alterations set. */
class cProtIntGenMBiomes:
public cProtIntGenWithNoise
{
typedef cProtIntGenWithNoise super;
using Super = cProtIntGenWithNoise;
public:
cProtIntGenMBiomes(int a_Seed, Underlying a_Alteration, Underlying a_Underlying):
super(a_Seed),
Super(a_Seed),
m_Underlying(a_Underlying),
m_Alteration(a_Alteration)
{

10
src/Generating/Ravines.cpp
View File

@@ -33,16 +33,16 @@ struct cRavDefPoint
}
} ;
typedef std::vector<cRavDefPoint> cRavDefPoints;
using cRavDefPoints = std::vector<cRavDefPoint>;
class cStructGenRavines::cRavine :
class cStructGenRavines::cRavine:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
cRavDefPoints m_Points;
@@ -81,7 +81,7 @@ protected:
// cStructGenRavines:
cStructGenRavines::cStructGenRavines(int a_Seed, int a_Size) :
super(a_Seed, a_Size, a_Size, a_Size, a_Size, a_Size * 2, a_Size * 2, 100),
Super(a_Seed, a_Size, a_Size, a_Size, a_Size, a_Size * 2, a_Size * 2, 100),
m_Size(a_Size)
{
}
@@ -103,7 +103,7 @@ cGridStructGen::cStructurePtr cStructGenRavines::CreateStructure(int a_GridX, in
// cStructGenRavines::cRavine
cStructGenRavines::cRavine::cRavine(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ, int a_Size, cNoise & a_Noise) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ)
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ)
{
// Calculate the ravine shape-defining points:
GenerateBaseDefPoints(a_OriginX, a_OriginZ, a_Size, a_Noise);

7
src/Generating/Ravines.h
View File

@@ -15,18 +15,19 @@
class cStructGenRavines :
class cStructGenRavines:
public cGridStructGen
{
typedef cGridStructGen super;
using Super = cGridStructGen;
public:
cStructGenRavines(int a_Seed, int a_Size);
protected:
class cRavine; // fwd: Ravines.cpp
int m_Size; // Max size, in blocks, of the ravines generated
int m_Size; // Max size, in blocks, of the ravines generated
// cGridStructGen overrides:

13
src/Generating/RoughRavines.cpp
View File

@@ -15,20 +15,21 @@
////////////////////////////////////////////////////////////////////////////////
// cRoughRavine:
class cRoughRavine :
class cRoughRavine:
public cGridStructGen::cStructure
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
public:
cRoughRavine(
int a_Seed, size_t a_Size,
float a_CenterWidth, float a_Roughness,
float a_FloorHeightEdge1, float a_FloorHeightEdge2, float a_FloorHeightCenter,
float a_CeilingHeightEdge1, float a_CeilingHeightEdge2, float a_CeilingHeightCenter,
int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ
) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
):
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
m_Seed(a_Seed + 100),
m_Noise(a_Seed + 100),
m_Roughness(a_Roughness)
@@ -72,7 +73,7 @@ protected:
m_Bottom = a_Bottom;
}
};
typedef std::vector<sRavineDefPoint> sRavineDefPoints;
using sRavineDefPoints = std::vector<sRavineDefPoint>;
int m_Seed;
@@ -231,7 +232,7 @@ cRoughRavines::cRoughRavines(
float a_MaxCeilingHeightCenter, float a_MinCeilingHeightCenter,
int a_GridSize, int a_MaxOffset
) :
super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 64),
Super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 64),
m_MaxSize(a_MaxSize),
m_MinSize(a_MinSize),
m_MaxCenterWidth(a_MaxCenterWidth),

5
src/Generating/RoughRavines.h
View File

@@ -14,12 +14,13 @@
class cRoughRavines :
class cRoughRavines:
public cGridStructGen
{
typedef cGridStructGen super;
using Super = cGridStructGen;
public:
cRoughRavines(
int a_Seed,
int a_MaxSize, int a_MinSize,

4
src/Generating/TwoHeights.cpp
View File

@@ -17,8 +17,10 @@
class cTwoHeights:
public cTerrainShapeGen
{
typedef cTerrainShapeGen super;
using Super = cTerrainShapeGen;
public:
cTwoHeights(int a_Seed, cBiomeGenPtr a_BiomeGen):
m_Seed(a_Seed),
m_Choice(a_Seed),

21
src/Generating/VillageGen.cpp
View File

@@ -37,16 +37,18 @@ per-village density setting, the cVillage class itself implements the cPiecePool
calls to the underlying cVillagePiecePool, after processing the density check.
*/
class cVillagePiecePool :
class cVillagePiecePool:
public cPrefabPiecePool
{
typedef cPrefabPiecePool super;
using Super = cPrefabPiecePool;
public:
cVillagePiecePool(
const cPrefab::sDef * a_PieceDefs, size_t a_NumPieceDefs,
const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs
) :
super(a_PieceDefs, a_NumPieceDefs, a_StartingPieceDefs, a_NumStartingPieceDefs)
):
Super(a_PieceDefs, a_NumPieceDefs, a_StartingPieceDefs, a_NumStartingPieceDefs)
{
AddRoadPieces();
}
@@ -107,13 +109,14 @@ public:
class cVillageGen::cVillage :
class cVillageGen::cVillage:
public cGridStructGen::cStructure,
protected cPiecePool
{
typedef cGridStructGen::cStructure super;
using Super = cGridStructGen::cStructure;
public:
cVillage(
int a_Seed,
int a_GridX, int a_GridZ,
@@ -123,8 +126,8 @@ public:
int a_Density,
cVillagePiecePool & a_Prefabs,
cTerrainHeightGenPtr a_HeightGen
) :
super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
):
Super(a_GridX, a_GridZ, a_OriginX, a_OriginZ),
m_Seed(a_Seed),
m_Noise(a_Seed),
m_MaxSize(a_MaxSize),
@@ -339,7 +342,7 @@ cVillageGen::cVillageGen(
int a_SeaLevel,
const AStringVector & a_PrefabsToLoad
) :
super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 100),
Super(a_Seed, a_GridSize, a_GridSize, a_MaxOffset, a_MaxOffset, a_MaxSize, a_MaxSize, 100),
m_RandNoise(a_Seed + 1000),
m_MaxDepth(a_MaxDepth),
m_MaxSize(a_MaxSize),

6
src/Generating/VillageGen.h
View File

@@ -23,11 +23,13 @@ class cVillagePiecePool;
class cVillageGen :
class cVillageGen:
public cGridStructGen
{
typedef cGridStructGen super;
using Super = cGridStructGen;
public:
/** Creates a new instance of the generator with the specified parameters. */
cVillageGen(
int a_Seed,