11 files changed, 101 insertions, 67 deletions

diff --git a/source/WSSCompact.cpp b/source/WSSCompact.cpp
index 04fb45351..3b0f6c2cf 100644
--- a/source/WSSCompact.cpp
+++ b/source/WSSCompact.cpp
@@ -313,7 +313,7 @@ bool cWSSCompact::cPAKFile::LoadChunk(const cChunkCoords & a_Chunk, int a_Offset
 		}

 	}

 

-	a_World->ChunkDataLoaded(a_Chunk.m_ChunkX, 0, a_Chunk.m_ChunkZ, UncompressedData.data(), Entities, BlockEntities);

+	a_World->ChunkDataLoaded(a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ, UncompressedData.data(), Entities, BlockEntities);

 

 	return true;

 }

@@ -348,11 +348,11 @@ bool cWSSCompact::cPAKFile::SaveChunkToData(const cChunkCoords & a_Chunk, cWorld
 {

 	// Serialize the chunk:

 	cJsonChunkSerializer Serializer;

-	a_World->GetChunkData(a_Chunk.m_ChunkX, 0, a_Chunk.m_ChunkZ, &Serializer);

+	a_World->GetChunkData(a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ, &Serializer);

 	if (Serializer.GetBlockData().empty())

 	{

 		// Chunk not valid

-		LOG("cWSSCompact: Trying to save chunk [%d, %d] that has no data, ignoring request.", a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ);

+		LOG("cWSSCompact: Trying to save chunk [%d, %d, %d] that has no data, ignoring request.", a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ);

 		return false;

 	}

 

@@ -371,7 +371,7 @@ bool cWSSCompact::cPAKFile::SaveChunkToData(const cChunkCoords & a_Chunk, cWorld
 	int errorcode = CompressString(Data.data(), Data.size(), CompressedData);

 	if ( errorcode != Z_OK )

 	{

-		LOGERROR("Error %i compressing data for chunk [%d, %d]", errorcode, a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ);

+		LOGERROR("Error %i compressing data for chunk [%d, %d, %d]", errorcode, a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ);

 		return false;

 	}

 	

@@ -382,7 +382,7 @@ bool cWSSCompact::cPAKFile::SaveChunkToData(const cChunkCoords & a_Chunk, cWorld
 	sChunkHeader * Header = new sChunkHeader;

 	if (Header == NULL)

 	{

-		LOGWARNING("Cannot create a new chunk header to save chunk [%d, %d]", a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ);

+		LOGWARNING("Cannot create a new chunk header to save chunk [%d, %d, %d]", a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ);

 		return false;

 	}

 	Header->m_CompressedSize = (int)CompressedData.size();

diff --git a/source/WorldStorage.cpp b/source/WorldStorage.cpp
index 73ad18f15..f6be97753 100644
--- a/source/WorldStorage.cpp
+++ b/source/WorldStorage.cpp
@@ -161,12 +161,12 @@ void cWorldStorage::WaitForFinish(void)
 

 

 

-void cWorldStorage::QueueLoadChunk(int a_ChunkX, int a_ChunkZ)

+void cWorldStorage::QueueLoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)

 {

 	// Queues the chunk for loading; if not loaded, the chunk will be generated

 	cCSLock Lock(m_CSLoadQueue);

-	m_LoadQueue.remove   (cChunkCoords(a_ChunkX, a_ChunkZ));  // Don't add twice

-	m_LoadQueue.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));

+	m_LoadQueue.remove   (cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));  // Don't add twice

+	m_LoadQueue.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));

 	m_Event.Set();

 }

 

@@ -174,11 +174,11 @@ void cWorldStorage::QueueLoadChunk(int a_ChunkX, int a_ChunkZ)
 

 

 

-void cWorldStorage::QueueSaveChunk(int a_ChunkX, int a_ChunkZ)

+void cWorldStorage::QueueSaveChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)

 {

 	cCSLock Lock(m_CSSaveQueue);

-	m_SaveQueue.remove   (cChunkCoords(a_ChunkX, a_ChunkZ));  // Don't add twice

-	m_SaveQueue.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));

