summaryrefslogblamecommitdiffstats
path: root/src/WorldStorage/WorldStorage.cpp
blob: c3bfbd4f6305cb613c02d0174ff9e6ea08b28737 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11










                                                                                                           
                     
                                         
                               
                                         
                                 



 






                                                                                                                                





































                                                                                                                       


















                                                                                








                              




                                                              
                                    


















                                                                                          









                                                                             





 
                                              

                                 
                                  





 
                                              

                                 
                                  







                                                                                             
                                                                                                  







                                                                            
                                                                                        





 

                                           

                                                                                    





 

                                                                         
                                   









                                                                                                              

                                                                          







                                                             
                                    








                                                           
                                                        
                                                        






































                                                                                                     
                             

                  
                                        




                                              

                                                  
                                           
                                  









                                          
                                                             












                                                                                                                      
                          







                                      



                                                             
                 

                                                                                            
                 
                                                                                          
                 




                                                                                          

                 
                          







                                                                       
                                                      































                                                                                                       

// WorldStorage.cpp

// Implements the cWorldStorage class representing the chunk loading / saving thread

// To add a new storage schema, implement a cWSSchema descendant and add it to cWorldStorage::InitSchemas()

#include "Globals.h"
#include "WorldStorage.h"
#include "WSSCompact.h"
#include "WSSAnvil.h"
#include "../World.h"
#include "../Generating/ChunkGenerator.h"
#include "../Entities/Entity.h"
#include "../BlockEntities/BlockEntity.h"
#include "../OSSupport/Promise.h"




/// If a chunk with this Y coord is de-queued, it is a signal to emit the saved-all message (cWorldStorage::QueueSavedMessage())
#define CHUNK_Y_MESSAGE 2





/// Example storage schema - forgets all chunks ;)
class cWSSForgetful :
	public cWSSchema
{
public:
	cWSSForgetful(cWorld * a_World) : cWSSchema(a_World) {}
	
protected:
	// cWSSchema overrides:
	virtual bool LoadChunk(const cChunkCoords & a_Chunk) override {return false; }
	virtual bool SaveChunk(const cChunkCoords & a_Chunk) override {return true; }
	virtual const AString GetName(void) const override {return "forgetful"; }
} ;





///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cWorldStorage:

cWorldStorage::cWorldStorage(void) :
	super("cWorldStorage"),
	m_World(NULL),
	m_SaveSchema(NULL)
{
}





cWorldStorage::~cWorldStorage()
{
	for (cWSSchemaList::iterator itr = m_Schemas.begin(); itr != m_Schemas.end(); ++itr)
	{
		delete *itr;
	}  // for itr - m_Schemas[]
}





bool cWorldStorage::Start(cWorld * a_World, const AString & a_StorageSchemaName)
{
	m_World = a_World;
	m_StorageSchemaName = a_StorageSchemaName;
	InitSchemas();
	
	return super::Start();
}





void cWorldStorage::Stop(void)
{
	WaitForFinish();
}





void cWorldStorage::WaitForFinish(void)
{
	LOG("Waiting for the world storage to finish saving");
	
	{
		m_LoadQueue.Clear();
	}
	
	// Wait for the saving to finish:
	WaitForQueuesEmpty();
	
	// Wait for the thread to finish:
	m_ShouldTerminate = true;
	m_Event.Set();
	m_evtRemoved.Set();  // Wake up anybody waiting in the WaitForQueuesEmpty() method
	super::Wait();
	LOG("World storage thread finished");
}





void cWorldStorage::WaitForQueuesEmpty(void)
{

	cPromise * LoadPromise = m_LoadQueue.BlockTillEmpty();
	cPromise * SavePromise = m_SaveQueue.BlockTillEmpty();
	cPromise * QueuePromise = LoadPromise->WaitFor(SavePromise);
	cPromise * CancelPromise = QueuePromise->CancelOn(m_ShouldTerminate);
	CancelPromise->Wait();
	delete CancelPromise;
	delete QueuePromise;
	delete SavePromise;
	delete LoadPromise;
}





size_t cWorldStorage::GetLoadQueueLength(void)
{
	cCSLock Lock(m_CSQueues);
	return m_LoadQueue.Size();
}





size_t cWorldStorage::GetSaveQueueLength(void)
{
	cCSLock Lock(m_CSQueues);
	return m_SaveQueue.Size();
}





void cWorldStorage::QueueLoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ, bool a_Generate)
{
	m_LoadQueue.EnqueueItemIfNotPresent(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ, a_Generate));
}





void cWorldStorage::QueueSaveChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
{
	m_SaveQueue.EnqueueItemIfNotPresent(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));
}





void cWorldStorage::QueueSavedMessage(void)
{
	// Pushes a special coord pair into the queue, signalizing a message instead
	m_SaveQueue.EnqueueItem(cChunkCoords(0, CHUNK_Y_MESSAGE, 0));
}





