From 8f262d8a9d2d520a9c92dc0f270a88c554cb3778 Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Tue, 6 May 2014 16:41:55 +0200
Subject: Initial cGridStructGen refactoring.

Ref.: #987.
---
 src/Generating/GridStructGen.cpp | 138 +++++++++++++++++++++++++++++++++++++++
 src/Generating/GridStructGen.h   | 124 +++++++++++++++++++++++++++++++++++
 2 files changed, 262 insertions(+)
 create mode 100644 src/Generating/GridStructGen.cpp
 create mode 100644 src/Generating/GridStructGen.h

(limited to 'src/Generating')

diff --git a/src/Generating/GridStructGen.cpp b/src/Generating/GridStructGen.cpp
new file mode 100644
index 000000000..975fd3fdc
--- /dev/null
+++ b/src/Generating/GridStructGen.cpp
@@ -0,0 +1,138 @@
+
+// GridStructGen.cpp
+
+// Implements the cGridStructGen class representing a common base class for structure generators that place structures in a semi-random grid
+
+#include "Globals.h"
+#include "GridStructGen.h"
+
+
+
+
+cGridStructGen::cGridStructGen(
+	int a_Seed,
+	int a_GridSizeX, int a_GridSizeZ,
+	int a_MaxStructureSizeX, int a_MaxStructureSizeZ,
+	size_t a_MaxCacheSize
+) :
+	m_Seed(a_Seed),
+	m_GridSizeX(a_GridSizeX),
+	m_GridSizeZ(a_GridSizeZ),
+	m_MaxStructureSizeX(a_MaxStructureSizeX),
+	m_MaxStructureSizeZ(a_MaxStructureSizeZ),
+	m_MaxCacheSize(a_MaxCacheSize)
+{
+}
+
+
+
+
+
+void cGridStructGen::GetStructuresForChunk(int a_ChunkX, int a_ChunkZ, cStructurePtrs & a_Structures)
+{
+	// Calculate the min and max grid coords of the structures to be returned:
+	int MinBlockX = a_ChunkX * cChunkDef::Width - m_MaxStructureSizeX;
+	int MinBlockZ = a_ChunkZ * cChunkDef::Width - m_MaxStructureSizeZ;
+	int MaxBlockX = a_ChunkX * cChunkDef::Width + m_MaxStructureSizeX + cChunkDef::Width - 1;
+	int MaxBlockZ = a_ChunkZ * cChunkDef::Width + m_MaxStructureSizeZ + cChunkDef::Width - 1;
+	int MinGridX = MinBlockX / m_GridSizeX;
+	int MinGridZ = MinBlockZ / m_GridSizeZ;
+	int MaxGridX = MaxBlockX / m_GridSizeX;
+	int MaxGridZ = MaxBlockX / m_GridSizeZ;
+	if (MinGridX < 0)
+	{
+		--MinGridX;
+	}
+	if (MinGridZ < 0)
+	{
+		--MinGridZ;
+	}
+	if (MaxGridX < 0)
+	{
+		--MaxGridX;
+	}
+	if (MaxGridZ < 0)
+	{
+		--MaxGridZ;
+	}
+
+	// Walk the cache, move each structure that we want into a_Structures:
+	for (cStructurePtrs::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
+	{
+		if (
+			((*itr)->m_OriginX >= MinBlockX) && ((*itr)->m_OriginX < MaxBlockX) &&
+			((*itr)->m_OriginZ >= MinBlockZ) && ((*itr)->m_OriginZ < MaxBlockZ)
+		)
+		{
+			// want
+			a_Structures.push_back(*itr);
+			itr = m_Cache.erase(itr);
+		}
+		else
+		{
+			// don't want
+			++itr;
+		}
+	}  // for itr - m_Cache[]
+
+	// Create those structures that haven't been in the cache:
+	for (int x = MinGridX; x < MaxGridX; x++)
+	{
+		int OriginX = x * m_GridSizeX;
+		for (int z = MinGridZ; z < MaxGridZ; z++)
+		{
+			int OriginZ = z * m_GridSizeZ;
+			bool Found = false;
+			for (cStructurePtrs::const_iterator itr = a_Structures.begin(), end = a_Structures.end(); itr != end; ++itr)
+			{
+				if (((*itr)->m_OriginX == OriginX) && ((*itr)->m_OriginZ == OriginZ))
+				{
+					Found = true;
+					break;
+				}
+			}  // for itr - a_Structures[]
+			if (!Found)
+			{
+				a_Structures.push_back(CreateStructure(OriginX, OriginZ));
+			}
+		}  // for z
+	}  // for x
+
+	// Copy a_Forts into m_Cache to the beginning:
+	cStructurePtrs StructuresCopy (a_Structures);
+	m_Cache.splice(m_Cache.begin(), StructuresCopy, StructuresCopy.begin(), StructuresCopy.end());
+
+	// Trim the cache if it's too long:
+	size_t CacheSize = 0;
+	for (cStructurePtrs::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
+	{
+		CacheSize += (*itr)->GetCacheCost();
+		if (CacheSize > m_MaxCacheSize)
+		{
+			// Erase all items from this one till the cache end
+			m_Cache.erase(itr, m_Cache.end());
+			break;
+		}
+	}
+}
+
+
+
+
+
+void cGridStructGen::GenFinish(cChunkDesc & a_ChunkDesc)
+{
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cStructurePtrs Structures;
+	GetStructuresForChunk(ChunkX, ChunkZ, Structures);
+	for (cStructurePtrs::const_iterator itr = Structures.begin(); itr != Structures.end(); ++itr)
+	{
+		(*itr)->DrawIntoChunk(a_ChunkDesc);
+	}  // for itr - Structures[]
+}
+
+
+
+
+
diff --git a/src/Generating/GridStructGen.h b/src/Generating/GridStructGen.h
new file mode 100644
index 000000000..234cc75c5
--- /dev/null
+++ b/src/Generating/GridStructGen.h
@@ -0,0 +1,124 @@
+
+// GridStructGen.h
+
+// Declares the cGridStructGen class representing a common base class for structure generators that place structures in a semi-random grid
+
+
+
+
+
+#pragma once
+
+#include "ComposableGenerator.h"
+
+
+
+
+
+/** Generates structures in a semi-random grid.
+Defines a grid in the XZ space with predefined cell size in each direction. Each cell then receives exactly
+one structure (provided by the descendant class). The structure is placed within the cell, but doesn't need
+to be bounded by the cell, it can be well outside the cell; the generator uses the MaxStructureSize parameter
+to determine how far away from the cell the structure can be at most.
+This class provides a cache for the structures generated for successive chunks and manages that cache. It
+also provides the cFinishGen override that uses the cache to actually generate the structure into chunk data.
+
+After generating each chunk the cache is checked for size, each item in the cache has a cost associated with
+it and the cache is trimmed (from its least-recently-used end) so that the sum of the cost in the cache is
+less than m_MaxCacheSize
+
+To use this class, declare a descendant class that implements the overridable methods, then create an
+instance of that class. The descendant must provide the CreateStructure() function that is called to generate
+a structure at the specific grid cell.
+
+The descendant must use a specific cStructure descendant to provide the actual structure that gets generated.
+The structure must provide the DrawIntoChunk() function that generates the structure into the chunk data, and
+can override the GetCacheCost() function that returns the cost of that structure in the cache.
+*/
+class cGridStructGen :
+	public cFinishGen
+{
+public:
+	cGridStructGen(
+		int a_Seed,
+		int a_GridSizeX, int a_GridSizeZ,
+		int a_MaxStructureSizeX, int a_MaxStructureSizeZ,
+		size_t a_MaxCacheSize
+	);
+	
+protected:
+	/** Represents a single structure that occupies the grid point. Knows how to draw itself into a chunk. */
+	class cStructure
+	{
+	public:
+		/** The origin (the coords of the gridpoint for which the structure is generated) */
+		int m_OriginX, m_OriginZ;
+		
+		
+		/** Creates a structure that has its originset at the specified coords. */
+		cStructure (int a_OriginX, int a_OriginZ) :
+			m_OriginX(a_OriginX),
+			m_OriginZ(a_OriginZ)
+		{
+		}
+		
+		// Force a virtual destructor in descendants:
+		virtual ~cStructure() {}
+		
+		/** Draws self into the specified chunk */
+		virtual void DrawIntoChunk(cChunkDesc & a_ChunkDesc) = 0;
+		
+		/** Returns the cost of keeping this structure in the cache */
+		virtual size_t GetCacheCost(void) const { return 1; }
+	} ;
+	typedef SharedPtr<cStructure> cStructurePtr;
+	typedef std::list<cStructurePtr> cStructurePtrs;
+	
+	
+	/** Seed for generating the semi-random grid. */
+	int m_Seed;
+	
+	/** The size of each grid's cell in the X axis */
+	int m_GridSizeX;
+	
+	/** The size of each grid's cell in the Z axis */
+	int m_GridSizeZ;
+	
+	/** Maximum theoretical size of the structure in the X axis.
+	This limits the structures considered for a single chunk, so the lesser the number, the better performance.
+	Structures large than this may get cropped. */
+	int m_MaxStructureSizeX;
+	
+	/** Maximum theoretical size of the structure in the Z axis.
+	This limits the structures considered for a single chunk, so the lesser the number, the better performance.
+	Structures large than this may get cropped. */
+	int m_MaxStructureSizeZ;
+	
+	/** Maximum allowed sum of costs for items in the cache. Items that are over this cost are removed from the
+	cache, oldest-first */
+	size_t m_MaxCacheSize;
+	
+	/** Cache for the most recently generated structures, ordered by the recentness. */
+	cStructurePtrs m_Cache;
+	
+	
+	/** Clears everything from the cache */
+	void ClearCache(void);
+	
+	/** Returns all structures that may intersect the given chunk.
+	The structures are considered as intersecting iff their bounding box (defined by m_MaxStructureSize)
+	around their gridpoint intersects the chunk. */
+	void GetStructuresForChunk(int a_ChunkX, int a_ChunkZ, cStructurePtrs & a_Structures);
+
+	// cFinishGen overrides:
+	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+	
+	// Functions for the descendants to override:
+	/** Create a new structure at the specified gridpoint */
+	virtual cStructurePtr CreateStructure(int a_OriginX, int a_OriginZ) = 0;
+} ;
+
+
+
+
+
-- 
cgit v1.2.3


From da5db2ddf9897d977716261e216e90ee8d61f2e7 Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Wed, 7 May 2014 11:01:30 +0200
Subject: Initial cPrefabPiecePool refactoring.

Ref.: #986.
---
 src/Generating/PrefabPiecePool.cpp | 121 +++++++++++++++++++++++++++++++++++++
 src/Generating/PrefabPiecePool.h   |  75 +++++++++++++++++++++++
 2 files changed, 196 insertions(+)
 create mode 100644 src/Generating/PrefabPiecePool.cpp
 create mode 100644 src/Generating/PrefabPiecePool.h

(limited to 'src/Generating')

diff --git a/src/Generating/PrefabPiecePool.cpp b/src/Generating/PrefabPiecePool.cpp
new file mode 100644
index 000000000..ed9340815
--- /dev/null
+++ b/src/Generating/PrefabPiecePool.cpp
@@ -0,0 +1,121 @@
+
+// PrefabPiecePool.cpp
+
+// Implements the cPrefabPiecePool class that represents a cPiecePool descendant that uses cPrefab instances as the pieces
+
+#include "Globals.h"
+#include "PrefabPiecePool.h"
+
+
+
+
+
+cPrefabPiecePool::cPrefabPiecePool(
+	const cPrefab::sDef * a_PieceDefs,         size_t a_NumPieceDefs,
+	const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs
+)
+{
+	AddPieceDefs(a_PieceDefs, a_NumPieceDefs);
+	if (a_StartingPieceDefs != NULL)
+	{
+		AddStartingPieceDefs(a_StartingPieceDefs, a_NumStartingPieceDefs);
+	}
+}
+
+
+
+
+
+void cPrefabPiecePool::AddPieceDefs(const cPrefab::sDef * a_PieceDefs, size_t a_NumPieceDefs)
+{
+	ASSERT(a_PieceDefs != NULL);
+	for (size_t i = 0; i < a_NumPieceDefs; i++)
+	{
+		cPrefab * Prefab = new cPrefab(a_PieceDefs[i]);
+		m_AllPieces.push_back(Prefab);
+		AddToPerConnectorMap(Prefab);
+	}
+}
+
+
+
+
+
+void cPrefabPiecePool::AddStartingPieceDefs(const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs)
+{
+	ASSERT(a_StartingPieceDefs != NULL);
+	for (size_t i = 0; i < a_NumStartingPieceDefs; i++)
+	{
+		cPrefab * Prefab = new cPrefab(a_StartingPieceDefs[i]);
+		m_StartingPieces.push_back(Prefab);
+	}
+}
+
+
+
+
+
+void cPrefabPiecePool::AddToPerConnectorMap(cPrefab * a_Prefab)
+{
+	cPiece::cConnectors Connectors = ((const cPiece *)a_Prefab)->GetConnectors();
+	for (cPiece::cConnectors::const_iterator itr = Connectors.begin(), end = Connectors.end(); itr != end; ++itr)
+	{
+		m_PiecesByConnector[itr->m_Type].push_back(a_Prefab);
+	}
+}
+
+
+
+
+cPieces cPrefabPiecePool::GetPiecesWithConnector(int a_ConnectorType)
+{
+	return m_PiecesByConnector[a_ConnectorType];
+}
+
+
+
+
+
+cPieces cPrefabPiecePool::GetStartingPieces(void)
+{
+	if (m_StartingPieces.empty())
+	{
+		return m_AllPieces;
+	}
+	else
+	{
+		return m_StartingPieces;
+	}
+}
+
+
+
+
+
+int cPrefabPiecePool::GetPieceWeight(const cPlacedPiece & a_PlacedPiece, const cPiece::cConnector & a_ExistingConnector, const cPiece & a_NewPiece)
+{
+	return ((const cPrefab &)a_NewPiece).GetPieceWeight(a_PlacedPiece, a_ExistingConnector);
+}
+
+
+
+
+
+void cPrefabPiecePool::PiecePlaced(const cPiece & a_Piece)
+{
+	// Do nothing
+	UNUSED(a_Piece);
+}
+
+
+
+
+
+void cPrefabPiecePool::Reset(void)
+{
+	// Do nothing
+}
+
+
+
+
diff --git a/src/Generating/PrefabPiecePool.h b/src/Generating/PrefabPiecePool.h
new file mode 100644
index 000000000..2a7993063
--- /dev/null
+++ b/src/Generating/PrefabPiecePool.h
@@ -0,0 +1,75 @@
+
+// PrefabPiecePool.h
+
+// Declares the cPrefabPiecePool class that represents a cPiecePool descendant that uses cPrefab instances as the pieces
+
+
+
+
+
+#pragma once
+
+#include "PieceGenerator.h"
+#include "Prefab.h"
+
+
+
+
+
+class cPrefabPiecePool :
+	public cPiecePool
+{
+public:
+	/** Creates a piece pool with prefabs from the specified definitions.
+	If both a_PieceDefs and a_StartingPieceDefs are given, only the a_StartingPieceDefs are used as starting
+	pieces for the pool, and they do not participate in the generation any further.
+	If only a_PieceDefs is given, any such piece can be chosen as a starting piece, and all the pieces are used
+	for generating. */
+	cPrefabPiecePool(
+		const cPrefab::sDef * a_PieceDefs,         size_t a_NumPieceDefs,
+		const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs
+	);
+	
+	/** Adds pieces from the specified definitions into m_AllPieces. Also adds the pieces into
+	the m_PiecesByConnector map.
+	May be called multiple times with different PieceDefs, will add all such pieces. */
+	void AddPieceDefs(const cPrefab::sDef * a_PieceDefs, size_t a_NumPieceDefs);
+	
+	/** Adds pieces from the specified definitions into m_StartingPieces. Doesn't add to
+	the m_PiecesByConnector map.
+	May be called multiple times with different PieceDefs, will add all such pieces. */
+	void AddStartingPieceDefs(const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs);
+	
+	
+protected:
+
+	/** The type used to map a connector type to the list of pieces with that connector */
+	typedef std::map<int, cPieces> cPiecesMap;
+	
+	/** All the pieces that are allowed for building.
+	This is the list that's used for memory allocation and deallocation for the pieces. */
+	cPieces m_AllPieces;
+	
+	/** The pieces that are used as starting pieces.
+	This list is not shared and the pieces need deallocation. */
+	cPieces m_StartingPieces;
+	
+	/** The map that has all pieces by their connector types
+	The pieces are copies out of m_AllPieces and shouldn't be ever delete-d. */
+	cPiecesMap m_PiecesByConnector;
+
+
+	/** Adds the prefab to the m_PiecesByConnector map for all its connectors. */
+	void AddToPerConnectorMap(cPrefab * a_Prefab);
+	
+	// cPiecePool overrides:
+	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;
+	virtual cPieces GetStartingPieces(void) override;
+	virtual int GetPieceWeight(const cPlacedPiece & a_PlacedPiece, const cPiece::cConnector & a_ExistingConnector, const cPiece & a_NewPiece) override;
+	virtual void PiecePlaced(const cPiece & a_Piece) override;
+	virtual void Reset(void) override;
+} ;
+
+
+
+
-- 
cgit v1.2.3


From 564261cfd9e385dfe6331c0585cae3b46989dd17 Mon Sep 17 00:00:00 2001
From: madmaxoft <github@xoft.cz>
Date: Wed, 7 May 2014 22:34:06 +0200
Subject: cNetherFortGen uses cGridStructGen.

WIP, this doesn't work properly yet.
---
 src/Generating/Caves.h           |   2 +-
 src/Generating/GridStructGen.cpp |  12 +--
 src/Generating/NetherFortGen.cpp | 223 ++++-----------------------------------
 src/Generating/NetherFortGen.h   |  61 ++---------
 src/Generating/PrefabPiecePool.h |   8 +-
 5 files changed, 42 insertions(+), 264 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/Caves.h b/src/Generating/Caves.h
index 7c45c056b..2a9fa01b8 100644
--- a/src/Generating/Caves.h
+++ b/src/Generating/Caves.h
@@ -93,7 +93,7 @@ protected:
 	/// Returns all caves that *may* intersect the given chunk. All the caves are valid until the next call to this function.
 	void GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cCaveSystems & a_Caves);
 	
-	// cStructGen override:
+	// cFinishGen override:
 	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
 } ;
 