+	m_SaveQueue.remove   (cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));  // Don't add twice

+	m_SaveQueue.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));

 	m_Event.Set();

 }

 

@@ -268,7 +268,7 @@ void cWorldStorage::Execute(void)
 

 bool cWorldStorage::LoadOneChunk(void)

 {

-	cChunkCoords ToLoad(0, 0);

+	cChunkCoords ToLoad(0, 0, 0);

 	bool HasMore;

 	bool ShouldLoad = false;

 	{

@@ -284,7 +284,7 @@ bool cWorldStorage::LoadOneChunk(void)
 	if (ShouldLoad && !LoadChunk(ToLoad))

 	{

 		// The chunk couldn't be loaded, generate it:

-		m_World->GetGenerator().GenerateChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkZ);

+		m_World->GetGenerator().GenerateChunk(ToLoad.m_ChunkX, ToLoad.m_ChunkY, ToLoad.m_ChunkZ);

 	}

 	return HasMore;

 }

@@ -295,7 +295,7 @@ bool cWorldStorage::LoadOneChunk(void)
 

 bool cWorldStorage::SaveOneChunk(void)

 {

-	cChunkCoords Save(0, 0);

+	cChunkCoords Save(0, 0, 0);

 	bool HasMore;

 	bool ShouldSave = false;

 	{

@@ -308,16 +308,16 @@ bool cWorldStorage::SaveOneChunk(void)
 		}

 		HasMore = (m_SaveQueue.size() > 0);

 	}

-	if (ShouldSave)

+	if (ShouldSave && m_World->IsChunkValid(Save.m_ChunkX, Save.m_ChunkY, Save.m_ChunkZ))

 	{

-		m_World->MarkChunkSaving(Save.m_ChunkX, 0, Save.m_ChunkZ);

+		m_World->MarkChunkSaving(Save.m_ChunkX, Save.m_ChunkY, Save.m_ChunkZ);

 		if (m_SaveSchema->SaveChunk(Save))

 		{

-			m_World->MarkChunkSaved(Save.m_ChunkX, 0, Save.m_ChunkZ);

+			m_World->MarkChunkSaved(Save.m_ChunkX, Save.m_ChunkY, Save.m_ChunkZ);

 		}

 		else

 		{

-			LOGWARNING("Cannot save chunk [%d, %d]", Save.m_ChunkX, Save.m_ChunkZ);

+			LOGWARNING("Cannot save chunk [%d, %d, %d]", Save.m_ChunkX, Save.m_ChunkY, Save.m_ChunkZ);

 		}

 	}

 	return HasMore;

@@ -329,7 +329,7 @@ bool cWorldStorage::SaveOneChunk(void)
 

 bool cWorldStorage::LoadChunk(const cChunkCoords & a_Chunk)

 {

-	if (m_World->IsChunkValid(a_Chunk.m_ChunkX, 0, a_Chunk.m_ChunkZ))

+	if (m_World->IsChunkValid(a_Chunk.m_ChunkX, a_Chunk.m_ChunkY, a_Chunk.m_ChunkZ))

 	{

 		// Already loaded (can happen, since the queue is async)

 		return true;

diff --git a/source/WorldStorage.h b/source/WorldStorage.h
index 5de7f49fa..220585c57 100644
--- a/source/WorldStorage.h
+++ b/source/WorldStorage.h
@@ -97,8 +97,8 @@ public:
 	cWorldStorage(void);

 	~cWorldStorage();

 	

-	void QueueLoadChunk(int a_ChunkX, int a_ChunkZ);  // Queues the chunk for loading; if not loaded, the chunk will be generated

-	void QueueSaveChunk(int a_ChunkX, int a_ChunkZ);

+	void QueueLoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);  // Queues the chunk for loading; if not loaded, the chunk will be generated

+	void QueueSaveChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);

 	

 	void UnqueueLoad(const cChunkCoords & a_Chunk);

 	void UnqueueSave(const cChunkCoords & a_Chunk);

