14 files changed, 96 insertions, 72 deletions

diff --git a/src/WorldStorage/CMakeLists.txt b/src/WorldStorage/CMakeLists.txt
index 2844f7fe5..a00ff3b2f 100644
--- a/src/WorldStorage/CMakeLists.txt
+++ b/src/WorldStorage/CMakeLists.txt
@@ -4,11 +4,34 @@ project (MCServer)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
 
-file(GLOB SOURCE
-    "*.cpp"
-    "*.h"
-)
+SET (SRCS
+	EnchantmentSerializer.cpp
+	FastNBT.cpp
+	FireworksSerializer.cpp
+	MapSerializer.cpp
+	NBTChunkSerializer.cpp
+	SchematicFileSerializer.cpp
+	ScoreboardSerializer.cpp
+	StatSerializer.cpp
+	WSSAnvil.cpp
+	WSSCompact.cpp
+	WorldStorage.cpp)
 
-add_library(WorldStorage ${SOURCE})
+SET (HDRS
+	EnchantmentSerializer.h
+	FastNBT.h
+	FireworksSerializer.h
+	MapSerializer.h
+	NBTChunkSerializer.h
+	SchematicFileSerializer.h
+	ScoreboardSerializer.h
+	StatSerializer.h
+	WSSAnvil.h
+	WSSCompact.h
+	WorldStorage.h)
 
-target_link_libraries(WorldStorage OSSupport)
+if(NOT MSVC)
+	add_library(WorldStorage ${SRCS} ${HDRS})
+
+	target_link_libraries(WorldStorage OSSupport)
+endif()
diff --git a/src/WorldStorage/FastNBT.cpp b/src/WorldStorage/FastNBT.cpp
index a047d67c7..c6294b99c 100644
--- a/src/WorldStorage/FastNBT.cpp
+++ b/src/WorldStorage/FastNBT.cpp
@@ -10,7 +10,7 @@
 
 
 
-// The number of NBT tags that are reserved when an NBT parsing is started. 
+// The number of NBT tags that are reserved when an NBT parsing is started.
 // You can override this by using a cmdline define
 #ifndef NBT_RESERVE_SIZE
 	#define NBT_RESERVE_SIZE 200
@@ -25,7 +25,7 @@
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cParsedNBT:
 
 #define NEEDBYTES(N) \
@@ -69,7 +69,7 @@ bool cParsedNBT::Parse(void)
 	
 	m_Pos = 1;
 	
-	RETURN_FALSE_IF_FALSE(ReadString(m_Tags.back().m_NameStart, m_Tags.back().m_NameLength)); 
+	RETURN_FALSE_IF_FALSE(ReadString(m_Tags.back().m_NameStart, m_Tags.back().m_NameLength));
 	RETURN_FALSE_IF_FALSE(ReadCompound());
 	
 	return true;
@@ -329,7 +329,7 @@ int cParsedNBT::FindTagByPath(int a_Tag, const AString & a_Path) const
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cFastNBTWriter:
 
 cFastNBTWriter::cFastNBTWriter(const AString & a_RootTagName) :
diff --git a/src/WorldStorage/FastNBT.h b/src/WorldStorage/FastNBT.h
index fe28005ac..7aa83fc24 100644
--- a/src/WorldStorage/FastNBT.h
+++ b/src/WorldStorage/FastNBT.h
@@ -5,11 +5,11 @@
 
 /*
 The fast parser parses the data into a vector of cFastNBTTag structures. These structures describe the NBT tree,
-but themselves are allocated in a vector, thus minimizing reallocation. 
+but themselves are allocated in a vector, thus minimizing reallocation.
 The structures have a minimal constructor, setting all member "pointers" to "invalid".
 
 The fast writer doesn't need a NBT tree structure built beforehand, it is commanded to open, append and close tags
-(just like XML); it keeps the internal tag stack and reports errors in usage. 
+(just like XML); it keeps the internal tag stack and reports errors in usage.
 It directly outputs a string containing the serialized NBT data.
 */
 
@@ -173,7 +173,7 @@ public:
 	}
 	
 	/** Returns the value stored in a Byte tag. Not valid for any other tag type. */