void cWorldStorage::UnqueueLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
{
	/*cCSLock Lock(m_CSQueues);
	for (sChunkLoadQueue::iterator itr = m_LoadQueue.begin(); itr != m_LoadQueue.end(); ++itr)
	{
		if ((itr->m_ChunkX != a_ChunkX) || (itr->m_ChunkY != a_ChunkY) || (itr->m_ChunkZ != a_ChunkZ))
		{
			continue;
		}
		m_LoadQueue.erase(itr);
		Lock.Unlock();
		m_evtRemoved.Set();
		return;
	}  // for itr - m_LoadQueue[]*/
	m_LoadQueue.Remove(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ,true));
}





void cWorldStorage::UnqueueSave(const cChunkCoords & a_Chunk)
{
	m_SaveQueue.Remove(a_Chunk);
}





void cWorldStorage::InitSchemas(void)
{
	// The first schema added is considered the default
	m_Schemas.push_back(new cWSSAnvil    (m_World));
	m_Schemas.push_back(new cWSSCompact  (m_World));
	m_Schemas.push_back(new cWSSForgetful(m_World));
	// Add new schemas here
	
	if (NoCaseCompare(m_StorageSchemaName, "default") == 0)
	{
		m_SaveSchema = m_Schemas.front();
		return;
	}
	for (cWSSchemaList::iterator itr = m_Schemas.begin(); itr != m_Schemas.end(); ++itr)
	{
		if (NoCaseCompare((*itr)->GetName(), m_StorageSchemaName) == 0)
		{
			m_SaveSchema = *itr;
			return;
		}
	}  // for itr - m_Schemas[]
	
	// Unknown schema selected, let the admin know:
	LOGWARNING("Unknown storage schema name \"%s\". Using default (\"%s\"). Available schemas:", 
		m_StorageSchemaName.c_str(), m_SaveSchema->GetName().c_str()
	);
	for (cWSSchemaList::iterator itr = m_Schemas.begin(); itr != m_Schemas.end(); ++itr)
	{
		LOGWARNING("\t\"%s\"", (*itr)->GetName().c_str());
	}
	m_SaveSchema = m_Schemas.front();
}





void cWorldStorage::Execute(void)
{
	while (!m_ShouldTerminate)
	{
		m_Event.Wait();
		
		// Process both queues until they are empty again:
		bool Success;
		do
		{
			Success = false;
			if (m_ShouldTerminate)
			{
				return;
			}
			
			Success = LoadOneChunk();
			Success |= SaveOneChunk();
			m_evtRemoved.Set();
		} while (Success);
	}
}





bool cWorldStorage::LoadOneChunk(void)
{
	sChunkLoad ToLoad(0, 0, 0, false);
	bool ShouldLoad = m_LoadQueue.TryDequeueItem(ToLoad);
	if (ShouldLoad && !LoadChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ))
	{
		if (ToLoad.m_Generate)
		{
			// The chunk couldn't be loaded, generate it:
			m_World->GetGenerator().QueueGenerateChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ);
		}
		else
		{
			// TODO: Notify the world that the load has failed:
			// m_World->ChunkLoadFailed(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ);
		}
	}
	return ShouldLoad;
}





bool cWorldStorage::SaveOneChunk(void)
{
	cChunkCoords ToSave(0, 0, 0);
	bool ShouldSave = m_SaveQueue.TryDequeueItem(ToSave);
	if(ShouldSave) {
		if (ToSave.m_ChunkY == CHUNK_Y_MESSAGE)
		{
			LOGINFO("Saved all chunks in world %s", m_World->GetName().c_str());
			return ShouldSave;
		}
		if (ShouldSave && m_World->IsChunkValid(ToSave.m_ChunkX, ToSave.m_ChunkZ))
		{
			m_World->MarkChunkSaving(ToSave.m_ChunkX, ToSave.m_ChunkZ);
			if (m_SaveSchema->SaveChunk(ToSave))
			{
				m_World->MarkChunkSaved(ToSave.m_ChunkX, ToSave.m_ChunkZ);
			}
		}
	}
	return ShouldSave;
}





bool cWorldStorage::LoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
{
	if (m_World->IsChunkValid(a_ChunkX, a_ChunkZ))
	{
		// Already loaded (can happen, since the queue is async)
		return true;
	}
	
	cChunkCoords Coords(a_ChunkX, a_ChunkY, a_ChunkZ);

	// First try the schema that is used for saving
	if (m_SaveSchema->LoadChunk(Coords))
	{
		return true;
	}
	
	// If it didn't have the chunk, try all the other schemas:
	for (cWSSchemaList::iterator itr = m_Schemas.begin(); itr != m_Schemas.end(); ++itr)
	{
		if (((*itr) != m_SaveSchema) && (*itr)->LoadChunk(Coords))
		{
			return true;
		}
	}
	
	// Notify the chunk owner that the chunk failed to load (sets cChunk::m_HasLoadFailed to true):
	m_World->ChunkLoadFailed(a_ChunkX, a_ChunkY, a_ChunkZ);
	
	return false;
}