diff --git a/source/cChunk.h b/source/cChunk.h
index 66efa0d1e..b750e10db 100644
--- a/source/cChunk.h
+++ b/source/cChunk.h
@@ -20,6 +20,15 @@
 

 

 

+/** This is really only a placeholder to be used in places where we need to "make up" a chunk's Y coord.

+It will help us when the new chunk format comes out and we need to patch everything up for compatibility.

+*/

+#define ZERO_CHUNK_Y 0

+

+

+

+

+

 namespace Json

 {

 	class Value;

@@ -238,13 +247,14 @@ class cChunkCoords
 {

 public:

 	int m_ChunkX;

+	int m_ChunkY;

 	int m_ChunkZ;

 	

-	cChunkCoords(int a_ChunkX, int a_ChunkZ) : m_ChunkX(a_ChunkX), m_ChunkZ(a_ChunkZ) {}

+	cChunkCoords(int a_ChunkX, int a_ChunkY, int a_ChunkZ) : m_ChunkX(a_ChunkX), m_ChunkY(a_ChunkY), m_ChunkZ(a_ChunkZ) {}

 	

 	bool operator == (const cChunkCoords & a_Other)

 	{

-		return ((m_ChunkX == a_Other.m_ChunkX) && (m_ChunkZ == a_Other.m_ChunkZ));

+		return ((m_ChunkX == a_Other.m_ChunkX) && (m_ChunkY == a_Other.m_ChunkY) && (m_ChunkZ == a_Other.m_ChunkZ));

 	}

 } ;

 

diff --git a/source/cChunkGenerator.cpp b/source/cChunkGenerator.cpp
index 4d9aef421..5c8144f05 100644
--- a/source/cChunkGenerator.cpp
+++ b/source/cChunkGenerator.cpp
@@ -81,14 +81,14 @@ void cChunkGenerator::Stop(void)
 

 

 

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

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

 {

 	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 ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))

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

 		{

 			// Already in the queue, bail out

 			return;

@@ -100,7 +100,7 @@ void cChunkGenerator::GenerateChunk(int a_ChunkX, int a_ChunkZ)
 	{

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

 	}

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

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

 	

 	m_Event.Set();

 }

@@ -130,24 +130,32 @@ void cChunkGenerator::Execute(void)
 		Lock.Unlock();			// Unlock ASAP

 

 		if (

-			m_World->IsChunkValid(coords.m_ChunkX, 0, coords.m_ChunkZ) ||

-			(SkipEnabled && m_World->HasChunkAnyClients(coords.m_ChunkX, 0, coords.m_ChunkZ))

+			m_World->IsChunkValid(coords.m_ChunkX, coords.m_ChunkY, coords.m_ChunkZ) ||

+			(SkipEnabled && m_World->HasChunkAnyClients(coords.m_ChunkX, coords.m_ChunkY, coords.m_ChunkZ))

 		)

 		{

 			// Already generated / overload-skip, ignore request

 			continue;

 		}

 		

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

-		m_pWorldGenerator->GenerateChunk(coords.m_ChunkX, 0, coords.m_ChunkZ);

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

+		DoGenerate(coords.m_ChunkX, coords.m_ChunkY, coords.m_ChunkZ);

 		

-		// Chunk->SetValid();

-

 		// Save the chunk right after generating, so that we don't have to generate it again on next run

-		m_World->GetStorage().QueueSaveChunk(coords.m_ChunkX, coords.m_ChunkZ);

+		m_World->GetStorage().QueueSaveChunk(coords.m_ChunkX, coords.m_ChunkY, coords.m_ChunkZ);

 	}  // while (!bStop)

 }

 

 

 

 

+void cChunkGenerator::DoGenerate(int a_ChunkX, int a_ChunkY, int a_ChunkZ)

+{

+	// TODO: Convert this not to require the actual cChunkPtr (generate into raw char array)

+	// char BlockData[cChunk::c_BlockDataSize];

+	m_pWorldGenerator->GenerateChunk(a_ChunkX, a_ChunkY, a_ChunkZ);

+}

+

+

+

+

