summaryrefslogtreecommitdiffstats
path: root/src/Generating/MineShafts.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/Generating/MineShafts.cpp')
-rw-r--r--src/Generating/MineShafts.cpp754
1 files changed, 549 insertions, 205 deletions
diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index 189b28095..265fb79d4 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -28,14 +28,14 @@ in a depth-first processing. Each of the descendants will branch randomly, if no
class cMineShaft abstract
{
-public:
+ public:
enum eKind
{
mskDirtRoom,
mskCorridor,
mskCrossing,
mskStaircase,
- } ;
+ };
enum eDirection
@@ -44,34 +44,28 @@ public:
dirZP,
dirXM,
dirZM,
- } ;
+ };
cStructGenMineShafts::cMineShaftSystem & m_ParentSystem;
- eKind m_Kind;
+ eKind m_Kind;
cCuboid m_BoundingBox;
cMineShaft(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, eKind a_Kind) :
- m_ParentSystem(a_ParentSystem),
- m_Kind(a_Kind)
+ m_ParentSystem(a_ParentSystem), m_Kind(a_Kind)
{
}
cMineShaft(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, eKind a_Kind, const cCuboid & a_BoundingBox) :
- m_ParentSystem(a_ParentSystem),
- m_Kind(a_Kind),
- m_BoundingBox(a_BoundingBox)
+ m_ParentSystem(a_ParentSystem), m_Kind(a_Kind), m_BoundingBox(a_BoundingBox)
{
}
virtual ~cMineShaft() {}
/** Returns true if this mineshaft intersects the specified cuboid */
- bool DoesIntersect(const cCuboid & a_Other)
- {
- return m_BoundingBox.DoesIntersect(a_Other);
- }
+ bool DoesIntersect(const cCuboid & a_Other) { return m_BoundingBox.DoesIntersect(a_Other); }
/** If recursion level is not too large, appends more branches to the parent system,
using exit points specific to this class. */
@@ -79,7 +73,7 @@ public:
/** Imprints this shape into the specified chunk's data */
virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) = 0;
-} ;
+};
using cMineShafts = std::vector<cMineShaft *>;
@@ -87,53 +81,57 @@ using cMineShafts = std::vector<cMineShaft *>;
-class cMineShaftDirtRoom:
- public cMineShaft
+class cMineShaftDirtRoom : public cMineShaft
{
using Super = cMineShaft;
-public:
-
+ public:
cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem & a_Parent, cNoise & a_Noise);
// cMineShaft overrides:
virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
-} ;
+};
-class cMineShaftCorridor:
- public cMineShaft
+class cMineShaftCorridor : public cMineShaft
{
using Super = cMineShaft;
-public:
-
+ 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. */
static cMineShaft * CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ eDirection a_Direction,
cNoise & a_Noise
);
-protected:
+ protected:
static const int MAX_SEGMENTS = 5;
- int m_NumSegments;
+ int m_NumSegments;
eDirection m_Direction;
- bool m_HasFullBeam[MAX_SEGMENTS]; ///< If true, segment at that index has a full beam support (planks in the top center block)
- int m_ChestPosition; ///< If <0, no chest; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on m_Direction
- int m_SpawnerPosition; ///< If <0, no spawner; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on m_Direction
- bool m_HasTracks; ///< If true, random tracks will be placed on the floor
+ bool m_HasFullBeam[MAX_SEGMENTS]; ///< If true, segment at that index has a full beam support (planks in the top
+ ///< center block)
+ int m_ChestPosition; ///< If <0, no chest; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on
+ ///< m_Direction
+ int m_SpawnerPosition; ///< If <0, no spawner; otherwise an offset from m_BoundingBox's p1.x or p1.z, depenging on
+ ///< m_Direction
+ bool m_HasTracks; ///< If true, random tracks will be placed on the floor
cMineShaftCorridor(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,
+ const cCuboid & a_BoundingBox,
+ int a_NumSegments,
+ eDirection a_Direction,
cNoise & a_Noise
);
@@ -152,52 +150,51 @@ protected:
/** Randomly places torches around the central beam block */
void PlaceTorches(cChunkDesc & a_ChunkDesc);
-} ;
+};
-class cMineShaftCrossing:
- public cMineShaft
+class cMineShaftCrossing : public cMineShaft
{
using Super = cMineShaft;
-public:
-
+ 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. */
static cMineShaft * CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ eDirection a_Direction,
cNoise & a_Noise
);
-protected:
+ protected:
cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox);
// cMineShaft overrides:
virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
-} ;
+};
-class cMineShaftStaircase:
- public cMineShaft
+class cMineShaftStaircase : public cMineShaft
{
using Super = cMineShaft;
-public:
-
+ public:
enum eSlope
{
sUp,
sDown,
- } ;
+ };
/** Creates a new Staircase attached to the specified pivot point and direction.
Checks all ParentSystem's objects and disallows intersecting. Initializes the new object to fit.
@@ -205,13 +202,16 @@ public:
*/
static cMineShaft * CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ eDirection a_Direction,
cNoise & a_Noise
);
-protected:
+ protected:
eDirection m_Direction;
- eSlope m_Slope;
+ eSlope m_Slope;
cMineShaftStaircase(
@@ -224,36 +224,41 @@ protected:
// cMineShaft overrides:
virtual void AppendBranches(int a_RecursionLevel, cNoise & a_Noise) override;
virtual void ProcessChunk(cChunkDesc & a_ChunkDesc) override;
-} ;
+};
-class cStructGenMineShafts::cMineShaftSystem:
- public cGridStructGen::cStructure
+class cStructGenMineShafts::cMineShaftSystem : public cGridStructGen::cStructure
{
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
- int m_ProbLevelCrossing; ///< Probability level of a branch object being the crossing, minus Corridor
- int m_ProbLevelStaircase; ///< Probability level of a branch object being the staircase, minus Crossing
- int m_ChanceChest; ///< Chance [0 .. 250] that a corridor has a chest in it
- int m_ChanceSpawner; ///< Chance [0 .. 250] that a corridor has a spawner in it
- int m_ChanceTorch; ///< Chance [0 .. 10k] for a torch appearing attached to a corridor's beam
- cMineShafts m_MineShafts; ///< List of cMineShaft descendants that comprise this system
- cCuboid m_BoundingBox; ///< Bounding box into which all of the components need to fit
+ 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
+ int m_ProbLevelCrossing; ///< Probability level of a branch object being the crossing, minus Corridor
+ int m_ProbLevelStaircase; ///< Probability level of a branch object being the staircase, minus Crossing
+ int m_ChanceChest; ///< Chance [0 .. 250] that a corridor has a chest in it
+ int m_ChanceSpawner; ///< Chance [0 .. 250] that a corridor has a spawner in it
+ int m_ChanceTorch; ///< Chance [0 .. 10k] for a torch appearing attached to a corridor's beam
+ cMineShafts m_MineShafts; ///< List of cMineShaft descendants that comprise this system
+ cCuboid m_BoundingBox; ///< Bounding box into which all of the components need to fit
/** Creates and generates the entire system */
cMineShaftSystem(
- int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ,
- int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
- int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
+ int a_GridX,
+ int a_GridZ,
+ int a_OriginX,
+ int a_OriginZ,
+ int a_GridSize,
+ int a_MaxSystemSize,
+ cNoise & a_Noise,
+ int a_ProbLevelCorridor,
+ int a_ProbLevelCrossing,
+ int a_ProbLevelStaircase
);
virtual ~cMineShaftSystem() override;
@@ -262,17 +267,21 @@ public:
if it fits, appends it to the list and calls its AppendBranches()
*/
void AppendBranch(
- int a_BlockX, int a_BlockY, int a_BlockZ,
- cMineShaft::eDirection a_Direction, cNoise & a_Noise,
+ int a_BlockX,
+ int a_BlockY,
+ int a_BlockZ,
+ cMineShaft::eDirection a_Direction,
+ cNoise & a_Noise,
int a_RecursionLevel
);
- /** Returns true if none of the objects in m_MineShafts intersect with the specified bounding box and the bounding box is valid */
+ /** Returns true if none of the objects in m_MineShafts intersect with the specified bounding box and the bounding
+ * box is valid */
bool CanAppend(const cCuboid & a_BoundingBox);
// cGridStructGen::cStructure overrides:
virtual void DrawIntoChunk(cChunkDesc & a_Chunk) override;
-} ;
+};
@@ -282,9 +291,16 @@ public:
// cStructGenMineShafts::cMineShaftSystem:
cStructGenMineShafts::cMineShaftSystem::cMineShaftSystem(
- int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ,
- int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
- int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
+ int a_GridX,
+ int a_GridZ,
+ int a_OriginX,
+ int a_OriginZ,
+ 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),
m_GridSize(a_GridSize),
@@ -302,7 +318,7 @@ cStructGenMineShafts::cMineShaftSystem::cMineShaftSystem(
m_MineShafts.push_back(Start);
m_BoundingBox.Assign(
- {Start->m_BoundingBox.p1.x - a_MaxSystemSize / 2, 2, Start->m_BoundingBox.p1.z - a_MaxSystemSize / 2},
+ {Start->m_BoundingBox.p1.x - a_MaxSystemSize / 2, 2, Start->m_BoundingBox.p1.z - a_MaxSystemSize / 2},
{Start->m_BoundingBox.p2.x + a_MaxSystemSize / 2, 50, Start->m_BoundingBox.p2.z + a_MaxSystemSize / 2}
);
@@ -344,8 +360,11 @@ void cStructGenMineShafts::cMineShaftSystem::DrawIntoChunk(cChunkDesc & a_Chunk)
void cStructGenMineShafts::cMineShaftSystem::AppendBranch(
- int a_PivotX, int a_PivotY, int a_PivotZ,
- cMineShaft::eDirection a_Direction, cNoise & a_Noise,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ cMineShaft::eDirection a_Direction,
+ cNoise & a_Noise,
int a_RecursionLevel
)
{
@@ -435,17 +454,45 @@ void cMineShaftDirtRoom::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
for (int x = m_BoundingBox.p1.x + 1; x < m_BoundingBox.p2.x; x += 4)
{
int rnd = a_Noise.IntNoise3DInt(x, a_RecursionLevel, m_BoundingBox.p1.z) / 7;
- m_ParentSystem.AppendBranch(x, m_BoundingBox.p1.y + (rnd % Height), m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ x,
+ m_BoundingBox.p1.y + (rnd % Height),
+ m_BoundingBox.p1.z - 1,
+ dirZM,
+ a_Noise,
+ a_RecursionLevel
+ );
rnd >>= 4;
- m_ParentSystem.AppendBranch(x, m_BoundingBox.p1.y + (rnd % Height), m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ x,
+ m_BoundingBox.p1.y + (rnd % Height),
+ m_BoundingBox.p2.z + 1,
+ dirZP,
+ a_Noise,
+ a_RecursionLevel
+ );
}
for (int z = m_BoundingBox.p1.z + 1; z < m_BoundingBox.p2.z; z += 4)
{
int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, a_RecursionLevel, z) / 13;
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, m_BoundingBox.p1.y + (rnd % Height), z, dirXM, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x - 1,
+ m_BoundingBox.p1.y + (rnd % Height),
+ z,
+ dirXM,
+ a_Noise,
+ a_RecursionLevel
+ );
rnd >>= 4;
- m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, m_BoundingBox.p1.y + (rnd % Height), z, dirXP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p2.x + 1,
+ m_BoundingBox.p1.y + (rnd % Height),
+ z,
+ dirXP,
+ a_Noise,
+ a_RecursionLevel
+ );
}
}
@@ -457,12 +504,8 @@ void cMineShaftDirtRoom::ProcessChunk(cChunkDesc & a_ChunkDesc)
{
int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
- if (
- (m_BoundingBox.p1.x > BlockX + cChunkDef::Width) ||
- (m_BoundingBox.p1.z > BlockZ + cChunkDef::Width) ||
- (m_BoundingBox.p2.x < BlockX) ||
- (m_BoundingBox.p2.z < BlockZ)
- )
+ if ((m_BoundingBox.p1.x > BlockX + cChunkDef::Width) || (m_BoundingBox.p1.z > BlockZ + cChunkDef::Width) ||
+ (m_BoundingBox.p2.x < BlockX) || (m_BoundingBox.p2.z < BlockZ))
{
// Early bailout - cannot intersect this chunk
return;
@@ -500,7 +543,9 @@ void cMineShaftDirtRoom::ProcessChunk(cChunkDesc & a_ChunkDesc)
cMineShaftCorridor::cMineShaftCorridor(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- const cCuboid & a_BoundingBox, int a_NumSegments, eDirection a_Direction,
+ const cCuboid & a_BoundingBox,
+ int a_NumSegments,
+ eDirection a_Direction,
cNoise & a_Noise
) :
Super(a_ParentSystem, mskCorridor, a_BoundingBox),
@@ -538,20 +583,40 @@ cMineShaftCorridor::cMineShaftCorridor(
cMineShaft * cMineShaftCorridor::CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ eDirection a_Direction,
cNoise & a_Noise
)
{
cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
BoundingBox.p2.y += 3;
- int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
+ int rnd =
+ a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
int NumSegments = 2 + (rnd) % (MAX_SEGMENTS - 1); // 2 .. MAX_SEGMENTS
switch (a_Direction)
{
- case dirXP: BoundingBox.p2.x += NumSegments * 5 - 1; BoundingBox.p1.z -= 1; BoundingBox.p2.z += 1; break;
- case dirXM: BoundingBox.p1.x -= NumSegments * 5 - 1; BoundingBox.p1.z -= 1; BoundingBox.p2.z += 1; break;
- case dirZP: BoundingBox.p2.z += NumSegments * 5 - 1; BoundingBox.p1.x -= 1; BoundingBox.p2.x += 1; break;
- case dirZM: BoundingBox.p1.z -= NumSegments * 5 - 1; BoundingBox.p1.x -= 1; BoundingBox.p2.x += 1; break;
+ case dirXP:
+ BoundingBox.p2.x += NumSegments * 5 - 1;
+ BoundingBox.p1.z -= 1;
+ BoundingBox.p2.z += 1;
+ break;
+ case dirXM:
+ BoundingBox.p1.x -= NumSegments * 5 - 1;
+ BoundingBox.p1.z -= 1;
+ BoundingBox.p2.z += 1;
+ break;
+ case dirZP:
+ BoundingBox.p2.z += NumSegments * 5 - 1;
+ BoundingBox.p1.x -= 1;
+ BoundingBox.p2.x += 1;
+ break;
+ case dirZM:
+ BoundingBox.p1.z -= NumSegments * 5 - 1;
+ BoundingBox.p1.x -= 1;
+ BoundingBox.p2.x += 1;
+ break;
}
if (!a_ParentSystem.CanAppend(BoundingBox))
{
@@ -566,67 +631,172 @@ cMineShaft * cMineShaftCorridor::CreateAndFit(
void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
{
- int Outerrnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 7;
+ int Outerrnd =
+ a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 7;
// Prefer the same height, but allow for up to one block height displacement:
int OuterHeight = m_BoundingBox.p1.y + ((Outerrnd % 4) + ((Outerrnd >> 3) % 3)) / 2;
switch (m_Direction)
{
case dirXM:
{
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, OuterHeight, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x - 1,
+ OuterHeight,
+ m_BoundingBox.p1.z + 1,
+ dirXM,
+ a_Noise,
+ a_RecursionLevel
+ );
for (int i = m_NumSegments; i >= 0; i--)
{
- int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+ int rnd = a_Noise.IntNoise3DInt(
+ m_BoundingBox.p1.x + i + 10,
+ m_BoundingBox.p1.y + a_RecursionLevel,
+ m_BoundingBox.p1.z
+ ) /
+ 11;
int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
rnd >>= 6;
int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + Ofs,
+ Height,
+ m_BoundingBox.p1.z - 1,
+ dirZM,
+ a_Noise,
+ a_RecursionLevel
+ );
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + Ofs,
+ Height,
+ m_BoundingBox.p2.z + 1,
+ dirZP,
+ a_Noise,
+ a_RecursionLevel
+ );
}
break;
}
case dirXP:
{
- m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, OuterHeight, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p2.x + 1,
+ OuterHeight,
+ m_BoundingBox.p1.z + 1,
+ dirXP,
+ a_Noise,
+ a_RecursionLevel
+ );
for (int i = m_NumSegments; i >= 0; i--)
{
- int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+ int rnd = a_Noise.IntNoise3DInt(
+ m_BoundingBox.p1.x + i + 10,
+ m_BoundingBox.p1.y + a_RecursionLevel,
+ m_BoundingBox.p1.z
+ ) /
+ 11;
int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
rnd >>= 6;
int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Ofs, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + Ofs,
+ Height,
+ m_BoundingBox.p1.z - 1,
+ dirZM,
+ a_Noise,
+ a_RecursionLevel
+ );
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + Ofs,
+ Height,
+ m_BoundingBox.p2.z + 1,
+ dirZP,
+ a_Noise,
+ a_RecursionLevel
+ );
}
break;
}
case dirZM:
{
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, OuterHeight, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + 1,
+ OuterHeight,
+ m_BoundingBox.p1.z - 1,
+ dirZM,
+ a_Noise,
+ a_RecursionLevel
+ );
for (int i = m_NumSegments; i >= 0; i--)
{
- int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+ int rnd = a_Noise.IntNoise3DInt(
+ m_BoundingBox.p1.x + i + 10,
+ m_BoundingBox.p1.y + a_RecursionLevel,
+ m_BoundingBox.p1.z
+ ) /
+ 11;
int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
rnd >>= 6;
int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + Ofs, dirXM, a_Noise, a_RecursionLevel);
- m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + Ofs, dirXP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x - 1,
+ Height,
+ m_BoundingBox.p1.z + Ofs,
+ dirXM,
+ a_Noise,
+ a_RecursionLevel
+ );
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p2.x + 1,
+ Height,
+ m_BoundingBox.p1.z + Ofs,
+ dirXP,
+ a_Noise,
+ a_RecursionLevel
+ );
}
break;
}
case dirZP:
{
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, OuterHeight, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + 1,
+ OuterHeight,
+ m_BoundingBox.p2.z + 1,
+ dirZP,
+ a_Noise,
+ a_RecursionLevel
+ );
for (int i = m_NumSegments; i >= 0; i--)
{
- int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
+ int rnd = a_Noise.IntNoise3DInt(
+ m_BoundingBox.p1.x + i + 10,
+ m_BoundingBox.p1.y + a_RecursionLevel,
+ m_BoundingBox.p1.z
+ ) /
+ 11;
int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
rnd >>= 6;
int Ofs = 1 + rnd % (m_NumSegments * 5 - 2);
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + Ofs, dirXM, a_Noise, a_RecursionLevel);
- m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + Ofs, dirXP, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x - 1,
+ Height,
+ m_BoundingBox.p1.z + Ofs,
+ dirXM,
+ a_Noise,
+ a_RecursionLevel
+ );
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p2.x + 1,
+ Height,
+ m_BoundingBox.p1.z + Ofs,
+ dirXP,
+ a_Noise,
+ a_RecursionLevel
+ );
}
break;
}
@@ -654,7 +824,7 @@ void cMineShaftCorridor::ProcessChunk(cChunkDesc & a_ChunkDesc)
{
// Cobwebs around the spider spawner
a_ChunkDesc.RandomFillRelCuboid(RelBoundingBox, E_BLOCK_COBWEB, 0, (BlockX ^ (BlockZ + BlockZ)), 8000);
- a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_COBWEB, 0, (BlockX ^ (BlockZ + BlockX)), 5000);
+ a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_COBWEB, 0, (BlockX ^ (BlockZ + BlockX)), 5000);
}
a_ChunkDesc.RandomFillRelCuboid(Top, E_BLOCK_COBWEB, 0, (BlockX ^ (BlockZ + BlockX + 10)), 500);
RelBoundingBox.p1.y = m_BoundingBox.p1.y;
@@ -745,21 +915,20 @@ void cMineShaftCorridor::ProcessChunk(cChunkDesc & a_ChunkDesc)
void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
{
- static const cLootProbab LootProbab[] =
- {
+ static const cLootProbab LootProbab[] = {
// Item, MinAmount, MaxAmount, Weight
- { cItem(E_ITEM_IRON), 1, 5, 10 },
- { cItem(E_ITEM_GOLD), 1, 3, 5 },
- { cItem(E_ITEM_REDSTONE_DUST), 4, 9, 5 },
- { cItem(E_ITEM_DIAMOND), 1, 2, 3 },
- { cItem(E_ITEM_DYE, 1, 4), 4, 9, 5 }, // lapis lazuli dye
- { cItem(E_ITEM_COAL), 3, 8, 10 },
- { cItem(E_ITEM_BREAD), 1, 3, 15 },
- { cItem(E_ITEM_IRON_PICKAXE), 1, 1, 1 },
- { cItem(E_BLOCK_MINECART_TRACKS), 4, 8, 1 },
- { cItem(E_ITEM_MELON_SEEDS), 2, 4, 10 },
- { cItem(E_ITEM_PUMPKIN_SEEDS), 2, 4, 10 },
- } ;
+ {cItem(E_ITEM_IRON), 1, 5, 10},
+ {cItem(E_ITEM_GOLD), 1, 3, 5},
+ {cItem(E_ITEM_REDSTONE_DUST), 4, 9, 5},
+ {cItem(E_ITEM_DIAMOND), 1, 2, 3},
+ {cItem(E_ITEM_DYE, 1, 4), 4, 9, 5}, // lapis lazuli dye
+ {cItem(E_ITEM_COAL), 3, 8, 10},
+ {cItem(E_ITEM_BREAD), 1, 3, 15},
+ {cItem(E_ITEM_IRON_PICKAXE), 1, 1, 1},
+ {cItem(E_BLOCK_MINECART_TRACKS), 4, 8, 1},
+ {cItem(E_ITEM_MELON_SEEDS), 2, 4, 10},
+ {cItem(E_ITEM_PUMPKIN_SEEDS), 2, 4, 10},
+ };
if (m_ChestPosition < 0)
{
@@ -795,13 +964,11 @@ void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
UNREACHABLE("Unsupported corridor direction");
}();
- if (
- (x >= 0) && (x < cChunkDef::Width) &&
- (z >= 0) && (z < cChunkDef::Width)
- )
+ if ((x >= 0) && (x < cChunkDef::Width) && (z >= 0) && (z < cChunkDef::Width))
{
a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p1.y + 1, z, E_BLOCK_CHEST, Meta);
- cChestEntity * ChestEntity = static_cast<cChestEntity *>(a_ChunkDesc.GetBlockEntity(x, m_BoundingBox.p1.y + 1, z));
+ cChestEntity * ChestEntity =
+ static_cast<cChestEntity *>(a_ChunkDesc.GetBlockEntity(x, m_BoundingBox.p1.y + 1, z));
ASSERT((ChestEntity != nullptr) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
int NumSlots = 3 + ((Noise.IntNoise3DInt(x, m_BoundingBox.p1.y, z) / 11) % 4);
@@ -844,7 +1011,13 @@ void cMineShaftCorridor::PlaceTracks(cChunkDesc & a_ChunkDesc)
break;
}
} // switch (direction)
- a_ChunkDesc.RandomFillRelCuboid(Box, E_BLOCK_MINECART_TRACKS, Meta, a_ChunkDesc.GetChunkX() + a_ChunkDesc.GetChunkZ(), 6000);
+ a_ChunkDesc.RandomFillRelCuboid(
+ Box,
+ E_BLOCK_MINECART_TRACKS,
+ Meta,
+ a_ChunkDesc.GetChunkX() + a_ChunkDesc.GetChunkZ(),
+ 6000
+ );
}
@@ -875,13 +1048,13 @@ void cMineShaftCorridor::PlaceSpawner(cChunkDesc & a_ChunkDesc)
break;
}
}
- if (
- (SpawnerRelX >= 0) && (SpawnerRelX < cChunkDef::Width) &&
- (SpawnerRelZ >= 0) && (SpawnerRelZ < cChunkDef::Width)
- )
+ if ((SpawnerRelX >= 0) && (SpawnerRelX < cChunkDef::Width) && (SpawnerRelZ >= 0) &&
+ (SpawnerRelZ < cChunkDef::Width))
{
a_ChunkDesc.SetBlockTypeMeta(SpawnerRelX, m_BoundingBox.p1.y + 1, SpawnerRelZ, E_BLOCK_MOB_SPAWNER, 0);
- cMobSpawnerEntity * MobSpawner = static_cast<cMobSpawnerEntity *>(a_ChunkDesc.GetBlockEntity(SpawnerRelX, m_BoundingBox.p1.y + 1, SpawnerRelZ));
+ cMobSpawnerEntity * MobSpawner = static_cast<cMobSpawnerEntity *>(
+ a_ChunkDesc.GetBlockEntity(SpawnerRelX, m_BoundingBox.p1.y + 1, SpawnerRelZ)
+ );
ASSERT((MobSpawner != nullptr) && (MobSpawner->GetBlockType() == E_BLOCK_MOB_SPAWNER));
MobSpawner->SetEntity(mtCaveSpider);
}
@@ -975,7 +1148,10 @@ void cMineShaftCorridor::PlaceTorches(cChunkDesc & a_ChunkDesc)
////////////////////////////////////////////////////////////////////////////////
// cMineShaftCrossing:
-cMineShaftCrossing::cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem & a_ParentSystem, const cCuboid & a_BoundingBox) :
+cMineShaftCrossing::cMineShaftCrossing(
+ cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
+ const cCuboid & a_BoundingBox
+) :
Super(a_ParentSystem, mskCrossing, a_BoundingBox)
{
}
@@ -986,12 +1162,16 @@ cMineShaftCrossing::cMineShaftCrossing(cStructGenMineShafts::cMineShaftSystem &
cMineShaft * cMineShaftCrossing::CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ eDirection a_Direction,
cNoise & a_Noise
)
{
cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
- int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
+ int rnd =
+ a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
BoundingBox.p2.y += 3;
if ((rnd % 4) < 2)
{
@@ -1007,10 +1187,26 @@ cMineShaft * cMineShaftCrossing::CreateAndFit(
}
switch (a_Direction)
{
- case dirXP: BoundingBox.p2.x += 4; BoundingBox.p1.z -= 2; BoundingBox.p2.z += 2; break;
- case dirXM: BoundingBox.p1.x -= 4; BoundingBox.p1.z -= 2; BoundingBox.p2.z += 2; break;
- case dirZP: BoundingBox.p2.z += 4; BoundingBox.p1.x -= 2; BoundingBox.p2.x += 2; break;
- case dirZM: BoundingBox.p1.z -= 4; BoundingBox.p1.x -= 2; BoundingBox.p2.x += 2; break;
+ case dirXP:
+ BoundingBox.p2.x += 4;
+ BoundingBox.p1.z -= 2;
+ BoundingBox.p2.z += 2;
+ break;
+ case dirXM:
+ BoundingBox.p1.x -= 4;
+ BoundingBox.p1.z -= 2;
+ BoundingBox.p2.z += 2;
+ break;
+ case dirZP:
+ BoundingBox.p2.z += 4;
+ BoundingBox.p1.x -= 2;
+ BoundingBox.p2.x += 2;
+ break;
+ case dirZM:
+ BoundingBox.p1.z -= 4;
+ BoundingBox.p1.x -= 2;
+ BoundingBox.p2.x += 2;
+ break;
}
if (!a_ParentSystem.CanAppend(BoundingBox))
{
@@ -1029,19 +1225,18 @@ void cMineShaftCrossing::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
{
int x, y, z;
eDirection dir;
- } Exits[] =
- {
+ } Exits[] = {
// Bottom level:
- {-1, 1, 2, dirXM},
- { 2, 1, -1, dirZM},
- { 5, 1, 2, dirXP},
- { 2, 1, 5, dirZP},
+ {-1, 1, 2, dirXM},
+ {2, 1, -1, dirZM},
+ {5, 1, 2, dirXP},
+ {2, 1, 5, dirZP},
// Top level:
- {-1, 5, 2, dirXM},
- { 2, 5, -1, dirZM},
- { 5, 5, 2, dirXP},
- { 2, 5, 5, dirZP},
- } ;
+ {-1, 5, 2, dirXM},
+ {2, 5, -1, dirZM},
+ {5, 5, 2, dirXP},
+ {2, 5, 5, dirZP},
+ };
for (size_t i = 0; i < ARRAYCOUNT(Exits); i++)
{
if (m_BoundingBox.p1.y + Exits[i].y >= m_BoundingBox.p2.y)
@@ -1051,7 +1246,14 @@ void cMineShaftCrossing::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
}
int Height = m_BoundingBox.p1.y + Exits[i].y;
- m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + Exits[i].x, Height, m_BoundingBox.p1.z + Exits[i].z, Exits[i].dir, a_Noise, a_RecursionLevel);
+ m_ParentSystem.AppendBranch(
+ m_BoundingBox.p1.x + Exits[i].x,
+ Height,
+ m_BoundingBox.p1.z + Exits[i].z,
+ Exits[i].dir,
+ a_Noise,
+ a_RecursionLevel
+ );
} // for i
}
@@ -1085,17 +1287,17 @@ void cMineShaftCrossing::ProcessChunk(cChunkDesc & a_ChunkDesc)
// The air on the edges:
int Mid = Floor + 2;
- a_ChunkDesc.FillRelCuboid(box.p1.x, box.p1.x, Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid(box.p2.x, box.p2.x, Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p1.z, box.p1.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p2.z, box.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p1.x, box.p1.x, Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p2.x, box.p2.x, Floor, Mid, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p1.z, box.p1.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Floor, Mid, box.p2.z, box.p2.z, E_BLOCK_AIR, 0);
Mid += 2;
if (Mid < Ceil)
{
- a_ChunkDesc.FillRelCuboid(box.p1.x, box.p1.x, Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid(box.p2.x, box.p2.x, Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p1.z, box.p1.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p2.z, box.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p1.x, box.p1.x, Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p2.x, box.p2.x, Mid, Ceil, box.p1.z + 1, box.p2.z - 1, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p1.z, box.p1.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FillRelCuboid(box.p1.x + 1, box.p2.x - 1, Mid, Ceil, box.p2.z, box.p2.z, E_BLOCK_AIR, 0);
}
// The floor, if needed:
@@ -1116,9 +1318,7 @@ cMineShaftStaircase::cMineShaftStaircase(
eDirection a_Direction,
eSlope a_Slope
) :
- Super(a_ParentSystem, mskStaircase, a_BoundingBox),
- m_Direction(a_Direction),
- m_Slope(a_Slope)
+ Super(a_ParentSystem, mskStaircase, a_BoundingBox), m_Direction(a_Direction), m_Slope(a_Slope)
{
}
@@ -1128,11 +1328,15 @@ cMineShaftStaircase::cMineShaftStaircase(
cMineShaft * cMineShaftStaircase::CreateAndFit(
cStructGenMineShafts::cMineShaftSystem & a_ParentSystem,
- int a_PivotX, int a_PivotY, int a_PivotZ, eDirection a_Direction,
+ int a_PivotX,
+ int a_PivotY,
+ int a_PivotZ,
+ eDirection a_Direction,
cNoise & a_Noise
)
{
- int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
+ int rnd =
+ a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
cCuboid Box;
switch (a_Direction)
{
@@ -1179,10 +1383,22 @@ void cMineShaftStaircase::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
int Height = m_BoundingBox.p1.y + ((m_Slope == sDown) ? 1 : 5);
switch (m_Direction)
{
- case dirXM: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel); break;
- case dirXP: m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel); break;
- case dirZM: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel); break;
- case dirZP: m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel); break;
+ case dirXM:
+ m_ParentSystem
+ .AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel);
+ break;
+ case dirXP:
+ m_ParentSystem
+ .AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel);
+ break;
+ case dirZM:
+ m_ParentSystem
+ .AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
+ break;
+ case dirZP:
+ m_ParentSystem
+ .AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
+ break;
}
}
@@ -1196,12 +1412,7 @@ void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
cCuboid RelB(m_BoundingBox);
RelB.Move({-BlockX, 0, -BlockZ});
- if (
- (RelB.p1.x >= cChunkDef::Width) ||
- (RelB.p1.z >= cChunkDef::Width) ||
- (RelB.p2.x < 0) ||
- (RelB.p2.z < 0)
- )
+ if ((RelB.p1.x >= cChunkDef::Width) || (RelB.p1.z >= cChunkDef::Width) || (RelB.p2.x < 0) || (RelB.p2.z < 0))
{
// No intersection between this staircase and this chunk
return;
@@ -1216,15 +1427,44 @@ void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
{
case dirXM:
{
- a_ChunkDesc.FillRelCuboid (RelB.p2.x - 1, RelB.p2.x, SFloor, SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p1.x + 1, DFloor, DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p2.x - 1, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p1.x + 1, DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p2.x - 1, RelB.p2.x, SFloor, SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p1.x, RelB.p1.x + 1, DFloor, DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p2.x - 1,
+ RelB.p2.x,
+ SFloor - 1,
+ SFloor - 1,
+ RelB.p1.z,
+ RelB.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p1.x,
+ RelB.p1.x + 1,
+ DFloor - 1,
+ DFloor - 1,
+ RelB.p1.z,
+ RelB.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Assign({RelB.p2.x - 2, SFloor + InitAdd, RelB.p1.z}, {RelB.p2.x - 2, SFloor + 3 + InitAdd, RelB.p2.z});
for (int i = 0; i < 4; i++)
{
a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ Box.p1.x,
+ Box.p2.x,
+ Box.p1.y - 1,
+ Box.p1.y - 1,
+ Box.p1.z,
+ Box.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Move({-1, Add, 0});
}
break;
@@ -1232,15 +1472,44 @@ void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
case dirXP:
{
- a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p1.x + 1, SFloor, SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid (RelB.p2.x - 1, RelB.p2.x, DFloor, DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p1.x + 1, SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p2.x - 1, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p1.x, RelB.p1.x + 1, SFloor, SFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p2.x - 1, RelB.p2.x, DFloor, DFloor + 2, RelB.p1.z, RelB.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p1.x,
+ RelB.p1.x + 1,
+ SFloor - 1,
+ SFloor - 1,
+ RelB.p1.z,
+ RelB.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p2.x - 1,
+ RelB.p2.x,
+ DFloor - 1,
+ DFloor - 1,
+ RelB.p1.z,
+ RelB.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Assign({RelB.p1.x + 2, SFloor + InitAdd, RelB.p1.z}, {RelB.p1.x + 2, SFloor + 3 + InitAdd, RelB.p2.z});
for (int i = 0; i < 4; i++)
{
a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ Box.p1.x,
+ Box.p2.x,
+ Box.p1.y - 1,
+ Box.p1.y - 1,
+ Box.p1.z,
+ Box.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Move({1, Add, 0});
}
break;
@@ -1248,15 +1517,44 @@ void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
case dirZM:
{
- a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, SFloor, SFloor + 2, RelB.p2.z - 1, RelB.p2.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, DFloor, DFloor + 2, RelB.p1.z, RelB.p1.z + 1, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p2.z - 1, RelB.p2.z, E_BLOCK_PLANKS, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p1.z, RelB.p1.z + 1, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p1.x, RelB.p2.x, SFloor, SFloor + 2, RelB.p2.z - 1, RelB.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p1.x, RelB.p2.x, DFloor, DFloor + 2, RelB.p1.z, RelB.p1.z + 1, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p1.x,
+ RelB.p2.x,
+ SFloor - 1,
+ SFloor - 1,
+ RelB.p2.z - 1,
+ RelB.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p1.x,
+ RelB.p2.x,
+ DFloor - 1,
+ DFloor - 1,
+ RelB.p1.z,
+ RelB.p1.z + 1,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Assign({RelB.p1.x, SFloor + InitAdd, RelB.p2.z - 2}, {RelB.p2.x, SFloor + 3 + InitAdd, RelB.p2.z - 2});
for (int i = 0; i < 4; i++)
{
a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ Box.p1.x,
+ Box.p2.x,
+ Box.p1.y - 1,
+ Box.p1.y - 1,
+ Box.p1.z,
+ Box.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Move({0, Add, -1});
}
break;
@@ -1264,15 +1562,44 @@ void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
case dirZP:
{
- a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, SFloor, SFloor + 2, RelB.p1.z, RelB.p1.z + 1, E_BLOCK_AIR, 0);
- a_ChunkDesc.FillRelCuboid (RelB.p1.x, RelB.p2.x, DFloor, DFloor + 2, RelB.p2.z - 1, RelB.p2.z, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, SFloor - 1, SFloor - 1, RelB.p1.z, RelB.p1.z + 1, E_BLOCK_PLANKS, 0);
- a_ChunkDesc.FloorRelCuboid(RelB.p1.x, RelB.p2.x, DFloor - 1, DFloor - 1, RelB.p2.z - 1, RelB.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p1.x, RelB.p2.x, SFloor, SFloor + 2, RelB.p1.z, RelB.p1.z + 1, E_BLOCK_AIR, 0);
+ a_ChunkDesc
+ .FillRelCuboid(RelB.p1.x, RelB.p2.x, DFloor, DFloor + 2, RelB.p2.z - 1, RelB.p2.z, E_BLOCK_AIR, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p1.x,
+ RelB.p2.x,
+ SFloor - 1,
+ SFloor - 1,
+ RelB.p1.z,
+ RelB.p1.z + 1,
+ E_BLOCK_PLANKS,
+ 0
+ );
+ a_ChunkDesc.FloorRelCuboid(
+ RelB.p1.x,
+ RelB.p2.x,
+ DFloor - 1,
+ DFloor - 1,
+ RelB.p2.z - 1,
+ RelB.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Assign({RelB.p1.x, SFloor + InitAdd, RelB.p1.z + 2}, {RelB.p2.x, SFloor + 3 + InitAdd, RelB.p1.z + 2});
for (int i = 0; i < 4; i++)
{
a_ChunkDesc.FillRelCuboid(Box, E_BLOCK_AIR, 0);
- a_ChunkDesc.FloorRelCuboid(Box.p1.x, Box.p2.x, Box.p1.y - 1, Box.p1.y - 1, Box.p1.z, Box.p2.z, E_BLOCK_PLANKS, 0);
+ a_ChunkDesc.FloorRelCuboid(
+ Box.p1.x,
+ Box.p2.x,
+ Box.p1.y - 1,
+ Box.p1.y - 1,
+ Box.p1.z,
+ Box.p2.z,
+ E_BLOCK_PLANKS,
+ 0
+ );
Box.Move({0, Add, 1});
}
break;
@@ -1289,8 +1616,13 @@ void cMineShaftStaircase::ProcessChunk(cChunkDesc & a_ChunkDesc)
// cStructGenMineShafts:
cStructGenMineShafts::cStructGenMineShafts(
- int a_Seed, int a_GridSize, int a_MaxOffset, int a_MaxSystemSize,
- int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
+ 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),
m_GridSize(a_GridSize),
@@ -1305,11 +1637,23 @@ cStructGenMineShafts::cStructGenMineShafts(
-cGridStructGen::cStructurePtr cStructGenMineShafts::CreateStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ)
+cGridStructGen::cStructurePtr cStructGenMineShafts::CreateStructure(
+ int a_GridX,
+ int a_GridZ,
+ int a_OriginX,
+ int a_OriginZ
+)
{
- return cStructurePtr(new cMineShaftSystem(a_GridX, a_GridZ, a_OriginX, a_OriginZ, m_GridSize, m_MaxSystemSize, m_Noise, m_ProbLevelCorridor, m_ProbLevelCrossing, m_ProbLevelStaircase));
+ return cStructurePtr(new cMineShaftSystem(
+ a_GridX,
+ a_GridZ,
+ a_OriginX,
+ a_OriginZ,
+ m_GridSize,
+ m_MaxSystemSize,
+ m_Noise,
+ m_ProbLevelCorridor,
+ m_ProbLevelCrossing,
+ m_ProbLevelStaircase
+ ));
}
-
-
-
-
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 09:08:34 +0100