1 files changed, 74 insertions, 88 deletions

diff --git a/source/cChunkGenerator.cpp b/source/cChunkGenerator.cpp
index 78853a26b..8755ea325 100644
--- a/source/cChunkGenerator.cpp
+++ b/source/cChunkGenerator.cpp
@@ -2,11 +2,13 @@
 #include "Globals.h"

 

 #include "cChunkGenerator.h"

-#include "cChunkMap.h"

-#include "cChunk.h"

 #include "cWorld.h"

+#include "cWorldGenerator.h"

+#include "cWorldGenerator_Test.h"

+

+

+

 

-#include "cMCLogger.h"

 

 typedef std::pair<int, int> ChunkCoord;

 typedef std::list< ChunkCoord > ChunkCoordList;

@@ -16,144 +18,128 @@ typedef std::list< ChunkCoord > ChunkCoordList;
 

 

 /// If the generation queue size exceeds this number, a warning will be output

-#define QUEUE_WARNING_LIMIT 1000

+const int QUEUE_WARNING_LIMIT = 1000;

+

+/// If the generation queue size exceeds this number, chunks with no clients will be skipped

+const int QUEUE_SKIP_LIMIT = 50;

 

 

 

 

 

-struct cChunkGenerator::sChunkGeneratorState

+cChunkGenerator::cChunkGenerator(void)

+	: super("cChunkGenerator")

+	, m_World(NULL)

+	, m_pWorldGenerator(NULL)

 {

-	cCriticalSection m_CriticalSection;  // For protecting the variables in this struct

+}

+

 

-	ChunkCoordList GenerateQueue;

-	ChunkCoord CurrentlyGeneratingCoords;

-	cChunk* pCurrentlyGenerating;

-	bool bCurrentlyGenerating;

 

-	cSemaphore m_Semaphore;

-	cThread * pThread;

 

-	bool bStop;

 

-	sChunkGeneratorState(void)

-		: m_Semaphore(1, 0)

-		, pThread( 0 )

-		, bStop( false )

-		, bCurrentlyGenerating( false )

-		, pCurrentlyGenerating( false )

-	{}

-};

+cChunkGenerator::~cChunkGenerator()

+{

+	Stop();

+}

 

 

 

 

 

-cChunkGenerator::cChunkGenerator( cChunkMap* a_pChunkMap )

-	: m_pState( new sChunkGeneratorState )

-	, m_pChunkMap( a_pChunkMap )

+bool cChunkGenerator::Start(cWorld * a_World, const AString & a_WorldGeneratorName)

 {

-	m_pState->pThread = new cThread( GenerateThread, this, "cChunkGenerator::GenerateThread" );

-	m_pState->pThread->Start( true );

+	m_World = a_World;

+	

+	if (a_WorldGeneratorName.compare("Test") == 0 )

+	{

+		m_pWorldGenerator = new cWorldGenerator_Test();

+	}

+	else	// Default

+	{

+		m_pWorldGenerator = new cWorldGenerator();

+	}

+	

+	return super::Start();

 }

 

 

 

 

 

-cChunkGenerator::~cChunkGenerator()

+void cChunkGenerator::Stop(void)

 {

-	m_pState->bStop = true;

-

-	m_pState->m_Semaphore.Signal(); // Signal so thread can continue and exit

-	delete m_pState->pThread;

-

-	delete m_pState;

+	mShouldTerminate = true;

+	m_Event.Set();

+	Wait();

+	

+	delete m_pWorldGenerator;

+	m_pWorldGenerator = NULL;

 }

 

 

 

 

 

-void cChunkGenerator::GenerateChunk( int a_X, int a_Z )

+void cChunkGenerator::GenerateChunk(int a_ChunkX, int a_ChunkZ)

 {

-	cCSLock Lock(&m_pState->m_CriticalSection);

-

-	if (m_pState->bCurrentlyGenerating)

+	cCSLock Lock(m_CS);

+	

+	// Check if it is already in the queue:

+	for (cChunkCoordsList::iterator itr = m_Queue.begin(); itr != m_Queue.end(); ++itr)

 	{

-		if ((m_pState->CurrentlyGeneratingCoords.first == a_X) && (m_pState->CurrentlyGeneratingCoords.second == a_Z))

+		if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))

 		{

-			return;	// Already generating this chunk, so ignore

+			// Already in the queue, bail out

+			return;

 		}

-	}

-

-	m_pState->GenerateQueue.remove( ChunkCoord(a_X, a_Z) );