diff --git a/source/cChunkGenerator.h b/source/cChunkGenerator.h
index 5de056572..8b0efc9e8 100644
--- a/source/cChunkGenerator.h
+++ b/source/cChunkGenerator.h
@@ -42,19 +42,21 @@ public:
 	bool Start(cWorld * a_World, const AString & a_WorldGeneratorName);

 	void Stop(void);

 

-	void GenerateChunk(int a_ChunkX, int a_ChunkZ);  // Queues the chunk for generation; removes duplicate requests

+	void GenerateChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);  // Queues the chunk for generation; removes duplicate requests

 

 private:

 

-	// cIsThread override:

-	virtual void Execute(void) override;

-

 	cWorld * m_World;

 	cWorldGenerator * m_pWorldGenerator;

 

 	cCriticalSection m_CS;

 	cChunkCoordsList m_Queue;

 	cEvent           m_Event;  // Set when an item is added to the queue or the thread should terminate

+

+	// cIsThread override:

+	virtual void Execute(void) override;

+

+	void DoGenerate(int a_ChunkX, int a_ChunkY, int a_ChunkZ);

 };

 

 

diff --git a/source/cChunkMap.cpp b/source/cChunkMap.cpp
index dbe6607fc..7adaebf90 100644
--- a/source/cChunkMap.cpp
+++ b/source/cChunkMap.cpp
@@ -103,10 +103,10 @@ cChunkPtr cChunkMap::GetChunk( int a_ChunkX, int a_ChunkY, int a_ChunkZ )
 		return cChunkPtr();

 	}

 	

-	cChunkPtr Chunk = Layer->GetChunk(a_ChunkX, a_ChunkZ);

+	cChunkPtr Chunk = Layer->GetChunk(a_ChunkX, a_ChunkY, a_ChunkZ);

 	if (!(Chunk->IsValid()))

 	{

-		m_World->GetStorage().QueueLoadChunk(a_ChunkX, a_ChunkZ);

+		m_World->GetStorage().QueueLoadChunk(a_ChunkX, a_ChunkY, a_ChunkZ);

 	}

 	return Chunk;

 }

@@ -125,7 +125,7 @@ cChunkPtr cChunkMap::GetChunkNoGen( int a_ChunkX, int a_ChunkY, int a_ChunkZ )
 		return cChunkPtr();

 	}

 	

-	cChunkPtr Chunk = Layer->GetChunk(a_ChunkX, a_ChunkZ);

+	cChunkPtr Chunk = Layer->GetChunk(a_ChunkX, a_ChunkY, a_ChunkZ);

 	

 	// TODO: Load, but do not generate, if not valid

 	