-	inline unsigned char GetByte(int a_Tag) const 
+	inline unsigned char GetByte(int a_Tag) const
 	{
 		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Byte);
 		return (unsigned char)(m_Data[(size_t)m_Tags[(size_t)a_Tag].m_DataStart]);
diff --git a/src/WorldStorage/FireworksSerializer.cpp b/src/WorldStorage/FireworksSerializer.cpp
index 181cfde0d..ecb600483 100644
--- a/src/WorldStorage/FireworksSerializer.cpp
+++ b/src/WorldStorage/FireworksSerializer.cpp
@@ -72,7 +72,7 @@ void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNB
 			for (int explosiontag = a_NBT.GetFirstChild(a_TagIdx); explosiontag >= 0; explosiontag = a_NBT.GetNextSibling(explosiontag))
 			{
 				eTagType TagType = a_NBT.GetType(explosiontag);
-				if (TagType == TAG_Byte) // Custon name tag
+				if (TagType == TAG_Byte)  // Custon name tag
 				{
 					AString ExplosionName = a_NBT.GetName(explosiontag);
 
@@ -98,7 +98,7 @@ void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNB
 						// Divide by four as data length returned in bytes
 						size_t DataLength = a_NBT.GetDataLength(explosiontag);
 						// round to the next highest multiple of four
-						DataLength -= DataLength % 4; 
+						DataLength -= DataLength % 4;
 						if (DataLength == 0)
 						{
 							continue;
@@ -114,7 +114,7 @@ void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNB
 					{
 						size_t DataLength = a_NBT.GetDataLength(explosiontag) / 4;
 						// round to the next highest multiple of four
-						DataLength -= DataLength % 4; 
+						DataLength -= DataLength % 4;
 						if (DataLength == 0)
 						{
 							continue;
@@ -135,7 +135,7 @@ void cFireworkItem::ParseFromNBT(cFireworkItem & a_FireworkItem, const cParsedNB
 			for (int fireworkstag = a_NBT.GetFirstChild(a_TagIdx); fireworkstag >= 0; fireworkstag = a_NBT.GetNextSibling(fireworkstag))
 			{
 				eTagType TagType = a_NBT.GetType(fireworkstag);
-				if (TagType == TAG_Byte) // Custon name tag
+				if (TagType == TAG_Byte)  // Custon name tag
 				{
 					if (a_NBT.GetName(fireworkstag) == "Flight")
 					{
diff --git a/src/WorldStorage/MapSerializer.h b/src/WorldStorage/MapSerializer.h
index eb7678a08..4fa40f6f9 100644
--- a/src/WorldStorage/MapSerializer.h
+++ b/src/WorldStorage/MapSerializer.h
@@ -52,10 +52,9 @@ private:
 
 
 /** Utility class used to serialize item ID counts.
- *
- * In order to perform bounds checking (while loading),
- * the last registered ID of each item is serialized to an NBT file.
- */
+In order to perform bounds checking (while loading),
+the last registered ID of each item is serialized to an NBT file.
+*/
 class cIDCountSerializer
 {
 public:
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index 6d0b60371..4857da1b6 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -279,7 +279,7 @@ void cNBTChunkSerializer::AddCommandBlockEntity(cCommandBlockEntity * a_CmdBlock
 		m_Writer.AddString("Command",      a_CmdBlock->GetCommand());
 		m_Writer.AddInt   ("SuccessCount", a_CmdBlock->GetResult());
 		m_Writer.AddString("LastOutput",   a_CmdBlock->GetLastOutput());
-		m_Writer.AddByte  ("TrackOutput",  1); // TODO 2014-01-18 xdot: Figure out what TrackOutput is and save it.
+		m_Writer.AddByte  ("TrackOutput",  1);  // TODO 2014-01-18 xdot: Figure out what TrackOutput is and save it.
 	m_Writer.EndCompound();
 }
 
@@ -613,7 +613,8 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
 				m_Writer.AddInt("EffectDuration",           (Int16)Potion->GetEntityEffect().GetDuration());
 				m_Writer.AddShort("EffectIntensity",         Potion->GetEntityEffect().GetIntensity());
 				m_Writer.AddDouble("EffectDistanceModifier", Potion->GetEntityEffect().GetDistanceModifier());
-				m_Writer.AddInt("PotionName",                Potion->GetPotionParticleType());
+				m_Writer.AddInt("PotionName",                Potion->GetPotionColor());
+				break;
 			}
 			case cProjectileEntity::pkGhastFireball:
 			{
@@ -630,7 +631,7 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
 			{
 				ASSERT(!"Unsaved projectile entity!");
 			}
-		}  // switch (ProjectileKind)		
+		}  // switch (ProjectileKind)
 
 		if (!a_Projectile->GetCreatorName().empty())
 		{
diff --git a/src/WorldStorage/SchematicFileSerializer.cpp b/src/WorldStorage/SchematicFileSerializer.cpp
index 1cf99efd9..64f4cb00d 100644
--- a/src/WorldStorage/SchematicFileSerializer.cpp
+++ b/src/WorldStorage/SchematicFileSerializer.cpp
@@ -44,7 +44,7 @@ public:
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cSchematicFileSerializer:
 
 bool cSchematicFileSerializer::LoadFromSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName)
diff --git a/src/WorldStorage/ScoreboardSerializer.cpp b/src/WorldStorage/ScoreboardSerializer.cpp
index 6c885bb45..da8236e0d 100644
--- a/src/WorldStorage/ScoreboardSerializer.cpp
+++ b/src/WorldStorage/ScoreboardSerializer.cpp
@@ -117,7 +117,7 @@ void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
 		a_Writer.EndCompound();
 	}
 
-	a_Writer.EndList(); // Objectives
+	a_Writer.EndList();  // Objectives
 
 	a_Writer.BeginList("PlayerScores", TAG_Compound);
 
@@ -138,7 +138,7 @@ void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
 		}
 	}
 
-	a_Writer.EndList(); // PlayerScores
+	a_Writer.EndList();  // PlayerScores
 
 	a_Writer.BeginList("Teams", TAG_Compound);
 	
@@ -169,7 +169,7 @@ void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
 		a_Writer.EndCompound();
 	}
 
-	a_Writer.EndList(); // Teams
+	a_Writer.EndList();  // Teams
 
 	a_Writer.BeginCompound("DisplaySlots");
 
@@ -182,9 +182,9 @@ void cScoreboardSerializer::SaveScoreboardToNBT(cFastNBTWriter & a_Writer)
 	Objective = m_ScoreBoard->GetObjectiveIn(cScoreboard::dsName);
 	a_Writer.AddString("slot_2", (Objective == NULL) ? "" : Objective->GetName());
 
-	a_Writer.EndCompound(); // DisplaySlots
+	a_Writer.EndCompound();  // DisplaySlots
 
-	a_Writer.EndCompound(); // Data
+	a_Writer.EndCompound();  // Data
 }
 
 
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index 1a43cf4ba..663d489bc 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -56,7 +56,7 @@ thus making skylight visible in Minutor's Lighting mode
 */
 // #define DEBUG_SKYLIGHT
 
-/** Maximum number of MCA files that are cached in memory. 
+/** Maximum number of MCA files that are cached in memory.
 Since only the header is actually in the memory, this number can be high, but still, each file means an OS FS handle.
 */
 #define MAX_MCA_FILES 32
@@ -69,7 +69,7 @@ Since only the header is actually in the memory, this number can be high, but st
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cWSSAnvil:
 
 cWSSAnvil::cWSSAnvil(cWorld * a_World, int a_CompressionFactor) :
@@ -393,7 +393,7 @@ bool cWSSAnvil::LoadChunkFromNBT(const cChunkCoords & a_Chunk, const cParsedNBT
 	
 	m_World->SetChunkData(
 		a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ,
-		BlockTypes, MetaData, 
+		BlockTypes, MetaData,
 		IsLightValid ? BlockLight : NULL,
 		IsLightValid ? SkyLight : NULL,
 		NULL, Biomes,
@@ -449,7 +449,7 @@ bool cWSSAnvil::SaveChunkToNBT(const cChunkCoords & a_Chunk, cFastNBTWriter & a_
 		const char * BlockLight  = (const char *)(Serializer.m_BlockSkyLight);
 	#else
 		const char * BlockLight  = (const char *)(Serializer.m_BlockLight);
-	#endif 
+	#endif
 	const char * BlockSkyLight = (const char *)(Serializer.m_BlockSkyLight);
 	for (int Y = 0; Y < 16; Y++)
 	{
@@ -463,7 +463,7 @@ bool cWSSAnvil::SaveChunkToNBT(const cChunkCoords & a_Chunk, cFastNBTWriter & a_
 	}
 	a_Writer.EndList();  // "Sections"
 	
-	// Store the information that the lighting is valid. 
+	// Store the information that the lighting is valid.
 	// For compatibility reason, the default is "invalid" (missing) - this means older data is re-lighted upon loading.
 	if (Serializer.IsLightValid())
 	{
@@ -1356,7 +1356,7 @@ void cWSSAnvil::LoadFallingBlockFromNBT(cEntityList & a_Entities, const cParsedN
 
 void cWSSAnvil::LoadMinecartRFromNBT(cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx)
 {
-	std::auto_ptr<cRideableMinecart> Minecart(new cRideableMinecart(0, 0, 0, cItem(), 1)); // TODO: Load the block and the height
+	std::auto_ptr<cRideableMinecart> Minecart(new cRideableMinecart(0, 0, 0, cItem(), 1));  // TODO: Load the block and the height
 	if (!LoadEntityBaseFromNBT(*Minecart.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1465,7 +1465,7 @@ void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 		return;
 	}
 	
-	std::auto_ptr<cPickup> Pickup(new cPickup(0, 0, 0, Item, false)); // Pickup delay doesn't matter, just say false
+	std::auto_ptr<cPickup> Pickup(new cPickup(0, 0, 0, Item, false));  // Pickup delay doesn't matter, just say false
 	if (!LoadEntityBaseFromNBT(*Pickup.get(), a_NBT, a_TagIdx))
 	{
 		return;
@@ -1681,7 +1681,7 @@ void cWSSAnvil::LoadSplashPotionFromNBT(cEntityList & a_Entities, const cParsedN
 	
 	SplashPotion->SetEntityEffectType((cEntityEffect::eType) a_NBT.FindChildByName(a_TagIdx, "EffectType"));
 	SplashPotion->SetEntityEffect(cEntityEffect(EffectDuration, EffectIntensity, EffectDistanceModifier));
-	SplashPotion->SetPotionParticleType(a_NBT.FindChildByName(a_TagIdx, "PotionName"));
+	SplashPotion->SetPotionColor(a_NBT.FindChildByName(a_TagIdx, "PotionName"));
 	
 	// Store the new splash potion in the entities list:
 	a_Entities.push_back(SplashPotion.release());
@@ -2363,8 +2363,8 @@ void cWSSAnvil::LoadWolfFromNBT(cEntityList & a_Entities, const cParsedNBT & a_N
 		return;
 	}
 	int OwnerIdx = a_NBT.FindChildByName(a_TagIdx, "Owner");
-	if (OwnerIdx > 0) 
-	{ 
+	if (OwnerIdx > 0)
+	{
 		AString OwnerName = a_NBT.GetString(OwnerIdx);
 		if (OwnerName != "")
 		{
@@ -2592,7 +2592,7 @@ bool cWSSAnvil::GetBlockEntityNBTPos(const cParsedNBT & a_NBT, int a_TagIdx, int
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cWSSAnvil::cMCAFile:
 
 cWSSAnvil::cMCAFile::cMCAFile(const AString & a_FileName, int a_RegionX, int a_RegionZ) :
diff --git a/src/WorldStorage/WSSAnvil.h b/src/WorldStorage/WSSAnvil.h
index 5b629f017..9f8714404 100644
--- a/src/WorldStorage/WSSAnvil.h
+++ b/src/WorldStorage/WSSAnvil.h
@@ -153,7 +153,7 @@ protected:
 	void LoadPickupFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadTNTFromNBT             (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadExpOrbFromNBT          (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
-	void LoadHangingFromNBT         (cHangingEntity & a_Hanging,const cParsedNBT & a_NBT, int a_TagIdx);
+	void LoadHangingFromNBT         (cHangingEntity & a_Hanging, const cParsedNBT & a_NBT, int a_TagIdx);
 	void LoadItemFrameFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
 
 	void LoadMinecartRFromNBT       (cEntityList & a_Entities, const cParsedNBT & a_NBT, int a_TagIdx);
diff --git a/src/WorldStorage/WSSCompact.cpp b/src/WorldStorage/WSSCompact.cpp
index a3ba443fd..ff43b6905 100644
--- a/src/WorldStorage/WSSCompact.cpp
+++ b/src/WorldStorage/WSSCompact.cpp
@@ -48,7 +48,7 @@ const int MAX_DIRTY_CHUNKS = 16;
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cJsonChunkSerializer:
 
 cJsonChunkSerializer::cJsonChunkSerializer(void) :
@@ -120,7 +120,7 @@ void cJsonChunkSerializer::LightIsValid(bool a_IsLightValid)
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cWSSCompact:
 
 cWSSCompact::~cWSSCompact()
@@ -411,7 +411,7 @@ void cWSSCompact::LoadEntitiesFromJson(Json::Value & a_Value, cEntityList & a_En
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cWSSCompact::cPAKFile
 
 #define READ(Var) \
@@ -427,7 +427,7 @@ cWSSCompact::cPAKFile::cPAKFile(const AString & a_FileName, int a_LayerX, int a_
 	m_LayerX(a_LayerX),
 	m_LayerZ(a_LayerZ),
 	m_NumDirty(0),
-	m_ChunkVersion( CHUNK_VERSION ), // Init with latest version
+	m_ChunkVersion( CHUNK_VERSION ),  // Init with latest version
 	m_PakVersion( PAK_VERSION )
 {
 	cFile f;
@@ -486,12 +486,12 @@ cWSSCompact::cPAKFile::cPAKFile(const AString & a_FileName, int a_LayerX, int a_
 		return;
 	}
 
-	if( m_ChunkVersion == 1 ) // Convert chunks to version 2
+	if( m_ChunkVersion == 1 )  // Convert chunks to version 2
 	{
 		UpdateChunk1To2();
 	}
 #if AXIS_ORDER == AXIS_ORDER_XZY
-	if( m_ChunkVersion == 2 ) // Convert chunks to version 3
+	if( m_ChunkVersion == 2 )  // Convert chunks to version 3
 	{
 		UpdateChunk2To3();
 	}
@@ -586,7 +586,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 		Offset += Header->m_CompressedSize;
 
 		// Crude data integrity check:
-		int ExpectedSize = (16*128*16)*2 + (16*128*16)/2; // For version 1
+		int ExpectedSize = (16*128*16)*2 + (16*128*16)/2;  // For version 1
 		if (UncompressedSize < ExpectedSize)
 		{
 			LOGWARNING("Chunk [%d, %d] has too short decompressed data (%d bytes out of %d needed), erasing",
@@ -603,7 +603,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 			int errorcode = UncompressString(Data.data(), Data.size(), UncompressedData, (size_t)UncompressedSize);
 			if (errorcode != Z_OK)
 			{
-				LOGERROR("Error %d decompressing data for chunk [%d, %d]", 
+				LOGERROR("Error %d decompressing data for chunk [%d, %d]",
 					errorcode,
 					Header->m_ChunkX, Header->m_ChunkZ
 					);
@@ -627,7 +627,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 		char ConvertedData[cChunkDef::BlockDataSize];
 		int Index = 0;
 		unsigned int InChunkOffset = 0;
-		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z ) 
+		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z )
 		{
 			for( int y = 0; y < 128; ++y )
 			{
@@ -638,7 +638,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 			Index += 128;
 		}
 		InChunkOffset += (16 * 128 * 16);
-		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z ) // Metadata
+		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z )  // Metadata
 		{
 			for( int y = 0; y < 64; ++y )
 			{
@@ -648,7 +648,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 			Index += 64;
 		}
 		InChunkOffset += (16 * 128 * 16) / 2;
-		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z ) // Block light
+		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z )  // Block light
 		{
 			for( int y = 0; y < 64; ++y )
 			{
@@ -658,7 +658,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 			Index += 64;
 		}
 		InChunkOffset += (16*128*16)/2;
-		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z ) // Sky light
+		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z )  // Sky light
 		{
 			for( int y = 0; y < 64; ++y )
 			{
@@ -683,7 +683,7 @@ void cWSSCompact::cPAKFile::UpdateChunk1To2()
 			int errorcode = CompressString(Converted.data(), Converted.size(), CompressedData, m_CompressionFactor);
 			if (errorcode != Z_OK)
 			{
-				LOGERROR("Error %d compressing data for chunk [%d, %d]", 
+				LOGERROR("Error %d compressing data for chunk [%d, %d]",
 					errorcode,
 					Header->m_ChunkX, Header->m_ChunkZ
 				);
@@ -747,7 +747,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 			int errorcode = UncompressString(Data.data(), Data.size(), UncompressedData, (size_t)UncompressedSize);
 			if (errorcode != Z_OK)
 			{
-				LOGERROR("Error %d decompressing data for chunk [%d, %d]", 
+				LOGERROR("Error %d decompressing data for chunk [%d, %d]",
 					errorcode,
 					Header->m_ChunkX, Header->m_ChunkZ
 					);
@@ -774,7 +774,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 		#define MAKE_3_INDEX( x, y, z ) ( x + (z * 16) + (y * 16 * 16) )
 
 		unsigned int InChunkOffset = 0;
-		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z ) for( int y = 0; y < 256; ++y ) // YZX Loop order is important, in 1.1 Y was first then Z then X
+		for( int x = 0; x < 16; ++x ) for( int z = 0; z < 16; ++z ) for( int y = 0; y < 256; ++y )  // YZX Loop order is important, in 1.1 Y was first then Z then X
 		{
 			ConvertedData[ MAKE_3_INDEX(x, y, z) ] = UncompressedData[InChunkOffset];
 			++InChunkOffset;
@@ -819,7 +819,7 @@ void cWSSCompact::cPAKFile::UpdateChunk2To3()
 			int errorcode = CompressString(Converted.data(), Converted.size(), CompressedData, m_CompressionFactor);
 			if (errorcode != Z_OK)
 			{
-				LOGERROR("Error %d compressing data for chunk [%d, %d]", 
+				LOGERROR("Error %d compressing data for chunk [%d, %d]",
 					errorcode,
 					Header->m_ChunkX, Header->m_ChunkZ
 					);
@@ -863,7 +863,7 @@ bool cWSSCompact::LoadChunkFromData(const cChunkCoords & a_Chunk, int a_Uncompre
 	int errorcode = UncompressString(a_Data.data(), a_Data.size(), UncompressedData, (size_t)a_UncompressedSize);
 	if (errorcode != Z_OK)
 	{
-		LOGERROR("Error %d decompressing data for chunk [%d, %d]", 
+		LOGERROR("Error %d decompressing data for chunk [%d, %d]",
 			errorcode,
 			a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ
 		);
diff --git a/src/WorldStorage/WSSCompact.h b/src/WorldStorage/WSSCompact.h
index b148005f6..83e9cb49f 100644
--- a/src/WorldStorage/WSSCompact.h
+++ b/src/WorldStorage/WSSCompact.h
@@ -105,15 +105,15 @@ protected:
 		
 		int           m_NumDirty;  // Number of chunks that were written into m_DataContents but not into the file
 
-		Vector3i      m_ChunkSize; // Is related to m_ChunkVersion
+		Vector3i      m_ChunkSize;  // Is related to m_ChunkVersion
 		char          m_ChunkVersion;
 		char          m_PakVersion;
 		
 		bool SaveChunkToData(const cChunkCoords & a_Chunk, cWorld * a_World);  // Saves the chunk to m_DataContents, updates headers and m_NumDirty
 		void SynchronizeFile(void);  // Writes m_DataContents along with the headers to file, resets m_NumDirty
 
-		void UpdateChunk1To2(void); // Height from 128 to 256
-		void UpdateChunk2To3(void); // Axis order from YZX to XZY
+		void UpdateChunk1To2(void);  // Height from 128 to 256
+		void UpdateChunk2To3(void);  // Axis order from YZX to XZY
 	} ;
 	
 	typedef std::list<cPAKFile *> cPAKFiles;
diff --git a/src/WorldStorage/WorldStorage.cpp b/src/WorldStorage/WorldStorage.cpp
index d3f35384b..d0b2acf3b 100644
--- a/src/WorldStorage/WorldStorage.cpp
+++ b/src/WorldStorage/WorldStorage.cpp
@@ -35,7 +35,7 @@ protected:
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cWorldStorage:
 
 cWorldStorage::cWorldStorage(void) :
@@ -96,7 +96,7 @@ void cWorldStorage::WaitForFinish(void)
 	
 	// Wait for the thread to finish:
 	m_ShouldTerminate = true;
-	m_Event.Set(); // Wake up the thread if waiting
+	m_Event.Set();  // Wake up the thread if waiting
 	super::Wait();
 	LOG("World storage thread finished");
 }
@@ -163,7 +163,7 @@ void cWorldStorage::QueueSaveChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
 
 void cWorldStorage::UnqueueLoad(int a_ChunkX, int a_ChunkY, int a_ChunkZ)
 {
-	m_LoadQueue.Remove(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ,true));
+	m_LoadQueue.Remove(sChunkLoad(a_ChunkX, a_ChunkY, a_ChunkZ, true));
 }
 
 
@@ -182,8 +182,8 @@ void cWorldStorage::UnqueueSave(const cChunkCoords & a_Chunk)
 void cWorldStorage::InitSchemas(int a_StorageCompressionFactor)
 {
 	// The first schema added is considered the default
-	m_Schemas.push_back(new cWSSAnvil    (m_World,a_StorageCompressionFactor));
-	m_Schemas.push_back(new cWSSCompact  (m_World,a_StorageCompressionFactor));
+	m_Schemas.push_back(new cWSSAnvil    (m_World, a_StorageCompressionFactor));
+	m_Schemas.push_back(new cWSSCompact  (m_World, a_StorageCompressionFactor));
 	m_Schemas.push_back(new cWSSForgetful(m_World));
 	// Add new schemas here
 	
@@ -202,7 +202,7 @@ void cWorldStorage::InitSchemas(int a_StorageCompressionFactor)
 	}  // for itr - m_Schemas[]
 	
 	// Unknown schema selected, let the admin know:
-	LOGWARNING("Unknown storage schema name \"%s\". Using default (\"%s\"). Available schemas:", 
+	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)
diff --git a/src/WorldStorage/WorldStorage.h b/src/WorldStorage/WorldStorage.h
index 1204b4310..2d5d9c830 100644
--- a/src/WorldStorage/WorldStorage.h
+++ b/src/WorldStorage/WorldStorage.h
@@ -95,21 +95,22 @@ protected:
 
 		bool operator==(const sChunkLoad other) const
 		{
-			return this->m_ChunkX == other.m_ChunkX && 
+			return this->m_ChunkX == other.m_ChunkX &&
 				this->m_ChunkY == other.m_ChunkY &&
 				this->m_ChunkZ == other.m_ChunkZ;
 		}
 	} ;
 
-	struct FuncTable {
+	struct FuncTable
+	{
 		static void Delete(sChunkLoad) {};
-		static void Combine(sChunkLoad& a_orig, const sChunkLoad a_new) 
+		static void Combine(sChunkLoad & a_orig, const sChunkLoad a_new)
 		{
 			a_orig.m_Generate |= a_new.m_Generate;
 		};
 	};
 
-	typedef cQueue<sChunkLoad,FuncTable> sChunkLoadQueue;
+	typedef cQueue<sChunkLoad, FuncTable> sChunkLoadQueue;
 	
 	cWorld * m_World;
 	AString  m_StorageSchemaName;