1 files changed, 364 insertions, 0 deletions

diff --git a/source/cChunkLoader.cpp b/source/cChunkLoader.cpp
new file mode 100644
index 000000000..a5d07818d
--- /dev/null
+++ b/source/cChunkLoader.cpp
@@ -0,0 +1,364 @@
+#if 0 // ignore all contents of this file

+#include "cChunkLoader.h"

+#include "cChunk.h"

+#include "cMCLogger.h"

+#include "BlockID.h"

+#include "cCriticalSection.h"

+#include "cEvent.h"

+#include "cThread.h"

+#include "cSleep.h"

+

+#include "cChestEntity.h"

+#include "cFurnaceEntity.h"

+#include "cSignEntity.h"

+

+#include <iostream>

+#ifndef _WIN32

+#include <cstring>

+#include <cstdlib>

+#include <stdio.h>

+#include <sys/stat.h>   // for mkdir

+#include <sys/types.h>

+#else

+#include <Windows.h>

+#endif

+

+#include <list>

+

+struct ChunkData

+{

+	ChunkData()

+		: x( 0 )

+		, z( 0 )

+		, Data( 0 )

+		, LiveChunk( 0 )

+	{}

+	int x, z;

+	unsigned int DataSize;

+	unsigned int ChunkStart;

+	char* Data;

+	cChunk* LiveChunk;

+};

+

+typedef std::list< ChunkData > ChunkDataList;

+struct cChunkLoader::ChunkPack

+{

+	ChunkDataList AllChunks;

+	int x, y, z;

+};

+

+typedef std::list< cChunkLoader::ChunkPack > ChunkPackList;

+struct cChunkLoader::ChunkPacks

+{

+	ChunkPackList AllPacks;

+};

+

+cChunkLoader::cChunkLoader()

+	: m_bStop( false )

+	, m_CriticalSection( new cCriticalSection() )

+	, m_Event( new cEvent() )

+	, m_ChunkPacks( new ChunkPacks )

+{

+	cThread( SaveThread, this );

+}

+

+cChunkLoader::~cChunkLoader()

+{

+	m_bStop = true;

+	m_Event->Wait();

+	delete m_CriticalSection;

+}

+

+void cChunkLoader::SaveThread( void* a_Param )

+{

+	cChunkLoader* self = (cChunkLoader*)a_Param;

+	while( !self->m_bStop )

+	{

+		cSleep::MilliSleep( 1000 ); // Only check for saving once a second

+	}

+	self->m_Event->Set();

+}

+

+cChunk* cChunkLoader::LoadChunk( int a_X, int a_Y, int a_Z )

+{

+	m_CriticalSection->Lock();

+	cChunk* Chunk = 0;

+	

+	Chunk = LoadOldFormat( a_X, a_Y, a_Z );

+	if( Chunk ) { Chunk->CalculateHeightmap(); }

+	else

+	{

+		1; // load new format()

+	}

+

+	m_CriticalSection->Unlock();

+	return Chunk;

+}

+

+bool cChunkLoader::SaveChunk( const cChunk & a_Chunk )

+{

+	m_CriticalSection->Lock();

+	bool Success = SaveOldFormat( a_Chunk );

+	m_CriticalSection->Unlock();

+

+	return Success;

+}

+

+/**************************************************

+ * Old format stuffs

+ **/

+

+cChunk* cChunkLoader::LoadOldFormat( int a_X, int a_Y, int a_Z )