@@ -341,7 +341,7 @@ cChunkMap::cChunkLayer::cChunkLayer(int a_LayerX, int a_LayerZ, cChunkMap * a_Pa
 

 

 

-cChunkPtr cChunkMap::cChunkLayer::GetChunk( int a_ChunkX, int a_ChunkZ )

+cChunkPtr cChunkMap::cChunkLayer::GetChunk( int a_ChunkX, int a_ChunkY, int a_ChunkZ )

 {

 	// Always returns an assigned chunkptr, but the chunk needn't be valid (loaded / generated) - callers must check

 	

@@ -371,7 +371,8 @@ void cChunkMap::cChunkLayer::Tick(float a_Dt, MTRand & a_TickRand)
 {

 	for (int i = 0; i < ARRAYCOUNT(m_Chunks); i++)

 	{

-		if ((m_Chunks[i] != NULL) && (m_Chunks[i]->IsValid()))

+		// Only tick chunks that are valid and have clients:

+		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid() && m_Chunks[i]->HasAnyClients())

 		{

 			m_Chunks[i]->Tick(a_Dt, a_TickRand);

 		}

@@ -382,6 +383,23 @@ void cChunkMap::cChunkLayer::Tick(float a_Dt, MTRand & a_TickRand)
 

 

 

+int cChunkMap::cChunkLayer::GetNumChunksLoaded(void) const

+{

+	int NumChunks = 0;

+	for ( int i = 0; i < ARRAYCOUNT(m_Chunks); ++i )

+	{

+		if (m_Chunks[i] != NULL)

+		{

+			NumChunks++;

+		}

+	}  // for i - m_Chunks[]

+	return NumChunks; 

+}

+

+

+

+

+

 void cChunkMap::cChunkLayer::Save(void)

 {

 	cWorld * World = m_Parent->GetWorld();

@@ -389,7 +407,7 @@ void cChunkMap::cChunkLayer::Save(void)
 	{

 		if ((m_Chunks[i] != NULL) && m_Chunks[i]->IsValid() && m_Chunks[i]->IsDirty())

 		{

-			World->GetStorage().QueueSaveChunk(m_Chunks[i]->GetPosX(), m_Chunks[i]->GetPosZ());

+			World->GetStorage().QueueSaveChunk(m_Chunks[i]->GetPosX(), m_Chunks[i]->GetPosY(), m_Chunks[i]->GetPosZ());

 		}

 	}  // for i - m_Chunks[]

 }

diff --git a/source/cChunkMap.h b/source/cChunkMap.h
index 0b3e79931..4ec7ef01d 100644
--- a/source/cChunkMap.h
+++ b/source/cChunkMap.h
@@ -89,18 +89,12 @@ private:
 		cChunkLayer(int a_LayerX, int a_LayerZ, cChunkMap * a_Parent);

 

 		/// Always returns an assigned chunkptr, but the chunk needn't be valid (loaded / generated) - callers must check

-		cChunkPtr GetChunk( int a_ChunkX, int a_ChunkZ );

+		cChunkPtr GetChunk( int a_ChunkX, int a_ChunkY, int a_ChunkZ );

 		

 		int GetX(void) const {return m_LayerX; }

 		int GetZ(void) const {return m_LayerZ; }

-		int GetNumChunksLoaded(void) const 

-		{

-			int NumChunks = 0;

-			for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i )

-				if( m_Chunks[i].get() )

-					NumChunks++;

-			return NumChunks; 

-		}

+		

+		int GetNumChunksLoaded(void) const ;

 		

 		void Save(void);

 		void UnloadUnusedChunks(void);

diff --git a/source/cClientHandle.cpp b/source/cClientHandle.cpp
index c8f8e82ed..6edddac6b 100644
--- a/source/cClientHandle.cpp
+++ b/source/cClientHandle.cpp
@@ -342,7 +342,7 @@ void cClientHandle::StreamChunks(void)
 			int RelZ = (*itr).m_ChunkZ - ChunkPosZ;

 			if ((RelX > VIEWDISTANCE) || (RelX < -VIEWDISTANCE) || (RelZ > VIEWDISTANCE) || (RelZ < -VIEWDISTANCE))

 			{

-				World->GetChunk((*itr).m_ChunkX, 0, (*itr).m_ChunkZ)->RemoveClient(this);

+				World->GetChunk(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ)->RemoveClient(this);

 				itr = m_LoadedChunks.erase(itr);

 			}

 			else

@@ -372,13 +372,13 @@ void cClientHandle::StreamChunks(void)
 		// For each distance add chunks in a hollow square centered around current position:

 		for (int i = -d; i <= d; ++i)

 		{

-			StreamChunk(ChunkPosX + d, ChunkPosZ + i);

-			StreamChunk(ChunkPosX - d, ChunkPosZ + i);

+			StreamChunk(ChunkPosX + d, ZERO_CHUNK_Y, ChunkPosZ + i);

+			StreamChunk(ChunkPosX - d, ZERO_CHUNK_Y, ChunkPosZ + i);

 		}  // for i

 		for (int i = -d + 1; i < d; ++i)

 		{

-			StreamChunk(ChunkPosX + i, ChunkPosZ + d);

-			StreamChunk(ChunkPosX + i, ChunkPosZ - d);

+			StreamChunk(ChunkPosX + i, ZERO_CHUNK_Y, ChunkPosZ + d);

+			StreamChunk(ChunkPosX + i, ZERO_CHUNK_Y, ChunkPosZ - d);

 		}  // for i

 	}  // for d

 	

@@ -388,13 +388,13 @@ void cClientHandle::StreamChunks(void)
 		// For each distance touch chunks in a hollow square centered around current position:

 		for (int i = -d; i <= d; ++i)

 		{

-			World->GetChunk(ChunkPosX + d, 0, ChunkPosZ + i);

-			World->GetChunk(ChunkPosX - d, 0, ChunkPosZ + i);

+			World->GetChunk(ChunkPosX + d, ZERO_CHUNK_Y, ChunkPosZ + i);

+			World->GetChunk(ChunkPosX - d, ZERO_CHUNK_Y, ChunkPosZ + i);

 		}  // for i

 		for (int i = -d + 1; i < d; ++i)

 		{

-			World->GetChunk(ChunkPosX + i, 0, ChunkPosZ + d);

-			World->GetChunk(ChunkPosX + i, 0, ChunkPosZ - d);

+			World->GetChunk(ChunkPosX + i, ZERO_CHUNK_Y, ChunkPosZ + d);

+			World->GetChunk(ChunkPosX + i, ZERO_CHUNK_Y, ChunkPosZ - d);

 		}  // for i

 	}  // for d

 }

