9 files changed, 31 insertions, 31 deletions

diff --git a/src/WorldStorage/FastNBT.cpp b/src/WorldStorage/FastNBT.cpp
index a047d67c7..8e7247aab 100644
--- a/src/WorldStorage/FastNBT.cpp
+++ b/src/WorldStorage/FastNBT.cpp
@@ -25,7 +25,7 @@
 
 
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 // cParsedNBT:
 
 #define NEEDBYTES(N) \
@@ -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/FireworksSerializer.cpp b/src/WorldStorage/FireworksSerializer.cpp
index 181cfde0d..5a2be8867 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);
 
@@ -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/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index 6d0b60371..3f79a6572 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();
 }
 
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..388ad0332 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -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) :
@@ -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;
@@ -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/WSSCompact.cpp b/src/WorldStorage/WSSCompact.cpp
index a3ba443fd..3b08c5ac5 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",
@@ -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 )
 			{
@@ -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;
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..b6d572f3e 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");
 }