-	if (m_pState->GenerateQueue.size() >= QUEUE_WARNING_LIMIT)

+	}  // for itr - m_Queue[]

+	

+	// Add to queue, issue a warning if too many:

+	if (m_Queue.size() >= QUEUE_WARNING_LIMIT)

 	{

-		LOGWARN("WARNING: Adding chunk (%i, %i) to generation queue; Queue is too big! (%i)", a_X, a_Z, m_pState->GenerateQueue.size() );

+		LOGWARN("WARNING: Adding chunk [%i, %i] to generation queue; Queue is too big! (%i)", a_ChunkX, a_ChunkZ, m_Queue.size());

 	}

-	m_pState->GenerateQueue.push_back( ChunkCoord(a_X, a_Z) );

-

-	Lock.Unlock();

+	m_Queue.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));

 	

-	m_pState->m_Semaphore.Signal();

+	m_Event.Set();

 }

 

 

 

 

 

-void cChunkGenerator::GenerateThread( void* a_Params )

+void cChunkGenerator::Execute(void)

 {

-	// Cache some values for easy access (they are all references/pointers)

-	cChunkGenerator * self = (cChunkGenerator*)a_Params;

-	sChunkGeneratorState * m_pState = self->m_pState;

-	ChunkCoordList & GenerateQueue = m_pState->GenerateQueue;

-	cChunkMap & ChunkMap = *self->m_pChunkMap;

-	cCriticalSection * CriticalSection = &m_pState->m_CriticalSection;

-	cSemaphore & Semaphore = m_pState->m_Semaphore;

-

-	while (!m_pState->bStop)

+	while (!mShouldTerminate)

 	{

-		cCSLock Lock(CriticalSection);

-		if (GenerateQueue.size() == 0)

+		cCSLock Lock(m_CS);

+		while (m_Queue.size() == 0)

 		{

 			cCSUnlock Unlock(Lock);

-			Semaphore.Wait();

+			m_Event.Wait();

+			if (mShouldTerminate)

+			{

+				return;

+			}

 		}

-		if (m_pState->bStop) break;

 		

-		ChunkCoord coord = *GenerateQueue.begin();		// Get next coord from queue

-		GenerateQueue.erase( GenerateQueue.begin() );	// Remove coordinate from queue

-		m_pState->bCurrentlyGenerating = true;

-		m_pState->CurrentlyGeneratingCoords = coord;

+		cChunkCoords coords = m_Queue.front();		// Get next coord from queue

+		m_Queue.erase( m_Queue.begin() );	// Remove coordinate from queue

+		bool SkipEnabled = (m_Queue.size() > QUEUE_SKIP_LIMIT);

 		Lock.Unlock();			// Unlock ASAP

 

-		ChunkMap.GetWorld()->LockChunks();

-		if( ChunkMap.GetChunk( coord.first, 0, coord.second ) ) // Make sure it has not been loaded in the meantime. Don't want to generate the same chunk twice

-		{														// This is possible when forcing the server to generate a chunk in the main thread

-			ChunkMap.GetWorld()->UnlockChunks();

+		cChunkPtr Chunk = m_World->GetChunk(coords.m_ChunkX, 0, coords.m_ChunkZ);

+		if ((Chunk != NULL) && (Chunk->IsValid() || (SkipEnabled && !Chunk->HasAnyClient())))

+		{

+			// Already generated / overload-skip, ignore request

 			continue;

 		}

-		ChunkMap.GetWorld()->UnlockChunks();

-

-		LOGINFO("cChunkGenerator generating chunk %i %i", coord.first, coord.second );

-		cChunk* Chunk = new cChunk( coord.first, 0, coord.second, ChunkMap.GetWorld() );

-

-		Lock.Lock();

-		m_pState->pCurrentlyGenerating = Chunk;

-		Lock.Unlock();

 

-		Chunk->Initialize(); // Generate the chunk

-

-		ChunkMap.GetWorld()->LockChunks();

-		ChunkMap.AddChunk( Chunk );

-		ChunkMap.GetWorld()->UnlockChunks();

-

-		Lock.Lock();

-		m_pState->bCurrentlyGenerating = false;

-		m_pState->pCurrentlyGenerating = 0;

-		Lock.Unlock();

+		LOG("Generating chunk [%d, %d]", coords.m_ChunkX, coords.m_ChunkZ);

+		m_pWorldGenerator->GenerateChunk(Chunk);

+		

+		Chunk->SetValid();

 	}  // while (!bStop)

 }