+{

+	char SourceFile[128];

+	sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.bin", a_X, a_Y, a_Z );

+

+	FILE* f = 0;

+	#ifdef _WIN32

+	if( fopen_s(&f, SourceFile, "rb" ) == 0 )	// no error

+	#else

+	if( (f = fopen(SourceFile, "rb" )) != 0 )	// no error

+	#endif

+	{

+		cChunk* Chunk = new cChunk( a_X, a_Y, a_Z );

+		if( fread( Chunk->m_BlockData, sizeof(char)*cChunk::c_BlockDataSize, 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }

+

+		// Now load Block Entities

+		ENUM_BLOCK_ID BlockType;

+		while( fread( &BlockType, sizeof(ENUM_BLOCK_ID), 1, f) == 1 )

+		{

+			switch( BlockType )

+			{

+			case E_BLOCK_CHEST:

+				{

+					cChestEntity* ChestEntity = new cChestEntity( 0, 0, 0 );

+					if( !ChestEntity->LoadFromFile( f ) )

+					{

+						LOGERROR("ERROR READING CHEST FROM FILE %s", SourceFile );

+						delete ChestEntity;

+						fclose(f);

+						return false;

+					}

+					Chunk->m_BlockEntities.push_back( ChestEntity );

+				}

+				break;

+			case E_BLOCK_FURNACE:

+				{

+					cFurnaceEntity* FurnaceEntity = new cFurnaceEntity( 0, 0, 0 );

+					if( !FurnaceEntity->LoadFromFile( f ) )

+					{

+						LOGERROR("ERROR READING FURNACE FROM FILE %s", SourceFile );

+						delete FurnaceEntity;

+						fclose(f);

+						return false;

+					}

+					Chunk->m_BlockEntities.push_back( FurnaceEntity );

+					Chunk->m_TickBlockEntities.push_back( FurnaceEntity ); // They need tickin'

+				}

+				break;

+			case E_BLOCK_SIGN_POST:

+			case E_BLOCK_WALLSIGN:

+				{

+					cSignEntity* SignEntity = new cSignEntity(BlockType, 0, 0, 0 );

+					if( !SignEntity->LoadFromFile( f ) )

+					{

+						LOGERROR("ERROR READING SIGN FROM FILE %s", SourceFile );

+						delete SignEntity;

+						fclose(f);

+						return false;

+					}

+					Chunk->m_BlockEntities.push_back( SignEntity );

+				}

+				break;

+			default:

+				break;

+			}

+		}

+

+		fclose(f);

+		return Chunk;

+	}

+	else

+	{

+		return 0;

+	}

+}

+

+bool cChunkLoader::SaveOldFormat( const cChunk & a_Chunk )

+{

+	char SourceFile[128];

+	sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.bin", a_Chunk.m_PosX, a_Chunk.m_PosY, a_Chunk.m_PosZ );

+

+    #ifdef _WIN32

+	{

+		SECURITY_ATTRIBUTES Attrib;

+		Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);

+		Attrib.lpSecurityDescriptor = NULL;

+		Attrib.bInheritHandle = false;

+		::CreateDirectory("world", &Attrib);

+	}

+	#else

+	{

+        mkdir("world", S_IRWXU | S_IRWXG | S_IRWXO);

+	}

+	#endif

+

+	FILE* f = 0;

+#ifdef _WIN32

+	if( fopen_s(&f, SourceFile, "wb" ) == 0 )	// no error

+	#else

+	if( (f = fopen(SourceFile, "wb" )) != 0 )	// no error

+	#endif

+	{

+		fwrite( a_Chunk.m_BlockData, sizeof(char)*cChunk::c_BlockDataSize, 1, f );

+

+		// Now write Block Entities

+		for( std::list<cBlockEntity*>::const_iterator itr = a_Chunk.m_BlockEntities.begin(); itr != a_Chunk.m_BlockEntities.end(); ++itr)

+		{

+			cBlockEntity* BlockEntity = *itr;

+			switch( BlockEntity->GetBlockType() )

+			{

+			case E_BLOCK_CHEST:

+				{

+					cChestEntity* ChestEntity = reinterpret_cast< cChestEntity* >( BlockEntity );

+					ChestEntity->WriteToFile( f );

+				}

+				break;

+			case E_BLOCK_FURNACE:

+				{

+					cFurnaceEntity* FurnaceEntity = reinterpret_cast< cFurnaceEntity* >( BlockEntity );

+					FurnaceEntity->WriteToFile( f );

+				}

+				break;

+			case E_BLOCK_SIGN_POST:

+			case E_BLOCK_WALLSIGN:

+				{

+					cSignEntity* SignEntity = reinterpret_cast< cSignEntity* >( BlockEntity );

+					SignEntity->WriteToFile( f );

+				}

+				break;

+			default:

+				break;

+			}

+		}

+

+		fclose(f);

+		return true;

+	}

+	else

+	{

+		LOGERROR("ERROR WRITING TO FILE %s", SourceFile);

+		return false;

+	}

+}