@@ -402,7 +402,7 @@ void cClientHandle::StreamChunks(void)
 

 

 

-void cClientHandle::StreamChunk(int a_ChunkX, int a_ChunkZ)

+void cClientHandle::StreamChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ)

 {

 	cWorld * World = m_Player->GetWorld();

 	assert(World != NULL);

@@ -412,8 +412,8 @@ void cClientHandle::StreamChunk(int a_ChunkX, int a_ChunkZ)
 	{

 		Chunk->AddClient(this);

 		cCSLock Lock(m_CSChunkLists);

-		m_LoadedChunks.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));

-		m_ChunksToSend.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));

+		m_LoadedChunks.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));

+		m_ChunksToSend.push_back(cChunkCoords(a_ChunkX, a_ChunkY, a_ChunkZ));

 	}

 }

 

@@ -430,7 +430,7 @@ void cClientHandle::RemoveFromAllChunks()
 	{

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

 		{

-			World->GetChunk(itr->m_ChunkX, 0, itr->m_ChunkZ)->RemoveClient(this);

+			World->GetChunk(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ)->RemoveClient(this);

 		}

 	}

 	m_LoadedChunks.clear();

@@ -1656,7 +1656,7 @@ void cClientHandle::Tick(float a_Dt)
 		int NumSent = 0;

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

 		{

-			cChunkPtr Chunk = World->GetChunk(itr->m_ChunkX, 0, itr->m_ChunkZ);

+			cChunkPtr Chunk = World->GetChunk(itr->m_ChunkX, itr->m_ChunkY, itr->m_ChunkZ);

 			if (!Chunk->IsValid())

 			{

 				++itr;

diff --git a/source/cClientHandle.h b/source/cClientHandle.h
index f45cf5b7d..ffe25db2b 100644
--- a/source/cClientHandle.h
+++ b/source/cClientHandle.h
@@ -201,7 +201,7 @@ private:
 	void SendConfirmPosition(void);

 	

 	/// Adds a single chunk to be streamed to the client; used by StreamChunks()

-	void StreamChunk(int a_ChunkX, int a_ChunkZ);

+	void StreamChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ);

 	

 	// cSocketThreads::cCallback overrides:

 	virtual void DataReceived   (const char * a_Data, int a_Size) override;  // Data is received from the client

diff --git a/source/cWorld.cpp b/source/cWorld.cpp
index ca435fe64..744780242 100644
--- a/source/cWorld.cpp
+++ b/source/cWorld.cpp
@@ -273,6 +273,8 @@ cWorld::cWorld( const AString & a_WorldName )
 	g_BlockTransparent[ E_BLOCK_TORCH ]		= true;

 	g_BlockTransparent[ E_BLOCK_SIGN_POST ] = true;

 	g_BlockTransparent[ E_BLOCK_WALLSIGN ]	= true;

+	

+	// TODO: Also set flowers, mushrooms etc as transparent

 

 	// One hit break blocks

 	g_BlockOneHitDig[ E_BLOCK_SAPLING ]				= true;