diff --git a/src/Generating/GridStructGen.cpp b/src/Generating/GridStructGen.cpp
index 975fd3fdc..2f064d3a0 100644
--- a/src/Generating/GridStructGen.cpp
+++ b/src/Generating/GridStructGen.cpp
@@ -37,21 +37,21 @@ void cGridStructGen::GetStructuresForChunk(int a_ChunkX, int a_ChunkZ, cStructur
 	int MaxBlockZ = a_ChunkZ * cChunkDef::Width + m_MaxStructureSizeZ + cChunkDef::Width - 1;
 	int MinGridX = MinBlockX / m_GridSizeX;
 	int MinGridZ = MinBlockZ / m_GridSizeZ;
-	int MaxGridX = MaxBlockX / m_GridSizeX;
-	int MaxGridZ = MaxBlockX / m_GridSizeZ;
-	if (MinGridX < 0)
+	int MaxGridX = (MaxBlockX + m_GridSizeX - 1) / m_GridSizeX;
+	int MaxGridZ = (MaxBlockZ + m_GridSizeZ - 1) / m_GridSizeZ;
+	if (MinBlockX < 0)
 	{
 		--MinGridX;
 	}
-	if (MinGridZ < 0)
+	if (MinBlockZ < 0)
 	{
 		--MinGridZ;
 	}
-	if (MaxGridX < 0)
+	if (MaxBlockX < 0)
 	{
 		--MaxGridX;
 	}
-	if (MaxGridZ < 0)
+	if (MaxBlockZ < 0)
 	{
 		--MaxGridZ;
 	}
diff --git a/src/Generating/NetherFortGen.cpp b/src/Generating/NetherFortGen.cpp
index d90fdeb0a..ac7fd0b7b 100644
--- a/src/Generating/NetherFortGen.cpp
+++ b/src/Generating/NetherFortGen.cpp
@@ -20,20 +20,21 @@ static const int NEIGHBORHOOD_SIZE = 3;
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cNetherFortGen::cNetherFort:
 
-class cNetherFortGen::cNetherFort
+class cNetherFortGen::cNetherFort :
+	public cGridStructGen::cStructure
 {
+	typedef cGridStructGen::cStructure super;
+	
 public:
 	cNetherFortGen & m_ParentGen;
-	int m_BlockX, m_BlockZ;
 	int m_GridSize;
 	int m_Seed;
 	cPlacedPieces m_Pieces;
 
 
-	cNetherFort(cNetherFortGen & a_ParentGen, int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxDepth, int a_Seed) :
+	cNetherFort(cNetherFortGen & a_ParentGen, int a_OriginX, int a_OriginZ, int a_GridSize, int a_MaxDepth, int a_Seed) :
+		super(a_OriginX, a_OriginZ),
 		m_ParentGen(a_ParentGen),
-		m_BlockX(a_BlockX),
-		m_BlockZ(a_BlockZ),
 		m_GridSize(a_GridSize),
 		m_Seed(a_Seed)
 	{
@@ -43,8 +44,8 @@ public:
 		// Generate pieces:
 		for (int i = 0; m_Pieces.size() < (size_t)(a_MaxDepth * a_MaxDepth / 8 + a_MaxDepth); i++)
 		{
-			cBFSPieceGenerator pg(m_ParentGen, a_Seed + i);
-			pg.PlacePieces(a_BlockX, BlockY, a_BlockZ, a_MaxDepth, m_Pieces);
+			cBFSPieceGenerator pg(cNetherFortGen::m_PiecePool, a_Seed + i);
+			pg.PlacePieces(a_OriginX, BlockY, a_OriginZ, a_MaxDepth, m_Pieces);
 		}
 	}
 
@@ -56,7 +57,7 @@ public:
 	
 		
 	/** Carves the system into the chunk data */
-	void ProcessChunk(cChunkDesc & a_Chunk)
+	virtual void DrawIntoChunk(cChunkDesc & a_Chunk)
 	{
 		for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
 		{
@@ -107,214 +108,30 @@ public:
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cNetherFortGen:
 
+cPrefabPiecePool cNetherFortGen::m_PiecePool(g_NetherFortPrefabs, g_NetherFortPrefabsCount, g_NetherFortStartingPrefabs, g_NetherFortStartingPrefabsCount);
+
+
+
+
+
 cNetherFortGen::cNetherFortGen(int a_Seed, int a_GridSize, int a_MaxDepth) :
-	m_Seed(a_Seed),
-	m_Noise(a_Seed),
-	m_GridSize(a_GridSize),
+	super(a_Seed, a_GridSize, a_GridSize, a_MaxDepth * 10, a_MaxDepth * 10, 200),
 	m_MaxDepth(a_MaxDepth)
 {
-	// Initialize the prefabs:
-	for (size_t i = 0; i < g_NetherFortPrefabsCount; i++)
-	{
-		cPrefab * Prefab = new cPrefab(g_NetherFortPrefabs[i]);
-		m_AllPieces.push_back(Prefab);
-		if (Prefab->HasConnectorType(0))
-		{
-			m_OuterPieces.push_back(Prefab);
-		}
-		if (Prefab->HasConnectorType(1))
-		{
-			m_InnerPieces.push_back(Prefab);
-		}
-	}
-	
-	// Initialize the starting piece prefabs:
-	for (size_t i = 0; i < g_NetherFortStartingPrefabsCount; i++)
-	{
-		m_StartingPieces.push_back(new cPrefab(g_NetherFortStartingPrefabs[i]));
-	}
-
 	/*
 	// DEBUG: Try one round of placement:
 	cPlacedPieces Pieces;
-	cBFSPieceGenerator pg(*this, a_Seed);
+	cBFSPieceGenerator pg(m_PiecePool, a_Seed);
 	pg.PlacePieces(0, 64, 0, a_MaxDepth, Pieces);
-	*/
-}
-
-
-
-
-
-cNetherFortGen::~cNetherFortGen()
-{
-	ClearCache();
-	for (cPieces::iterator itr = m_AllPieces.begin(), end = m_AllPieces.end(); itr != end; ++itr)
-	{
-		delete *itr;
-	}  // for itr - m_AllPieces[]
-	m_AllPieces.clear();
+	//*/
 }
 
 
 
 
 
-void cNetherFortGen::ClearCache(void)
+cGridStructGen::cStructurePtr cNetherFortGen::CreateStructure(int a_OriginX, int a_OriginZ)
 {
-	// TODO
+	return cStructurePtr(new cNetherFort(*this, a_OriginX, a_OriginZ, m_GridSizeX, m_MaxDepth, m_Seed));
 }
 
-
-
-
-
-void cNetherFortGen::GetFortsForChunk(int a_ChunkX, int a_ChunkZ, cNetherForts & a_Forts)
-{
-	int BaseX = a_ChunkX * cChunkDef::Width / m_GridSize;
-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_GridSize;
-	if (BaseX < 0)
-	{
-		--BaseX;
-	}
-	if (BaseZ < 0)
-	{
-		--BaseZ;
-	}
-	BaseX -= NEIGHBORHOOD_SIZE / 2;
-	BaseZ -= NEIGHBORHOOD_SIZE / 2;
-
-	// Walk the cache, move each cave system that we want into a_Forts:
-	int StartX = BaseX * m_GridSize;
-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
-	int StartZ = BaseZ * m_GridSize;
-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
-	for (cNetherForts::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
-	{
-		if (
-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
-		)
-		{
-			// want
-			a_Forts.push_back(*itr);
-			itr = m_Cache.erase(itr);
-		}
-		else
-		{
-			// don't want
-			++itr;
-		}
-	}  // for itr - m_Cache[]
-
-	// Create those forts that haven't been in the cache:
-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
-	{
-		int RealX = (BaseX + x) * m_GridSize;
-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
-		{
-			int RealZ = (BaseZ + z) * m_GridSize;
-			bool Found = false;
-			for (cNetherForts::const_iterator itr = a_Forts.begin(), end = a_Forts.end(); itr != end; ++itr)
-			{
-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
-				{
-					Found = true;
-					break;
-				}
-			}  // for itr - a_Mineshafts
-			if (!Found)
-			{
-				a_Forts.push_back(new cNetherFort(*this, RealX, RealZ, m_GridSize, m_MaxDepth, m_Seed));
-			}
-		}  // for z
-	}  // for x
-
-	// Copy a_Forts into m_Cache to the beginning:
-	cNetherForts FortsCopy (a_Forts);
-	m_Cache.splice(m_Cache.begin(), FortsCopy, FortsCopy.begin(), FortsCopy.end());
-
-	// Trim the cache if it's too long:
-	if (m_Cache.size() > 100)
-	{
-		cNetherForts::iterator itr = m_Cache.begin();
-		std::advance(itr, 100);
-		for (cNetherForts::iterator end = m_Cache.end(); itr != end; ++itr)
-		{
-			delete *itr;
-		}
-		itr = m_Cache.begin();
-		std::advance(itr, 100);
-		m_Cache.erase(itr, m_Cache.end());
-	}
-}
-
-
-
-
-
-void cNetherFortGen::GenFinish(cChunkDesc & a_ChunkDesc)
-{
-	int ChunkX = a_ChunkDesc.GetChunkX();
-	int ChunkZ = a_ChunkDesc.GetChunkZ();
-	cNetherForts Forts;
-	GetFortsForChunk(ChunkX, ChunkZ, Forts);
-	for (cNetherForts::const_iterator itr = Forts.begin(); itr != Forts.end(); ++itr)
-	{
-		(*itr)->ProcessChunk(a_ChunkDesc);
-	}  // for itr - Forts[]
-}
-
-
-
-
-
-cPieces cNetherFortGen::GetPiecesWithConnector(int a_ConnectorType)
-{
-	switch (a_ConnectorType)
-	{
-		case 0: return m_OuterPieces;
-		case 1: return m_InnerPieces;
-		default: return cPieces();
-	}
-}
-
-
-
-
-
-cPieces cNetherFortGen::GetStartingPieces(void)
-{
-	return m_StartingPieces;
-}
-
-
-
-
-
-int cNetherFortGen::GetPieceWeight(const cPlacedPiece & a_PlacedPiece, const cPiece::cConnector & a_ExistingConnector, const cPiece & a_NewPiece)
-{
-	return ((const cPrefab &)a_NewPiece).GetPieceWeight(a_PlacedPiece, a_ExistingConnector);
-}
-
-
-
-
-
-void cNetherFortGen::PiecePlaced(const cPiece & a_Piece)
-{
-	UNUSED(a_Piece);
-}
-
-
-
-
-
-void cNetherFortGen::Reset(void)
-{
-	// Nothing needed
-}
-
-
-
-
diff --git a/src/Generating/NetherFortGen.h b/src/Generating/NetherFortGen.h
index d51596b9e..f35801a3c 100644
--- a/src/Generating/NetherFortGen.h
+++ b/src/Generating/NetherFortGen.h
@@ -10,77 +10,34 @@
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "PieceGenerator.h"
+#include "PrefabPiecePool.h"
+#include "GridStructGen.h"
 
 
 
 
 
 class cNetherFortGen :
-	public cFinishGen,
-	public cPiecePool
+	public cGridStructGen
 {
+	typedef cGridStructGen super;
+	
 public:
 	cNetherFortGen(int a_Seed, int a_GridSize, int a_MaxDepth);
 	
-	virtual ~cNetherFortGen();
-	
 protected:
 	friend class cNetherFortPerfTest;  // fwd: NetherFortGen.cpp
 	class cNetherFort;  // fwd: NetherFortGen.cpp
-	typedef std::list<cNetherFort *> cNetherForts;
-	
-	
-	/** The seed used for generating*/
-	int m_Seed;
-	
-	/** The noise used for generating */
-	cNoise m_Noise;
-	
-	/** Average spacing between the fortresses*/
-	int m_GridSize;
 	
 	/** Maximum depth of the piece-generator tree */
 	int m_MaxDepth;
-
-	/** Cache of the most recently used systems. MoveToFront used. */
-	cNetherForts m_Cache;
 	
-	/** All the pieces that are allowed for building.
-	This is the list that's used for memory allocation and deallocation for the pieces. */
-	cPieces m_AllPieces;
+	/** The pool of pieces to use for generating. Static, so that it's shared by multiple generators. */
+	static cPrefabPiecePool m_PiecePool;
 	
-	/** The pieces that are used as starting pieces.
-	This list is not shared and the pieces need deallocation. */
-	cPieces m_StartingPieces;
-	
-	/** The pieces that have an "outer" connector.
-	The pieces are copies out of m_AllPieces and shouldn't be ever delete-d. */
-	cPieces m_OuterPieces;
-
-	/** The pieces that have an "inner" connector.
-	The pieces are copies out of m_AllPieces and shouldn't be ever delete-d. */
-	cPieces m_InnerPieces;
-
 
-	/** Clears everything from the cache.
-	Also invalidates the forst returned by GetFortsForChunk(). */
-	void ClearCache(void);
-	
-	/** Returns all forts that *may* intersect the given chunk.
-	The returned forts live within m_Cache.They are valid until the next call
-	to this function (which may delete some of the pointers).	*/
-	void GetFortsForChunk(int a_ChunkX, int a_ChunkZ, cNetherForts & a_Forts);
-
-	// cFinishGen overrides:
-	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
-	
-	// cPiecePool overrides:
-	virtual cPieces GetPiecesWithConnector(int a_ConnectorType) override;
-	virtual cPieces GetStartingPieces(void) override;
-	virtual int GetPieceWeight(const cPlacedPiece & a_PlacedPiece, const cPiece::cConnector & a_ExistingConnector, const cPiece & a_NewPiece) override;
-	virtual void PiecePlaced(const cPiece & a_Piece) override;
-	virtual void Reset(void) override;
+	// cGridStructGen overrides:
+	virtual cStructurePtr CreateStructure(int a_OriginX, int a_OriginZ) override;
 } ;
 
 
diff --git a/src/Generating/PrefabPiecePool.h b/src/Generating/PrefabPiecePool.h
index 2a7993063..c6a5ad360 100644
--- a/src/Generating/PrefabPiecePool.h
+++ b/src/Generating/PrefabPiecePool.h
@@ -20,11 +20,15 @@ class cPrefabPiecePool :
 	public cPiecePool
 {
 public:
+	/** Creates an empty instance. Prefabs can be added by calling AddPieceDefs() and AddStartingPieceDefs(). */
+	cPrefabPiecePool(void);
+	
 	/** Creates a piece pool with prefabs from the specified definitions.
 	If both a_PieceDefs and a_StartingPieceDefs are given, only the a_StartingPieceDefs are used as starting
 	pieces for the pool, and they do not participate in the generation any further.
 	If only a_PieceDefs is given, any such piece can be chosen as a starting piece, and all the pieces are used
-	for generating. */
+	for generating.
+	More pieces can be added to the instance afterwards by calling AddPieceDefs() and AddStartingPieceDefs(). */
 	cPrefabPiecePool(
 		const cPrefab::sDef * a_PieceDefs,         size_t a_NumPieceDefs,
 		const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs
@@ -35,7 +39,7 @@ public:
 	May be called multiple times with different PieceDefs, will add all such pieces. */
 	void AddPieceDefs(const cPrefab::sDef * a_PieceDefs, size_t a_NumPieceDefs);
 	
-	/** Adds pieces from the specified definitions into m_StartingPieces. Doesn't add to
+	/** Adds pieces from the specified definitions into m_StartingPieces. Doesn't add them to
 	the m_PiecesByConnector map.
 	May be called multiple times with different PieceDefs, will add all such pieces. */
 	void AddStartingPieceDefs(const cPrefab::sDef * a_StartingPieceDefs, size_t a_NumStartingPieceDefs);
-- 
cgit v1.2.3


From c4ea25e136026004526a63516cbed498e2b6fabe Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Thu, 8 May 2014 20:16:35 +0200
Subject: Fixed MSVC 64-bit build warnings.

---
 src/Generating/Caves.cpp          | 10 ++++++++--
 src/Generating/MineShafts.cpp     |  6 +++---
 src/Generating/PieceGenerator.cpp |  4 ++--
 src/Generating/Ravines.cpp        | 10 ++++++++--
 src/Generating/Trees.cpp          |  2 +-
 5 files changed, 22 insertions(+), 10 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/Caves.cpp b/src/Generating/Caves.cpp
index 5cad11d2a..6df22a14a 100644
--- a/src/Generating/Caves.cpp
+++ b/src/Generating/Caves.cpp
@@ -239,9 +239,15 @@ void cCaveTunnel::Randomize(cNoise & a_Noise)
 
 bool cCaveTunnel::RefineDefPoints(const cCaveDefPoints & a_Src, cCaveDefPoints & a_Dst)
 {
+	if (a_Src.size() < 2)
+	{
+		// There are no midpoints, nothing to smooth
+		return true;
+	}
+
 	// Smoothing: for each line segment, add points on its 1/4 lengths
 	bool res = false;
-	int Num = a_Src.size() - 2;  // this many intermediary points
+	size_t Num = a_Src.size() - 2;  // this many intermediary points
 	a_Dst.clear();
 	a_Dst.reserve(Num * 2 + 2);
 	cCaveDefPoints::const_iterator itr = a_Src.begin() + 1;
@@ -251,7 +257,7 @@ bool cCaveTunnel::RefineDefPoints(const cCaveDefPoints & a_Src, cCaveDefPoints &
 	int PrevY = Source.m_BlockY;
 	int PrevZ = Source.m_BlockZ;
 	int PrevR = Source.m_Radius;
-	for (int i = 0; i <= Num; ++i, ++itr)
+	for (size_t i = 0; i <= Num; ++i, ++itr)
 	{
 		int dx = itr->m_BlockX - PrevX;
 		int dy = itr->m_BlockY - PrevY;
diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index 231295c3f..af63e549b 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -543,7 +543,7 @@ cMineShaft * cMineShaftCorridor::CreateAndFit(
 {
 	cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
 	BoundingBox.p2.y += 3;
-	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
+	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + (int)a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
 	int NumSegments = 2 + (rnd) % (MAX_SEGMENTS - 1);  // 2 .. MAX_SEGMENTS
 	switch (a_Direction)
 	{
@@ -985,7 +985,7 @@ cMineShaft * cMineShaftCrossing::CreateAndFit(
 )
 {
 	cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
-	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
+	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + (int)a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
 	BoundingBox.p2.y += 3;
 	if ((rnd % 4) < 2)
 	{
@@ -1127,7 +1127,7 @@ cMineShaft * cMineShaftStaircase::CreateAndFit(
 	cNoise & a_Noise
 )
 {
-	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
+	int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + (int)a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
 	cCuboid Box;
 	switch (a_Direction)
 	{
diff --git a/src/Generating/PieceGenerator.cpp b/src/Generating/PieceGenerator.cpp
index db45cd08b..ce19c1c95 100644
--- a/src/Generating/PieceGenerator.cpp
+++ b/src/Generating/PieceGenerator.cpp
@@ -339,9 +339,9 @@ cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, i
 	int NumRotations = 1;
 	for (size_t i = 1; i < ARRAYCOUNT(Rotations); i++)
 	{
-		if (StartingPiece->CanRotateCCW(i))
+		if (StartingPiece->CanRotateCCW((int)i))
 		{
-			Rotations[NumRotations] = i;
+			Rotations[NumRotations] = (int)i;
 			NumRotations += 1;
 		}
 	}
diff --git a/src/Generating/Ravines.cpp b/src/Generating/Ravines.cpp
index 267dcbbf9..a036cf25f 100644
--- a/src/Generating/Ravines.cpp
+++ b/src/Generating/Ravines.cpp
@@ -306,8 +306,14 @@ void cStructGenRavines::cRavine::GenerateBaseDefPoints(int a_BlockX, int a_Block
 
 void cStructGenRavines::cRavine::RefineDefPoints(const cRavDefPoints & a_Src, cRavDefPoints & a_Dst)
 {
+	if (a_Src.size() < 2)
+	{
+		// No midpoints, nothing to refine
+		return;
+	}
+
 	// Smoothing: for each line segment, add points on its 1/4 lengths
-	int Num = a_Src.size() - 2;  // this many intermediary points
+	size_t Num = a_Src.size() - 2;  // this many intermediary points
 	a_Dst.clear();
 	a_Dst.reserve(Num * 2 + 2);
 	cRavDefPoints::const_iterator itr = a_Src.begin() + 1;
@@ -318,7 +324,7 @@ void cStructGenRavines::cRavine::RefineDefPoints(const cRavDefPoints & a_Src, cR
 	int PrevR = Source.m_Radius;
 	int PrevT = Source.m_Top;
 	int PrevB = Source.m_Bottom;
-	for (int i = 0; i <= Num; ++i, ++itr)
+	for (size_t i = 0; i <= Num; ++i, ++itr)
 	{
 		int dx = itr->m_BlockX - PrevX;
 		int dz = itr->m_BlockZ - PrevZ;
diff --git a/src/Generating/Trees.cpp b/src/Generating/Trees.cpp
index 4909587b1..4f1553c36 100644
--- a/src/Generating/Trees.cpp
+++ b/src/Generating/Trees.cpp
@@ -136,7 +136,7 @@ inline void PushSomeColumns(int a_BlockX, int a_Height, int a_BlockZ, int a_Colu
 	{
 		int x = a_BlockX + a_Coords[i].x;
 		int z = a_BlockZ + a_Coords[i].z;
-		if (a_Noise.IntNoise3DInt(x + 64 * a_Seq, a_Height + i, z + 64 * a_Seq) <= a_Chance)
+		if (a_Noise.IntNoise3DInt(x + 64 * a_Seq, a_Height + (int)i, z + 64 * a_Seq) <= a_Chance)
 		{
 			for (int j = 0; j < a_ColumnHeight; j++)
 			{
-- 
cgit v1.2.3


From ee680990ba12b8d272a34e45f372893f2525c868 Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Thu, 8 May 2014 21:10:55 +0200
Subject: Fixed cGridStructGen.

Now cNetherFortGen works with the new architecture.
---
 src/Generating/GridStructGen.cpp | 24 ++++++------------------
 1 file changed, 6 insertions(+), 18 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/GridStructGen.cpp b/src/Generating/GridStructGen.cpp
index 2f064d3a0..3bbc89054 100644
--- a/src/Generating/GridStructGen.cpp
+++ b/src/Generating/GridStructGen.cpp
@@ -39,29 +39,17 @@ void cGridStructGen::GetStructuresForChunk(int a_ChunkX, int a_ChunkZ, cStructur
 	int MinGridZ = MinBlockZ / m_GridSizeZ;
 	int MaxGridX = (MaxBlockX + m_GridSizeX - 1) / m_GridSizeX;
 	int MaxGridZ = (MaxBlockZ + m_GridSizeZ - 1) / m_GridSizeZ;
-	if (MinBlockX < 0)
-	{
-		--MinGridX;
-	}
-	if (MinBlockZ < 0)
-	{
-		--MinGridZ;
-	}
-	if (MaxBlockX < 0)
-	{
-		--MaxGridX;
-	}
-	if (MaxBlockZ < 0)
-	{
-		--MaxGridZ;
-	}
+	int MinX = MinGridX * m_GridSizeX;
+	int MaxX = MaxGridX * m_GridSizeX;
+	int MinZ = MinGridZ * m_GridSizeZ;
+	int MaxZ = MaxGridZ * m_GridSizeZ;
 
 	// Walk the cache, move each structure that we want into a_Structures:
 	for (cStructurePtrs::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
 	{
 		if (
-			((*itr)->m_OriginX >= MinBlockX) && ((*itr)->m_OriginX < MaxBlockX) &&
-			((*itr)->m_OriginZ >= MinBlockZ) && ((*itr)->m_OriginZ < MaxBlockZ)
+			((*itr)->m_OriginX >= MinX) && ((*itr)->m_OriginX < MaxX) &&
+			((*itr)->m_OriginZ >= MinZ) && ((*itr)->m_OriginZ < MaxZ)
 		)
 		{
 			// want
-- 
cgit v1.2.3


From 14543aa3fc204f38d0ab402d4c257d533619a983 Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 9 May 2014 10:59:33 +0200
Subject: Mineshafts generator rewritten to use GridStructGen.

---
 src/Generating/MineShafts.cpp | 155 ++++++------------------------------------
 src/Generating/MineShafts.h   |  34 ++++-----
 2 files changed, 33 insertions(+), 156 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index af63e549b..7b26c2b62 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -234,10 +234,12 @@ protected:
 
 
 
-class cStructGenMineShafts::cMineShaftSystem
+class cStructGenMineShafts::cMineShaftSystem :
+	public cGridStructGen::cStructure
 {
+	typedef cGridStructGen::cStructure super;
+
 public:
-	int         m_BlockX, m_BlockZ;    ///< The pivot point on which the system is generated
 	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
@@ -249,17 +251,15 @@ public:
 	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
+
+	/** Creates and generates the entire system */
 	cMineShaftSystem(
-		int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
+		int a_OriginX, int a_OriginZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
 		int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
 	);
 
 	~cMineShaftSystem();
 
-	/// Carves the system into the chunk data
-	void ProcessChunk(cChunkDesc & a_Chunk);
-
 	/** Creates new cMineShaft descendant connected at the specified point, heading the specified direction,
 	if it fits, appends it to the list and calls its AppendBranches()
 	*/
@@ -269,8 +269,11 @@ public:
 		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);
 } ;
 
 
@@ -281,11 +284,10 @@ public:
 // cStructGenMineShafts::cMineShaftSystem:
 
 cStructGenMineShafts::cMineShaftSystem::cMineShaftSystem(
-	int a_BlockX, int a_BlockZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
+	int a_OriginX, int a_OriginZ, int a_GridSize, int a_MaxSystemSize, cNoise & a_Noise,
 	int a_ProbLevelCorridor, int a_ProbLevelCrossing, int a_ProbLevelStaircase
 ) :
-	m_BlockX(a_BlockX),
-	m_BlockZ(a_BlockZ),
+	super(a_OriginX, a_OriginZ),
 	m_GridSize(a_GridSize),
 	m_MaxRecursion(8),  // TODO: settable
 	m_ProbLevelCorridor(a_ProbLevelCorridor),
@@ -330,7 +332,7 @@ cStructGenMineShafts::cMineShaftSystem::~cMineShaftSystem()
 
 
 
-void cStructGenMineShafts::cMineShaftSystem::ProcessChunk(cChunkDesc & a_Chunk)
+void cStructGenMineShafts::cMineShaftSystem::DrawIntoChunk(cChunkDesc & a_Chunk)
 {
 	for (cMineShafts::const_iterator itr = m_MineShafts.begin(), end = m_MineShafts.end(); itr != end; ++itr)
 	{
@@ -409,15 +411,15 @@ cMineShaftDirtRoom::cMineShaftDirtRoom(cStructGenMineShafts::cMineShaftSystem &
 	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_BlockX, 0, a_Parent.m_BlockZ) / 7;
+	int rnd = a_Noise.IntNoise3DInt(a_Parent.m_OriginX, 0, a_Parent.m_OriginZ) / 7;
 	int OfsX = (rnd % a_Parent.m_GridSize) - a_Parent.m_GridSize / 2;
 	rnd >>= 12;
 	int OfsZ = (rnd % a_Parent.m_GridSize) - a_Parent.m_GridSize / 2;
-	rnd = a_Noise.IntNoise3DInt(a_Parent.m_BlockX, 1000, a_Parent.m_BlockZ) / 11;
-	m_BoundingBox.p1.x = a_Parent.m_BlockX + OfsX;
+	rnd = a_Noise.IntNoise3DInt(a_Parent.m_OriginX, 1000, a_Parent.m_OriginZ) / 11;
+	m_BoundingBox.p1.x = a_Parent.m_OriginX + OfsX;
 	m_BoundingBox.p2.x = m_BoundingBox.p1.x + 10 + (rnd % 8);
 	rnd >>= 4;
-	m_BoundingBox.p1.z = a_Parent.m_BlockZ + OfsZ;
+	m_BoundingBox.p1.z = a_Parent.m_OriginZ + OfsZ;
 	m_BoundingBox.p2.z = m_BoundingBox.p1.z + 10 + (rnd % 8);
 	rnd >>= 4;
 	m_BoundingBox.p1.y = 20;
@@ -1287,6 +1289,7 @@ cStructGenMineShafts::cStructGenMineShafts(
 	int a_Seed, int a_GridSize, int a_MaxSystemSize,
 	int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
 ) :
+	super(a_Seed, a_GridSize, a_GridSize, 120 + a_MaxSystemSize * 10, 120 + a_MaxSystemSize * 10, 100),
 	m_Noise(a_Seed),
 	m_GridSize(a_GridSize),
 	m_MaxSystemSize(a_MaxSystemSize),
@@ -1300,125 +1303,9 @@ cStructGenMineShafts::cStructGenMineShafts(
 
 
 
-cStructGenMineShafts::~cStructGenMineShafts()
-{
-	ClearCache();
-}
-
-
-
-
-
-void cStructGenMineShafts::ClearCache(void)
+cGridStructGen::cStructurePtr cStructGenMineShafts::CreateStructure(int a_OriginX, int a_OriginZ)
 {
-	for (cMineShaftSystems::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
-	{
-		delete *itr;
-	}  // for itr - m_Cache[]
-	m_Cache.clear();
-}
-
-
-
-
-
-void cStructGenMineShafts::GetMineShaftSystemsForChunk(
-	int a_ChunkX, int a_ChunkZ,
-	cStructGenMineShafts::cMineShaftSystems & a_MineShafts
-)
-{
-	int BaseX = a_ChunkX * cChunkDef::Width / m_GridSize;
-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_GridSize;
-	if (BaseX < 0)
-	{
-		--BaseX;
-	}
-	if (BaseZ < 0)
-	{
-		--BaseZ;
-	}
-	BaseX -= NEIGHBORHOOD_SIZE / 2;
-	BaseZ -= NEIGHBORHOOD_SIZE / 2;
-
-	// Walk the cache, move each cave system that we want into a_Mineshafts:
-	int StartX = BaseX * m_GridSize;
-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
-	int StartZ = BaseZ * m_GridSize;
-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_GridSize;
-	for (cMineShaftSystems::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
-	{
-		if (
-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
-		)
-		{
-			// want
-			a_MineShafts.push_back(*itr);
-			itr = m_Cache.erase(itr);
-		}
-		else
-		{
-			// don't want
-			++itr;
-		}
-	}  // for itr - m_Cache[]
-
-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
-	{
-		int RealX = (BaseX + x) * m_GridSize;
-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
-		{
-			int RealZ = (BaseZ + z) * m_GridSize;
-			bool Found = false;
-			for (cMineShaftSystems::const_iterator itr = a_MineShafts.begin(), end = a_MineShafts.end(); itr != end; ++itr)
-			{
-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
-				{
-					Found = true;
-					break;
-				}
-			}  // for itr - a_Mineshafts
-			if (!Found)
-			{
-				a_MineShafts.push_back(new cMineShaftSystem(RealX, RealZ, m_GridSize, m_MaxSystemSize, m_Noise, m_ProbLevelCorridor, m_ProbLevelCrossing, m_ProbLevelStaircase));
-			}
-		}  // for z
-	}  // for x
-
-	// Copy a_MineShafts into m_Cache to the beginning:
-	cMineShaftSystems MineShaftsCopy(a_MineShafts);
-	m_Cache.splice(m_Cache.begin(), MineShaftsCopy, MineShaftsCopy.begin(), MineShaftsCopy.end());
-
-	// Trim the cache if it's too long:
-	if (m_Cache.size() > 100)
-	{
-		cMineShaftSystems::iterator itr = m_Cache.begin();
-		std::advance(itr, 100);
-		for (cMineShaftSystems::iterator end = m_Cache.end(); itr != end; ++itr)
-		{
-			delete *itr;
-		}
-		itr = m_Cache.begin();
-		std::advance(itr, 100);
-		m_Cache.erase(itr, m_Cache.end());
-	}
-}
-
-
-
-
-
-
-void cStructGenMineShafts::GenFinish(cChunkDesc & a_ChunkDesc)
-{
-	int ChunkX = a_ChunkDesc.GetChunkX();
-	int ChunkZ = a_ChunkDesc.GetChunkZ();
-	cMineShaftSystems MineShafts;
-	GetMineShaftSystemsForChunk(ChunkX, ChunkZ, MineShafts);
-	for (cMineShaftSystems::const_iterator itr = MineShafts.begin(); itr != MineShafts.end(); ++itr)
-	{
-		(*itr)->ProcessChunk(a_ChunkDesc);
-	}  // for itr - MineShafts[]
+	return cStructurePtr(new cMineShaftSystem(a_OriginX, a_OriginZ, m_GridSize, m_MaxSystemSize, m_Noise, m_ProbLevelCorridor, m_ProbLevelCrossing, m_ProbLevelStaircase));
 }
 
 
diff --git a/src/Generating/MineShafts.h b/src/Generating/MineShafts.h
index ba32e75ad..c29b6cdac 100644
--- a/src/Generating/MineShafts.h
+++ b/src/Generating/MineShafts.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "ComposableGenerator.h"
+#include "GridStructGen.h"
 #include "../Noise.h"
 
 
@@ -17,16 +17,16 @@
 
 
 class cStructGenMineShafts :
-	public cFinishGen
+	public cGridStructGen
 {
+	typedef cGridStructGen super;
+
 public:
 	cStructGenMineShafts(
 		int a_Seed, int a_GridSize, int a_MaxSystemSize,
 		int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
 	);
 	
-	virtual ~cStructGenMineShafts();
-	
 protected:
 	friend class cMineShaft;
 	friend class cMineShaftDirtRoom;
@@ -34,26 +34,16 @@ protected:
 	friend class cMineShaftCrossing;
 	friend class cMineShaftStaircase;
 	class cMineShaftSystem;  // fwd: MineShafts.cpp
-	typedef std::list<cMineShaftSystem *> cMineShaftSystems;
 	
-	cNoise            m_Noise;
-	int               m_GridSize;            ///< Average spacing of the systems
-	int               m_MaxSystemSize;       ///< Maximum blcok size of a mineshaft system
-	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
-	cMineShaftSystems m_Cache;               ///< Cache of the most recently used systems. MoveToFront used.
+	cNoise m_Noise;
+	int    m_GridSize;            ///< Average spacing of the systems
+	int    m_MaxSystemSize;       ///< Maximum blcok size of a mineshaft system
+	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
 	
-	/// Clears everything from the cache
-	void ClearCache(void);
-	
-	/** Returns all systems that *may* intersect the given chunk.
-	All the systems are valid until the next call to this function (which may delete some of the pointers).
-	*/
-	void GetMineShaftSystemsForChunk(int a_ChunkX, int a_ChunkZ, cMineShaftSystems & a_MineShaftSystems);
-
-	// cFinishGen overrides:
-	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+	// cGridStructGen overrides:
+	virtual cStructurePtr CreateStructure(int a_OriginX, int a_OriginZ) override;
 } ;
 
 
-- 
cgit v1.2.3


From 95ead1128f85b2f0935c6c0b575a13acbec27b6b Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 9 May 2014 11:16:13 +0200
Subject: cWormNestCaves rewritten using cGridStructGen.

Ref.: #987.
---
 src/Generating/Caves.cpp | 230 +++++------------------------------------------
 src/Generating/Caves.h   |  22 ++---
 2 files changed, 29 insertions(+), 223 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/Caves.cpp b/src/Generating/Caves.cpp
index 6df22a14a..48663c21a 100644
--- a/src/Generating/Caves.cpp
+++ b/src/Generating/Caves.cpp
@@ -122,27 +122,19 @@ 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;
+
 public:
 	// The generating block position; is read directly in cStructGenWormNestCaves::GetCavesForChunk()
 	int m_BlockX;
 	int m_BlockZ;
 
-	cCaveSystem(int a_BlockX, int a_BlockZ, int a_MaxOffset, int a_Size, cNoise & a_Noise);
+	cCaveSystem(int a_OriginX, int a_OriginZ, int a_MaxOffset, int a_Size, cNoise & a_Noise);
 	~cCaveSystem();
 
-	/// Carves the cave system into the chunk specified
-	void ProcessChunk(
-		int a_ChunkX, int a_ChunkZ,
-		cChunkDef::BlockTypes & a_BlockTypes,
-		cChunkDef::HeightMap & a_HeightMap
-	);
-
-	#ifdef _DEBUG
-	AString ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const;
-	#endif  // _DEBUG
-
 protected:
 	int m_Size;
 	cCaveTunnels m_Tunnels;
@@ -157,6 +149,9 @@ protected:
 
 	/// Returns a radius based on the location provided.
 	int GetRadius(cNoise & a_Noise, int a_OriginX, int a_OriginY, int a_OriginZ);
+
+	// cGridStructGen::cStructure overrides:
+	virtual void DrawIntoChunk(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -586,17 +581,16 @@ AString cCaveTunnel::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) cons
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenWormNestCaves::cCaveSystem:
 
-cStructGenWormNestCaves::cCaveSystem::cCaveSystem(int a_BlockX, int a_BlockZ, int a_MaxOffset, int a_Size, cNoise & a_Noise) :
-	m_BlockX(a_BlockX),
-	m_BlockZ(a_BlockZ),
+cStructGenWormNestCaves::cCaveSystem::cCaveSystem(int a_OriginX, int a_OriginZ, int a_MaxOffset, int a_Size, cNoise & a_Noise) :
+	super(a_OriginX, a_OriginZ),
 	m_Size(a_Size)
 {
-	int Num = 1 + a_Noise.IntNoise2DInt(a_BlockX, a_BlockZ) % 3;
+	int Num = 1 + a_Noise.IntNoise2DInt(a_OriginX, a_OriginZ) % 3;
 	for (int i = 0; i < Num; i++)
 	{
-		int OriginX = a_BlockX + (a_Noise.IntNoise3DInt(13 * a_BlockX, 17 * a_BlockZ, 11 * i) / 19) % a_MaxOffset;
-		int OriginZ = a_BlockZ + (a_Noise.IntNoise3DInt(17 * a_BlockX, 13 * a_BlockZ, 11 * i) / 23) % a_MaxOffset;
-		int OriginY  = 20 + (a_Noise.IntNoise3DInt(19 * a_BlockX, 13 * a_BlockZ, 11 * i) / 17) % 20;
+		int OriginX = a_OriginX + (a_Noise.IntNoise3DInt(13 * a_OriginX, 17 * a_OriginZ, 11 * i) / 19) % a_MaxOffset;
+		int OriginZ = a_OriginZ + (a_Noise.IntNoise3DInt(17 * a_OriginX, 13 * a_OriginZ, 11 * i) / 23) % a_MaxOffset;
+		int OriginY  = 20 + (a_Noise.IntNoise3DInt(19 * a_OriginX, 13 * a_OriginZ, 11 * i) / 17) % 20;
 
 		// Generate three branches from the origin point:
 		// The tunnels generated depend on X, Y, Z and Branches,
@@ -622,64 +616,17 @@ cStructGenWormNestCaves::cCaveSystem::~cCaveSystem()
 
 
 
-void cStructGenWormNestCaves::cCaveSystem::ProcessChunk(
-	int a_ChunkX, int a_ChunkZ,
-	cChunkDef::BlockTypes & a_BlockTypes,
-	cChunkDef::HeightMap & a_HeightMap
-)
-{
-	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)
-	{
-		(*itr)->ProcessChunk(a_ChunkX, a_ChunkZ, a_BlockTypes, a_HeightMap);
-	}  // for itr - m_Tunnels[]
-}
-
-
-
-
-
-#ifdef _DEBUG
-AString cStructGenWormNestCaves::cCaveSystem::ExportAsSVG(int a_Color, int a_OffsetX, int a_OffsetZ) const
+void cStructGenWormNestCaves::cCaveSystem::DrawIntoChunk(cChunkDesc & a_ChunkDesc)
 {
-	AString SVG;
-	SVG.reserve(512 * 1024);
+	int ChunkX = a_ChunkDesc.GetChunkX();
+	int ChunkZ = a_ChunkDesc.GetChunkZ();
+	cChunkDef::BlockTypes & BlockTypes = a_ChunkDesc.GetBlockTypes();
+	cChunkDef::HeightMap &  HeightMap  = a_ChunkDesc.GetHeightMap();
 	for (cCaveTunnels::const_iterator itr = m_Tunnels.begin(), end = m_Tunnels.end(); itr != end; ++itr)
 	{
-		SVG.append((*itr)->ExportAsSVG(a_Color, a_OffsetX, a_OffsetZ));
+		(*itr)->ProcessChunk(ChunkX, ChunkZ, BlockTypes, HeightMap);
 	}  // for itr - m_Tunnels[]
-
-	// Base point highlight:
-	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
-		a_OffsetX + m_BlockX - 5, a_OffsetZ + m_BlockZ, a_OffsetX + m_BlockX + 5, a_OffsetZ + m_BlockZ
-	);
-	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ - 5, a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ + 5
-	);
-
-	// A gray line from the base point to the first point of the ravine, for identification:
-	AppendPrintf(SVG, "<path style=\"fill:none;stroke:#cfcfcf;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ,
-		a_OffsetX + m_Tunnels.front()->m_Points.front().m_BlockX,
-		a_OffsetZ + m_Tunnels.front()->m_Points.front().m_BlockZ
-	);
-
-	// Offset guides:
-	if (a_OffsetX > 0)
-	{
-		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M %d,0 L %d,1024\"/>\n",
-			a_OffsetX, a_OffsetX
-		);
-	}
-	if (a_OffsetZ > 0)
-	{
-		AppendPrintf(SVG, "<path style=\"fill:none;stroke:#0000ff;stroke-width:1px;\"\nd=\"M 0,%d L 1024,%d\"/>\n",
-			a_OffsetZ, a_OffsetZ
-		);
-	}
-
-	return SVG;
 }
-#endif  // _DEBUG
 
 
 
@@ -750,142 +697,9 @@ int cStructGenWormNestCaves::cCaveSystem::GetRadius(cNoise & a_Noise, int a_Orig
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenWormNestCaves:
 
-cStructGenWormNestCaves::~cStructGenWormNestCaves()
-{
-	ClearCache();
-}
-
-
-
-
-
-void cStructGenWormNestCaves::ClearCache(void)
-{
-	for (cCaveSystems::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
-	{
-		delete *itr;
-	}  // for itr - m_Cache[]
-	m_Cache.clear();
-}
-
-
-
-
-
-void cStructGenWormNestCaves::GenFinish(cChunkDesc & a_ChunkDesc)
+cGridStructGen::cStructurePtr cStructGenWormNestCaves::CreateStructure(int a_OriginX, int a_OriginZ)
 {
-	int ChunkX = a_ChunkDesc.GetChunkX();
-	int ChunkZ = a_ChunkDesc.GetChunkZ();
-	cCaveSystems Caves;
-	GetCavesForChunk(ChunkX, ChunkZ, Caves);
-	for (cCaveSystems::const_iterator itr = Caves.begin(); itr != Caves.end(); ++itr)
-	{
-		(*itr)->ProcessChunk(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
-	}  // for itr - Caves[]
-}
-
-
-
-
-
-void cStructGenWormNestCaves::GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cStructGenWormNestCaves::cCaveSystems & a_Caves)
-{
-	int BaseX = a_ChunkX * cChunkDef::Width / m_Grid;
-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_Grid;
-	if (BaseX < 0)
-	{
-		--BaseX;
-	}
-	if (BaseZ < 0)
-	{
-		--BaseZ;
-	}
-	BaseX -= NEIGHBORHOOD_SIZE / 2;
-	BaseZ -= NEIGHBORHOOD_SIZE / 2;
-
-	// Walk the cache, move each cave system that we want into a_Caves:
-	int StartX = BaseX * m_Grid;
-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_Grid;
-	int StartZ = BaseZ * m_Grid;
-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_Grid;
-	for (cCaveSystems::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
-	{
-		if (
-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
-		)
-		{
-			// want
-			a_Caves.push_back(*itr);
-			itr = m_Cache.erase(itr);
-		}
-		else
-		{
-			// don't want
-			++itr;
-		}
-	}  // for itr - m_Cache[]
-
-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
-	{
-		int RealX = (BaseX + x) * m_Grid;
-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
-		{
-			int RealZ = (BaseZ + z) * m_Grid;
-			bool Found = false;
-			for (cCaveSystems::const_iterator itr = a_Caves.begin(), end = a_Caves.end(); itr != end; ++itr)
-			{
-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
-				{
-					Found = true;
-					break;
-				}
-			}
-			if (!Found)
-			{
-				a_Caves.push_back(new cCaveSystem(RealX, RealZ, m_MaxOffset, m_Size, m_Noise));
-			}
-		}
-	}
-
-	// Copy a_Caves into m_Cache to the beginning:
-	cCaveSystems CavesCopy(a_Caves);
-	m_Cache.splice(m_Cache.begin(), CavesCopy, CavesCopy.begin(), CavesCopy.end());
-
-	// Trim the cache if it's too long:
-	if (m_Cache.size() > 100)
-	{
-		cCaveSystems::iterator itr = m_Cache.begin();
-		std::advance(itr, 100);
-		for (cCaveSystems::iterator end = m_Cache.end(); itr != end; ++itr)
-		{
-			delete *itr;
-		}
-		itr = m_Cache.begin();
-		std::advance(itr, 100);
-		m_Cache.erase(itr, m_Cache.end());
-	}
-
-	/*
-	// Uncomment this block for debugging the caves' shapes in 2D using an SVG export
-	#ifdef _DEBUG
-	AString SVG;
-	SVG.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1024\" height = \"1024\">\n");
-	SVG.reserve(2 * 1024 * 1024);
-	for (cCaveSystems::const_iterator itr = a_Caves.begin(), end = a_Caves.end(); itr != end; ++itr)
-	{
-		int Color = 0x10 * abs((*itr)->m_BlockX / m_Grid);
-		Color |= 0x1000 * abs((*itr)->m_BlockZ / m_Grid);
-		SVG.append((*itr)->ExportAsSVG(Color, 512, 512));
-	}
-	SVG.append("</svg>\n");
-
-	AString fnam;
-	Printf(fnam, "wnc\\%03d_%03d.svg", a_ChunkX, a_ChunkZ);
-	cFile File(fnam, cFile::fmWrite);
-	File.Write(SVG.c_str(), SVG.size());
-	#endif  // _DEBUG
-	//*/
+	return cStructurePtr(new cCaveSystem(a_OriginX, a_OriginZ, m_MaxOffset, m_Size, m_Noise));
 }
 
 
diff --git a/src/Generating/Caves.h b/src/Generating/Caves.h
index 2a9fa01b8..254dcddbd 100644
--- a/src/Generating/Caves.h
+++ b/src/Generating/Caves.h
@@ -12,7 +12,7 @@
 
 #pragma once
 
-#include "ComposableGenerator.h"
+#include "GridStructGen.h"
 #include "../Noise.h"
 
 
@@ -64,10 +64,12 @@ protected:
 
 
 class cStructGenWormNestCaves :
-	public cFinishGen
+	public cGridStructGen
 {
+	typedef cGridStructGen super;
 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_Size + a_MaxOffset, a_Size + a_MaxOffset, 100),
 		m_Noise(a_Seed),
 		m_Size(a_Size),
 		m_MaxOffset(a_MaxOffset),
@@ -75,26 +77,16 @@ public:
 	{
 	}
 	
-	~cStructGenWormNestCaves();
-	
 protected:
 	class cCaveSystem;  // fwd: Caves.cpp
-	typedef std::list<cCaveSystem *> cCaveSystems;
 
 	cNoise       m_Noise;
 	int          m_Size;  // relative size of the cave systems' caves. Average number of blocks of each initial tunnel
 	int          m_MaxOffset;  // maximum offset of the cave nest origin from the grid cell the nest belongs to
 	int          m_Grid;  // average spacing of the nests
-	cCaveSystems m_Cache;
-	
-	/// Clears everything from the cache
-	void ClearCache(void);
-	
-	/// Returns all caves that *may* intersect the given chunk. All the caves are valid until the next call to this function.
-	void GetCavesForChunk(int a_ChunkX, int a_ChunkZ, cCaveSystems & a_Caves);
-	
-	// cFinishGen override:
-	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+
+	// cGridStructGen override:
+	virtual cStructurePtr CreateStructure(int a_OriginX, int a_OriginZ) override;
 } ;
 
 
-- 
cgit v1.2.3


From ea593dcaad59bf6e91da59ec5dadc64b9b803580 Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 9 May 2014 18:30:39 +0200
Subject: Ravines rewritten using cGridStructGen.

Ref.: #987.
---
 src/Generating/Ravines.cpp | 198 +++++++--------------------------------------
 src/Generating/Ravines.h   |  24 +++---
 2 files changed, 40 insertions(+), 182 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/Ravines.cpp b/src/Generating/Ravines.cpp
index a036cf25f..78093f5ee 100644
--- a/src/Generating/Ravines.cpp
+++ b/src/Generating/Ravines.cpp
@@ -42,40 +42,38 @@ typedef std::vector<cRavDefPoint> cRavDefPoints;
 
 
 
-class cStructGenRavines::cRavine
+class cStructGenRavines::cRavine :
+	public cGridStructGen::cStructure
 {
+	typedef cGridStructGen::cStructure super;
+
 	cRavDefPoints m_Points;
+
 	
-	/// Generates the shaping defpoints for the ravine, based on the ravine block coords and noise
+	/** Generates the shaping defpoints for the ravine, based on the ravine block coords and noise */
 	void GenerateBaseDefPoints(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise);
 	
-	/// Refines (adds and smooths) defpoints from a_Src into a_Dst
+	/** Refines (adds and smooths) defpoints from a_Src into a_Dst */
 	void RefineDefPoints(const cRavDefPoints & a_Src, cRavDefPoints & a_Dst);
 	
-	/// Does one round of smoothing, two passes of RefineDefPoints()
+	/** Does one round of smoothing, two passes of RefineDefPoints() */
 	void Smooth(void);
 	
-	/// Linearly interpolates the points so that the maximum distance between two neighbors is max 1 block
+	/** Linearly interpolates the points so that the maximum distance between two neighbors is max 1 block */
 	void FinishLinear(void);
 	
 public:
-	// Coords for which the ravine was generated (not necessarily the center)
-	int m_BlockX;
-	int m_BlockZ;
 	
 	cRavine(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise);
 	
-	/// Carves the ravine into the chunk specified
-	void ProcessChunk(
-		int a_ChunkX, int a_ChunkZ, 
-		cChunkDef::BlockTypes & a_BlockTypes, 
-		cChunkDef::HeightMap & a_HeightMap
-	);
-	
 	#ifdef _DEBUG
 	/// Exports itself as a SVG line definition
 	AString ExportAsSVG(int a_Color, int a_OffsetX = 0, int a_OffsetZ = 0) const;
 	#endif  // _DEBUG
+
+protected:
+	// cGridStructGen::cStructure overrides:
+	virtual void DrawIntoChunk(cChunkDesc & a_ChunkDesc) override;
 } ;
 
 
@@ -86,6 +84,7 @@ public:
 // cStructGenRavines:
 
 cStructGenRavines::cStructGenRavines(int a_Seed, int a_Size) :
+	super(a_Seed, a_Size, a_Size, a_Size * 2, a_Size * 2, 100),
 	m_Noise(a_Seed),
 	m_Size(a_Size)
 {
@@ -95,139 +94,9 @@ cStructGenRavines::cStructGenRavines(int a_Seed, int a_Size) :
 
 
 
-cStructGenRavines::~cStructGenRavines()
+cGridStructGen::cStructurePtr cStructGenRavines::CreateStructure(int a_OriginX, int a_OriginZ)
 {
-	ClearCache();
-}
-
-
-
-
-
-void cStructGenRavines::ClearCache(void)
-{
-	for (cRavines::const_iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end; ++itr)
-	{
-		delete *itr;
-	}  // for itr - m_Cache[]
-	m_Cache.clear();
-}
-
-
-
-
-
-void cStructGenRavines::GenFinish(cChunkDesc & a_ChunkDesc)
-{
-	int ChunkX = a_ChunkDesc.GetChunkX();
-	int ChunkZ = a_ChunkDesc.GetChunkZ();
-	cRavines Ravines;
-	GetRavinesForChunk(ChunkX, ChunkZ, Ravines);
-	for (cRavines::const_iterator itr = Ravines.begin(), end = Ravines.end(); itr != end; ++itr)
-	{
-		(*itr)->ProcessChunk(ChunkX, ChunkZ, a_ChunkDesc.GetBlockTypes(), a_ChunkDesc.GetHeightMap());
-	}  // for itr - Ravines[]
-}
-
-
-
-
-
-void cStructGenRavines::GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cStructGenRavines::cRavines & a_Ravines)
-{
-	int BaseX = a_ChunkX * cChunkDef::Width / m_Size;
-	int BaseZ = a_ChunkZ * cChunkDef::Width / m_Size;
-	if (BaseX < 0)
-	{
-		--BaseX;
-	}
-	if (BaseZ < 0)
-	{
-		--BaseZ;
-	}
-	BaseX -= 4;
-	BaseZ -= 4;
-	
-	// Walk the cache, move each ravine that we want into a_Ravines:
-	int StartX = BaseX * m_Size;
-	int EndX = (BaseX + NEIGHBORHOOD_SIZE + 1) * m_Size;
-	int StartZ = BaseZ * m_Size;
-	int EndZ = (BaseZ + NEIGHBORHOOD_SIZE + 1) * m_Size;
-	for (cRavines::iterator itr = m_Cache.begin(), end = m_Cache.end(); itr != end;)
-	{
-		if (
-			((*itr)->m_BlockX >= StartX) && ((*itr)->m_BlockX < EndX) &&
-			((*itr)->m_BlockZ >= StartZ) && ((*itr)->m_BlockZ < EndZ)
-		)
-		{
-			// want
-			a_Ravines.push_back(*itr);
-			itr = m_Cache.erase(itr);
-		}
-		else
-		{
-			// don't want
-			++itr;
-		}
-	}  // for itr - m_Cache[]
-	
-	for (int x = 0; x < NEIGHBORHOOD_SIZE; x++)
-	{
-		int RealX = (BaseX + x) * m_Size;
-		for (int z = 0; z < NEIGHBORHOOD_SIZE; z++)
-		{
-			int RealZ = (BaseZ + z) * m_Size;
-			bool Found = false;
-			for (cRavines::const_iterator itr = a_Ravines.begin(), end = a_Ravines.end(); itr != end; ++itr)
-			{
-				if (((*itr)->m_BlockX == RealX) && ((*itr)->m_BlockZ == RealZ))
-				{
-					Found = true;
-					break;
-				}
-			}
-			if (!Found)
-			{
-				a_Ravines.push_back(new cRavine(RealX, RealZ, m_Size, m_Noise));
-			}
-		}
-	}
-	
-	// Copy a_Ravines into m_Cache to the beginning:
-	cRavines RavinesCopy(a_Ravines);
-	m_Cache.splice(m_Cache.begin(), RavinesCopy, RavinesCopy.begin(), RavinesCopy.end());
-	
-	// Trim the cache if it's too long:
-	if (m_Cache.size() > 100)
-	{
-		cRavines::iterator itr = m_Cache.begin();
-		std::advance(itr, 100);
-		for (cRavines::iterator end = m_Cache.end(); itr != end; ++itr)
-		{
-			delete *itr;
-		}
-		itr = m_Cache.begin();
-		std::advance(itr, 100);
-		m_Cache.erase(itr, m_Cache.end());
-	}
-	
-	/*
-	#ifdef _DEBUG
-	// DEBUG: Export as SVG into a file specific for the chunk, for visual verification:
-	AString SVG;
-	SVG.append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1024\" height = \"1024\">\n");
-	for (cRavines::const_iterator itr = a_Ravines.begin(), end = a_Ravines.end(); itr != end; ++itr)
-	{
-		SVG.append((*itr)->ExportAsSVG(0, 512, 512));
-	}
-	SVG.append("</svg>\n");
-	
-	AString fnam;
-	Printf(fnam, "ravines\\%03d_%03d.svg", a_ChunkX, a_ChunkZ);
-	cFile File(fnam, cFile::fmWrite);
-	File.Write(SVG.c_str(), SVG.size());
-	#endif  // _DEBUG
-	//*/
+	return cStructurePtr(new cRavine(a_OriginX, a_OriginZ, m_Size, m_Noise));
 }
 
 
@@ -238,14 +107,13 @@ void cStructGenRavines::GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cStructGe
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cStructGenRavines::cRavine
 
-cStructGenRavines::cRavine::cRavine(int a_BlockX, int a_BlockZ, int a_Size, cNoise & a_Noise) :
-	m_BlockX(a_BlockX),
-	m_BlockZ(a_BlockZ)
+cStructGenRavines::cRavine::cRavine(int a_OriginX, int a_OriginZ, int a_Size, cNoise & a_Noise) :
+	super(a_OriginX, a_OriginZ)
 {
 	// Calculate the ravine shape-defining points:
-	GenerateBaseDefPoints(a_BlockX, a_BlockZ, a_Size, a_Noise);
+	GenerateBaseDefPoints(a_OriginX, a_OriginZ, a_Size, a_Noise);
 	
-	// Smooth the ravine. A two passes are needed:
+	// Smooth the ravine. Two passes are needed:
 	Smooth();
 	Smooth();
 	
@@ -263,8 +131,8 @@ void cStructGenRavines::cRavine::GenerateBaseDefPoints(int a_BlockX, int a_Block
 	a_Size = (512 + ((a_Noise.IntNoise3DInt(19 * a_BlockX, 11 * a_BlockZ, a_BlockX + a_BlockZ) / 17) % 512)) * a_Size / 1024;
 	
 	// The complete offset of the ravine from its cellpoint, up to 2 * a_Size in each direction
-	int OffsetX = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 0)    / 9) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * m_BlockZ, 1000) / 7) % (2 * a_Size)) - 2 * a_Size) / 2;
-	int OffsetZ = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 2000) / 7) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * m_BlockZ, 3000) / 9) % (2 * a_Size)) - 2 * a_Size) / 2;
+	int OffsetX = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 0)    / 9) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * a_BlockZ, 1000) / 7) % (2 * a_Size)) - 2 * a_Size) / 2;
+	int OffsetZ = (((a_Noise.IntNoise3DInt(50 * a_BlockX, 30 * a_BlockZ, 2000) / 7) % (2 * a_Size)) + ((a_Noise.IntNoise3DInt(30 * a_BlockX, 50 * a_BlockZ, 3000) / 9) % (2 * a_Size)) - 2 * a_Size) / 2;
 	int CenterX = a_BlockX + OffsetX;
 	int CenterZ = a_BlockZ + OffsetZ;
 	
@@ -429,15 +297,15 @@ AString cStructGenRavines::cRavine::ExportAsSVG(int a_Color, int a_OffsetX, int
   
   // Base point highlight:
   AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
-		a_OffsetX + m_BlockX - 5, a_OffsetZ + m_BlockZ, a_OffsetX + m_BlockX + 5, a_OffsetZ + m_BlockZ
+		a_OffsetX + m_OriginX - 5, a_OffsetZ + m_OriginZ, a_OffsetX + m_OriginX + 5, a_OffsetZ + m_OriginZ
 	);
   AppendPrintf(SVG, "<path style=\"fill:none;stroke:#ff0000;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ - 5, a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ + 5
+		a_OffsetX + m_OriginX, a_OffsetZ + m_OriginZ - 5, a_OffsetX + m_OriginX, a_OffsetZ + m_OriginZ + 5
 	);
 	
 	// A gray line from the base point to the first point of the ravine, for identification:
   AppendPrintf(SVG, "<path style=\"fill:none;stroke:#cfcfcf;stroke-width:1px;\"\nd=\"M %d,%d L %d,%d\"/>\n",
-		a_OffsetX + m_BlockX, a_OffsetZ + m_BlockZ, a_OffsetX + m_Points.front().m_BlockX, a_OffsetZ + m_Points.front().m_BlockZ
+		a_OffsetX + m_OriginX, a_OffsetZ + m_OriginZ, a_OffsetX + m_Points.front().m_BlockX, a_OffsetZ + m_Points.front().m_BlockZ
 	);
 	
 	// Offset guides:
@@ -461,14 +329,10 @@ AString cStructGenRavines::cRavine::ExportAsSVG(int a_Color, int a_OffsetX, int
 
 
 
-void cStructGenRavines::cRavine::ProcessChunk(
-	int a_ChunkX, int a_ChunkZ, 
-	cChunkDef::BlockTypes & a_BlockTypes,
-	cChunkDef::HeightMap & a_HeightMap
-)
+void cStructGenRavines::cRavine::DrawIntoChunk(cChunkDesc & a_ChunkDesc)
 {
-	int BlockStartX = a_ChunkX * cChunkDef::Width;
-	int BlockStartZ = a_ChunkZ * cChunkDef::Width;
+	int BlockStartX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
+	int BlockStartZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
 	int BlockEndX = BlockStartX + cChunkDef::Width;
 	int BlockEndZ = BlockStartZ + cChunkDef::Width;
 	for (cRavDefPoints::const_iterator itr = m_Points.begin(), end = m_Points.end(); itr != end; ++itr)
@@ -494,7 +358,7 @@ void cStructGenRavines::cRavine::ProcessChunk(
 			// DEBUG: Make the ravine shapepoints visible on a single layer (so that we can see with Minutor what's going on)
 			if ((DifX + x == 0) && (DifZ + z == 0))
 			{
-				cChunkDef::SetBlock(a_BlockTypes, x, 4, z, E_BLOCK_LAPIS_ORE);
+				a_ChunkDesc.SetBlockType(x, 4, z, E_BLOCK_LAPIS_ORE);
 			}
 			#endif  // _DEBUG
 			
@@ -504,7 +368,7 @@ void cStructGenRavines::cRavine::ProcessChunk(
 				int Top = std::min(itr->m_Top, (int)(cChunkDef::Height));  // Stupid gcc needs int cast
 				for (int y = std::max(itr->m_Bottom, 1); y <= Top; y++)
 				{
-					switch (cChunkDef::GetBlock(a_BlockTypes, x, y, z))
+					switch (a_ChunkDesc.GetBlockType(x, y, z))
 					{
 						// Only carve out these specific block types
 						case E_BLOCK_DIRT:
@@ -522,7 +386,7 @@ void cStructGenRavines::cRavine::ProcessChunk(
 						case E_BLOCK_REDSTONE_ORE:
 						case E_BLOCK_REDSTONE_ORE_GLOWING:
 						{
-							cChunkDef::SetBlock(a_BlockTypes, x, y, z, E_BLOCK_AIR);
+							a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);
 							break;
 						}
 						default: break;
diff --git a/src/Generating/Ravines.h b/src/Generating/Ravines.h
index c76b9f19f..30b47e9ec 100644
--- a/src/Generating/Ravines.h
+++ b/src/Generating/Ravines.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "ComposableGenerator.h"
+#include "GridStructGen.h"
 #include "../Noise.h"
 
 
@@ -17,28 +17,22 @@
 
 
 class cStructGenRavines :
-	public cFinishGen
+	public cGridStructGen
 {
+	typedef cGridStructGen super;
+
 public:
 	cStructGenRavines(int a_Seed, int a_Size);
-	~cStructGenRavines();
 	
 protected:
 	class cRavine;  // fwd: Ravines.cpp
-	typedef std::list<cRavine *> cRavines;
-	
-	cNoise   m_Noise;
-	int      m_Size;  // Max size, in blocks, of the ravines generated
-	cRavines m_Cache;
 	
-	/// Clears everything from the cache
-	void ClearCache(void);
+	cNoise m_Noise;
+	int    m_Size;  // Max size, in blocks, of the ravines generated
 	
-	/// Returns all ravines that *may* intersect the given chunk. All the ravines are valid until the next call to this function.
-	void GetRavinesForChunk(int a_ChunkX, int a_ChunkZ, cRavines & a_Ravines);
-	
-	// cFinishGen override:
-	virtual void GenFinish(cChunkDesc & a_ChunkDesc) override;
+
+	// cGridStructGen overrides:
+	virtual cStructurePtr CreateStructure(int a_OriginX, int a_OriginZ) override;
 } ;
 
 
-- 
cgit v1.2.3


From b997fbaf4577f0c3ff4f60f1a9ab2ca93c5f0d71 Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 9 May 2014 19:35:35 +0200
Subject: Removed an unused macro.

---
 src/Generating/Caves.cpp | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/Caves.cpp b/src/Generating/Caves.cpp
index 48663c21a..872e3341d 100644
--- a/src/Generating/Caves.cpp
+++ b/src/Generating/Caves.cpp
@@ -35,13 +35,6 @@ reduced in complexity in order for this generator to be useful, so the caves' sh
 
 
 
-/// How many nests in each direction are generated for a given chunk. Must be an even number
-#define NEIGHBORHOOD_SIZE 8
-
-
-
-
-
 const int MIN_RADIUS = 3;
 const int MAX_RADIUS = 8;
 
-- 
cgit v1.2.3


From 0fc60edaeb4bc54b87bc3d7af4631802c0331303 Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 9 May 2014 19:53:57 +0200
Subject: Removed an unused NetherFortGen variable.

---
 src/Generating/NetherFortGen.cpp | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/NetherFortGen.cpp b/src/Generating/NetherFortGen.cpp
index ac7fd0b7b..3867ec80c 100644
--- a/src/Generating/NetherFortGen.cpp
+++ b/src/Generating/NetherFortGen.cpp
@@ -11,12 +11,6 @@
 
 
 
-static const int NEIGHBORHOOD_SIZE = 3;
-
-
-
-
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // cNetherFortGen::cNetherFort:
 
-- 
cgit v1.2.3


From a936736acd822b29d09b4344ece768656b4d24db Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 9 May 2014 20:13:20 +0200
Subject: Removed unused constants from MineShafts and Ravines.

---
 src/Generating/MineShafts.cpp | 6 ------
 src/Generating/Ravines.cpp    | 3 ---
 2 files changed, 9 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index 7b26c2b62..391e4c04f 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -25,12 +25,6 @@ in a depth-first processing. Each of the descendants will branch randomly, if no
 
 
 
-static const int NEIGHBORHOOD_SIZE = 3;
-
-
-
-
-
 class cMineShaft abstract
 {
 public:
diff --git a/src/Generating/Ravines.cpp b/src/Generating/Ravines.cpp
index 78093f5ee..2722e4ca3 100644
--- a/src/Generating/Ravines.cpp
+++ b/src/Generating/Ravines.cpp
@@ -9,9 +9,6 @@
 
 
 
-/// How many ravines in each direction are generated for a given chunk. Must be an even number
-static const int NEIGHBORHOOD_SIZE = 8;
-
 static const int NUM_RAVINE_POINTS = 4;
 
 
-- 
cgit v1.2.3


From 3f9e00a3f3486c2845115e495d66f438f90825f3 Mon Sep 17 00:00:00 2001
From: archshift <admin@archshft.com>
Date: Sun, 11 May 2014 16:25:21 -0700
Subject: Fixed a few more switch warnings.

---
 src/Generating/StructGen.cpp | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/StructGen.cpp b/src/Generating/StructGen.cpp
index db9d5578c..636364e17 100644
--- a/src/Generating/StructGen.cpp
+++ b/src/Generating/StructGen.cpp
@@ -596,24 +596,22 @@ void cStructGenDirectOverhangs::GenFinish(cChunkDesc & a_ChunkDesc)
 		// Interpolate between FloorLo and FloorHi:
 		for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++)
 		{
-			switch (a_ChunkDesc.GetBiome(x, z))
+			EMCSBiome biome = a_ChunkDesc.GetBiome(x, z);
+			
+			if ((biome == biExtremeHills) || (biome == biExtremeHillsEdge))
 			{
-				case biExtremeHills:
-				case biExtremeHillsEdge:
+				int Lo = FloorLo[x + 17 * z] / 256;
+				int Hi = FloorHi[x + 17 * z] / 256;
+				for (int y = 0; y < SEGMENT_HEIGHT; y++)
 				{
-					int Lo = FloorLo[x + 17 * z] / 256;
-					int Hi = FloorHi[x + 17 * z] / 256;
-					for (int y = 0; y < SEGMENT_HEIGHT; y++)
+					int Val = Lo + (Hi - Lo) * y / SEGMENT_HEIGHT;
+					if (Val < 0)
 					{
-						int Val = Lo + (Hi - Lo) * y / SEGMENT_HEIGHT;
-						if (Val < 0)
-						{
-							a_ChunkDesc.SetBlockType(x, y + Segment, z, E_BLOCK_AIR);
-						}
-					}  // for y
-					break;
-				}
-			}  // switch (biome)
+						a_ChunkDesc.SetBlockType(x, y + Segment, z, E_BLOCK_AIR);
+					}
+				}  // for y
+				break;
+			}  // if (biome)
 		}  // for z, x
 		
 		// Swap the floors:
-- 
cgit v1.2.3


From 3a5e04d118a88dc33930866546007f59fdba951f Mon Sep 17 00:00:00 2001
From: archshift <admin@archshift.com>
Date: Sun, 11 May 2014 16:54:42 -0700
Subject: More switch warnings.

---
 src/Generating/Trees.cpp | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

(limited to 'src/Generating')

diff --git a/src/Generating/Trees.cpp b/src/Generating/Trees.cpp
index 4f1553c36..522f45148 100644
--- a/src/Generating/Trees.cpp
+++ b/src/Generating/Trees.cpp
@@ -174,7 +174,7 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 			{
 				GetBirchTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
 			}
-			break;
+			return;
 		}
 		
 		case biTaiga:
@@ -184,14 +184,14 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 		{
 			// Conifers
 			GetConiferTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
-			break;
+			return;
 		}
 		
 		case biSwampland:
 		{
 			// Swamp trees:
 			GetSwampTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
-			break;
+			return;
 		}
 		
 		case biJungle:
@@ -207,21 +207,21 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 			{
 				GetJungleTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
 			}
-			break;
+			return;
 		}
 		
 		case biBirchForest:
 		case biBirchForestHills:
 		{
 			GetBirchTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
-			break;
+			return;
 		}
 
 		case biBirchForestM:
 		case biBirchForestHillsM:
 		{
 			GetTallBirchTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
-			break;
+			return;
 		}
 
 		case biRoofedForest:
@@ -257,9 +257,29 @@ void GetTreeImageByBiome(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
 		{
 			// TODO: These need their special trees
 			GetBirchTreeImage(a_BlockX, a_BlockY, a_BlockZ, a_Noise, a_Seq, a_LogBlocks, a_OtherBlocks);
-			break;
+			return;
+		}
+			
+		case biDesert:
+		case biDesertHills:
+		case biRiver:
+		case biBeach:
+		case biHell:
+		case biSky:
+		case biOcean:
+		case biFrozenOcean:
+		case biFrozenRiver:
+		case biVariant:
+		case biNumBiomes:
+		case biNumVariantBiomes:
+		case biInvalidBiome:
+		{
+			// These biomes have no trees, or are non-biome members of the enum.
+			return;
 		}
 	}
+	
+	ASSERT(!"Invalid biome type!");
 }
 
 
-- 
cgit v1.2.3


From a4c964c888748e7099308dc56578244112148cdd Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 23 May 2014 13:01:06 +0200
Subject: Auto-enlargement for cGridStructGen cache.

---
 src/Generating/GridStructGen.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'src/Generating')

diff --git a/src/Generating/GridStructGen.cpp b/src/Generating/GridStructGen.cpp
index 3bbc89054..bfa6bccb1 100644
--- a/src/Generating/GridStructGen.cpp
+++ b/src/Generating/GridStructGen.cpp
@@ -22,6 +22,15 @@ cGridStructGen::cGridStructGen(
 	m_MaxStructureSizeZ(a_MaxStructureSizeZ),
 	m_MaxCacheSize(a_MaxCacheSize)
 {
+	size_t NumStructuresPerQuery = (size_t)((m_MaxStructureSizeX / m_GridSizeX + 1) * (m_MaxStructureSizeZ / m_GridSizeZ + 1));
+	if (NumStructuresPerQuery > m_MaxCacheSize)
+	{
+		m_MaxCacheSize = NumStructuresPerQuery * 4;
+		LOGINFO(
+			"cGridStructGen: The cache size is too small (%u), increasing the cache size to %u to avoid inefficiency.",
+			(unsigned)a_MaxCacheSize, (unsigned)m_MaxCacheSize
+		);
+	}
 }
 
 
-- 
cgit v1.2.3


From 97865bff7ce1595ae43be65082c1a02fed4ea8c4 Mon Sep 17 00:00:00 2001
From: Mattes D <github@xoft.cz>
Date: Fri, 23 May 2014 13:01:50 +0200
Subject: Fixed Mineshaft system size.

---
 src/Generating/MineShafts.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/Generating')

diff --git a/src/Generating/MineShafts.cpp b/src/Generating/MineShafts.cpp
index 391e4c04f..81ae6481d 100644
--- a/src/Generating/MineShafts.cpp
+++ b/src/Generating/MineShafts.cpp
@@ -1283,7 +1283,7 @@ cStructGenMineShafts::cStructGenMineShafts(
 	int a_Seed, int a_GridSize, int a_MaxSystemSize,
 	int a_ChanceCorridor, int a_ChanceCrossing, int a_ChanceStaircase
 ) :
-	super(a_Seed, a_GridSize, a_GridSize, 120 + a_MaxSystemSize * 10, 120 + a_MaxSystemSize * 10, 100),
+	super(a_Seed, a_GridSize, a_GridSize, a_MaxSystemSize, a_MaxSystemSize, 100),
 	m_Noise(a_Seed),
 	m_GridSize(a_GridSize),
 	m_MaxSystemSize(a_MaxSystemSize),
-- 
cgit v1.2.3