+

+

+/******************************************

+ * New format

+ **/

+

+cChunk* cChunkLoader::LoadFormat1( int a_X, int a_Y, int a_Z )

+{

+	int PakX = (int)(floorf((float)a_X / 16.f));

+	int PakY = (int)(floorf((float)a_Y / 16.f));

+	int PakZ = (int)(floorf((float)a_Z / 16.f));

+

+	ChunkPack * Pack = 0;

+	ChunkPackList & PackList = m_ChunkPacks->AllPacks;

+	for( ChunkPackList::iterator itr = PackList.begin(); itr != PackList.end(); ++itr )

+	{

+		if( itr->x == PakX && itr->y == PakY && itr->z == PakZ )

+		{

+			Pack = &(*itr);

+			break;

+		}

+	}

+

+	

+	if( !Pack ) // The pack was not in memory, so try to load it from disk

+	{

+		Pack = LoadPak1( PakX, PakY, PakZ ); // Load .pak file from disk

+		if( Pack )

+		{

+			PackList.push_back( *Pack ); // Add it to the loaded list

+		}

+	}

+

+	if( Pack ) // Allright, the pack is in memory

+	{

+		ChunkData * Data = 0;

+		ChunkDataList & ChunkList = Pack->AllChunks;

+		for( ChunkDataList::iterator itr = ChunkList.begin(); itr != ChunkList.end(); ++itr )

+		{

+			if( itr->x == a_X && itr->z == a_Z )

+			{

+				Data = &(*itr);

+				break;

+			}

+		}

+

+		if( !Data ) // Sorry, chunk does not exist (yet)

+			return 0;

+

+		if( Data->LiveChunk ) // This chunk is already loaded and decoded (this should actually never happen)

+			return Data->LiveChunk;

+

+		// Decompress chunk, and return brand new chunk

+

+		// doing it...

+

+		return 0; // actually return the chunk

+	}

+

+	return 0; // .pak file didn't exist

+}

+

+cChunkLoader::ChunkPack* cChunkLoader::LoadPak1( int PakX, int PakY, int PakZ )

+{

+	char SourceFile[128];

+	sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.pak", PakX, PakY, PakZ );

+

+	FILE* f = 0;

+	#ifdef _WIN32

+	if( fopen_s(&f, SourceFile, "rb" ) == 0 )	// no error

+	#else

+	if( (f = fopen(SourceFile, "rb" )) != 0 )	// no error

+	#endif

+	{

+		cChunkLoader::ChunkPack * Pack = new cChunkLoader::ChunkPack;

+		Pack->x = PakX;

+		Pack->y = PakY;

+		Pack->z = PakZ;

+

+		short Version = 0;

+		if( fread( &Version, sizeof( short ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+		if( Version != 1 ) { LOGERROR("Wrong pak version! %s", SourceFile ); return 0; }

+		short NumChunks = 0;

+		if( fread( &NumChunks, sizeof( short ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+

+		// Load all the headers

+		for( short i = 0; i < NumChunks; ++i )

+		{

+			ChunkData Data;

+			if( fread( &Data.x, sizeof( int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+			if( fread( &Data.z, sizeof( int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+			if( fread( &Data.DataSize, sizeof( unsigned int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+			if( fread( &Data.ChunkStart, sizeof( unsigned int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+			Pack->AllChunks.push_back( Data );

+		}

+

+		// Load all compressed chunk data in the order the headers were loaded

+		ChunkDataList::iterator itr = Pack->AllChunks.begin();

+		for( short i = 0; i < NumChunks; ++i )

+		{

+			itr->Data = new char[ itr->DataSize ];

+			if( fread( itr->Data, sizeof( char ) * itr->DataSize, 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }

+			++itr;

+		}

+

+		// And we're done :)

+		return Pack;

+	}

+	return 0;

+}

+#endif
\ No newline at end of file