12 files changed, 191 insertions, 261 deletions

diff --git a/MCServer/Plugins/MagicCarpet b/MCServer/Plugins/MagicCarpet
-Subproject 94da343b62f0498a5843247f36d6ee00cbeb8f2
+Subproject 493f2dfa6d39f134e37c4c614cf8d6ffd10c825
diff --git a/src/BlockEntities/BlockEntity.h b/src/BlockEntities/BlockEntity.h
index 85f75a523..71367efb6 100644
--- a/src/BlockEntities/BlockEntity.h
+++ b/src/BlockEntities/BlockEntity.h
@@ -85,6 +85,7 @@ public:
 	// tolua_begin
 	
 	// Position, in absolute block coordinates:
+	Vector3i GetPos(void) const { return Vector3i{m_PosX, m_PosY, m_PosZ}; }
 	int GetPosX(void) const { return m_PosX; }
 	int GetPosY(void) const { return m_PosY; }
 	int GetPosZ(void) const { return m_PosZ; }
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 7af669163..02bc2ba8c 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -2852,22 +2852,6 @@ void cChunk::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cons
 
 
 
-void cChunk::BroadcastChunkData(cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude)
-{
-	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
-	{
-		if (*itr == a_Exclude)
-		{
-			continue;
-		}
-		(*itr)->SendChunkData(m_PosX, m_PosZ, a_Serializer);
-	}  // for itr - LoadedByClient[]
-}
-
-
-
-
-
 void cChunk::BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude)
 {
 	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
diff --git a/src/Chunk.h b/src/Chunk.h
index f57769107..fd9ea0b0c 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -319,7 +319,6 @@ public:
 	void BroadcastBlockAction        (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastBlockBreakAnimation(UInt32 a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastBlockEntity        (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = nullptr);
-	void BroadcastChunkData          (cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastCollectEntity      (const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastDestroyEntity      (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastEntityEffect       (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = nullptr);
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index 2f38e4cd6..4db73971c 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -409,22 +409,6 @@ void cChunkMap::BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, c
 
 
 
-void cChunkMap::BroadcastChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude)
-{
-	cCSLock Lock(m_CSLayers);
-	cChunkPtr Chunk = GetChunkNoGen(a_ChunkX, a_ChunkZ);
-	if (Chunk == nullptr)
-	{
-		return;
-	}
-	// It's perfectly legal to broadcast packets even to invalid chunks!
-	Chunk->BroadcastChunkData(a_Serializer, a_Exclude);
-}
-
-
-
-
-
 void cChunkMap::BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude)
 {
 	cCSLock Lock(m_CSLayers);
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 964188bbe..916a3433d 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -73,7 +73,6 @@ public:
 	void BroadcastBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastBlockBreakAnimation(UInt32 a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastBlockEntity(int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude);
-	void BroadcastChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastCollectPickup(const cPickup & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastDestroyEntity(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
diff --git a/src/ChunkSender.cpp b/src/ChunkSender.cpp
index 2f18ea75c..877aacfc5 100644
--- a/src/ChunkSender.cpp
+++ b/src/ChunkSender.cpp
@@ -13,6 +13,7 @@
 #include "BlockEntities/BlockEntity.h"
 #include "Protocol/ChunkDataSerializer.h"
 #include "ClientHandle.h"
+#include "Chunk.h"
 
 
 
@@ -28,25 +29,29 @@ class cNotifyChunkSender :
 {
 	virtual void Call(int a_ChunkX, int a_ChunkZ) override
 	{
-		m_ChunkSender->ChunkReady(a_ChunkX, a_ChunkZ);
+		cChunkSender & ChunkSender = m_ChunkSender;
+		m_World.DoWithChunk(
+			a_ChunkX, a_ChunkZ,
+			[&ChunkSender] (cChunk & a_Chunk) -> bool
+			{
+				ChunkSender.QueueSendChunkTo(a_Chunk.GetPosX(), a_Chunk.GetPosZ(), cChunkSender::PRIORITY_BROADCAST, a_Chunk.GetAllClients());
+				return true;
+			}
+		);
 	}
 
-	cChunkSender * m_ChunkSender;
-public:
-	cNotifyChunkSender(cChunkSender * a_ChunkSender) : m_ChunkSender(a_ChunkSender) {}
-};
-
-
-
+	cChunkSender & m_ChunkSender;
 
+	cWorld & m_World;
+public:
+	cNotifyChunkSender(cChunkSender & a_ChunkSender, cWorld & a_World) : m_ChunkSender(a_ChunkSender), m_World(a_World) {}
 
 
-////////////////////////////////////////////////////////////////////////////////
-// cChunkSender:
+};
 
-cChunkSender::cChunkSender(void) :
+cChunkSender::cChunkSender(cWorld & a_World) :
 	super("ChunkSender"),
-	m_World(nullptr),
+	m_World(a_World),
 	m_RemoveCount(0)
 {
 }
@@ -64,10 +69,9 @@ cChunkSender::~cChunkSender()
 
 
 
-bool cChunkSender::Start(cWorld * a_World)
+bool cChunkSender::Start()
 {
 	m_ShouldTerminate = false;
-	m_World = a_World;
 	return super::Start();
 }
 
@@ -86,12 +90,30 @@ void cChunkSender::Stop(void)
 
 
 
-void cChunkSender::ChunkReady(int a_ChunkX, int a_ChunkZ)
+void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, cClientHandle * a_Client)
 {
-	// This is probably never gonna be called twice for the same chunk, and if it is, we don't mind, so we don't check
+	ASSERT(a_Client != nullptr);
 	{
+		cChunkCoords Chunk{a_ChunkX, a_ChunkZ};
 		cCSLock Lock(m_CS);
-		m_ChunksReady.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
+		auto iter = m_ChunkInfo.find(Chunk);
+		if (iter != m_ChunkInfo.end())
+		{
+			auto & info = iter->second;
+			if (info.m_Priority > a_Priority)
+			{
+				m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
+				info.m_Priority = a_Priority;
+			}
+			info.m_Clients.insert(a_Client);
+		}
+		else
+		{
+			m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
+			auto info = sSendChunk{Chunk, a_Priority};
+			info.m_Clients.insert(a_Client);
+			m_ChunkInfo.emplace(Chunk, info);
+		}
 	}
 	m_evtQueue.Set();
 }
@@ -100,40 +122,29 @@ void cChunkSender::ChunkReady(int a_ChunkX, int a_ChunkZ)
 
 
 
-void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, cClientHandle * a_Client)
+
+void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, std::list<cClientHandle *> a_Clients)
 {
-	ASSERT(a_Client != nullptr);
 	{
-		sSendChunk Chunk(a_ChunkX, a_ChunkZ, a_Client);
-
+		cChunkCoords Chunk{a_ChunkX, a_ChunkZ};
 		cCSLock Lock(m_CS);
-		if (
-			std::find(m_SendChunksLowPriority.begin(), m_SendChunksLowPriority.end(), Chunk) != m_SendChunksLowPriority.end() ||
-			std::find(m_SendChunksMediumPriority.begin(), m_SendChunksMediumPriority.end(), Chunk) != m_SendChunksMediumPriority.end() ||
-			std::find(m_SendChunksHighPriority.begin(), m_SendChunksHighPriority.end(), Chunk) != m_SendChunksHighPriority.end()
-		)
+		auto iter = m_ChunkInfo.find(Chunk);
+		if (iter != m_ChunkInfo.end())
 		{
-			// Already queued, bail out
-			return;
-		}
-
-		switch (a_Priority)
-		{
-			case E_CHUNK_PRIORITY_LOW:
-			{
-				m_SendChunksLowPriority.push_back(Chunk);
-				break;
-			}
-			case E_CHUNK_PRIORITY_MEDIUM:
-			{
-				m_SendChunksMediumPriority.push_back(Chunk);
-				break;
-			}
-			case E_CHUNK_PRIORITY_HIGH:
+			auto & info = iter->second;
+			if (info.m_Priority > a_Priority)
 			{
-				m_SendChunksHighPriority.push_back(Chunk);
-				break;
+				m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
+				info.m_Priority = a_Priority;
 			}
+			info.m_Clients.insert(a_Clients.begin(), a_Clients.end());
+		}
+		else
+		{
+			m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
+			auto info = sSendChunk{Chunk, a_Priority};
+			info.m_Clients.insert(a_Clients.begin(), a_Clients.end());
+			m_ChunkInfo.emplace(Chunk, info);
 		}
 	}
 	m_evtQueue.Set();
@@ -147,33 +158,12 @@ void cChunkSender::RemoveClient(cClientHandle * a_Client)
 {
 	{
 		cCSLock Lock(m_CS);
-		for (sSendChunkList::iterator itr = m_SendChunksLowPriority.begin(); itr != m_SendChunksLowPriority.end();)
-		{
-			if (itr->m_Client == a_Client)
-			{
-				itr = m_SendChunksLowPriority.erase(itr);
-				continue;
-			}
-			++itr;
-		}  // for itr - m_SendChunksLowPriority[]
-		for (sSendChunkList::iterator itr = m_SendChunksMediumPriority.begin(); itr != m_SendChunksMediumPriority.end();)
+		for (auto && pair : m_ChunkInfo)
 		{
-			if (itr->m_Client == a_Client)
-			{
-				itr = m_SendChunksMediumPriority.erase(itr);
-				continue;
-			}
-			++itr;
-		}  // for itr - m_SendChunksMediumPriority[]
-		for (sSendChunkList::iterator itr = m_SendChunksHighPriority.begin(); itr != m_SendChunksHighPriority.end();)
-		{
-			if (itr->m_Client == a_Client)
-			{
-				itr = m_SendChunksHighPriority.erase(itr);
-				continue;
-			}
-			++itr;
-		}  // for itr - m_SendChunksHighPriority[]
+			auto && clients = pair.second.m_Clients;
+			clients.erase(a_Client);  // nop for sets that do not contain a_Client
+		}
+
 		m_RemoveCount++;
 	}
 	m_evtQueue.Set();
@@ -189,7 +179,7 @@ void cChunkSender::Execute(void)
 	while (!m_ShouldTerminate)
 	{
 		cCSLock Lock(m_CS);
-		while (m_ChunksReady.empty() && m_SendChunksLowPriority.empty() && m_SendChunksMediumPriority.empty() && m_SendChunksHighPriority.empty())
+		do
 		{
 			int RemoveCount = m_RemoveCount;
 			m_RemoveCount = 0;
@@ -203,52 +193,24 @@ void cChunkSender::Execute(void)
 			{
 				return;
 			}
-		}  // while (empty)
-
-		if (!m_SendChunksHighPriority.empty())
-		{
-			// Take one from the queue:
-			sSendChunk Chunk(m_SendChunksHighPriority.front());
-			m_SendChunksHighPriority.pop_front();
-			Lock.Unlock();
+		} while (m_SendChunks.empty());
 
-			SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, Chunk.m_Client);
-		}
-		else if (!m_ChunksReady.empty())
+		// Take one from the queue:
+		auto Chunk = m_SendChunks.top().m_Chunk;
+		m_SendChunks.pop();
+		auto itr = m_ChunkInfo.find(Chunk);
+		if (itr == m_ChunkInfo.end())
 		{
-			// Take one from the queue:
-			cChunkCoords Coords(m_ChunksReady.front());
-			m_ChunksReady.pop_front();
-			Lock.Unlock();
-			
-			SendChunk(Coords.m_ChunkX, Coords.m_ChunkZ, nullptr);
+			continue;
 		}
-		else if (!m_SendChunksMediumPriority.empty())
-		{
-			// Take one from the queue:
-			sSendChunk Chunk(m_SendChunksMediumPriority.front());
-			m_SendChunksMediumPriority.pop_front();
-			Lock.Unlock();
+		
+		std::unordered_set<cClientHandle *> clients;
+		std::swap(itr->second.m_Clients, clients);
+		m_ChunkInfo.erase(itr);
 
-			SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, Chunk.m_Client);
-		}
-		else
-		{
-			// Take one from the queue:
-			sSendChunk Chunk(m_SendChunksLowPriority.front());
-			m_SendChunksLowPriority.pop_front();
-			Lock.Unlock();
-
-			SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, Chunk.m_Client);
-		}
-		Lock.Lock();
-		int RemoveCount = m_RemoveCount;
-		m_RemoveCount = 0;
 		Lock.Unlock();
-		for (int i = 0; i < RemoveCount; i++)
-		{
-			m_evtRemoved.Set();  // Notify that the removed clients are safe to be deleted
-		}
+
+		SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, clients);
 	}  // while (!mShouldTerminate)
 }
 
@@ -256,64 +218,60 @@ void cChunkSender::Execute(void)
 
 
 
-void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client)
+void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, std::unordered_set<cClientHandle *> a_Clients)
 {
-	ASSERT(m_World != nullptr);
 	
 	// Ask the client if it still wants the chunk:
-	if ((a_Client != nullptr) && !a_Client->WantsSendChunk(a_ChunkX, a_ChunkZ))
+	for (auto itr = a_Clients.begin(); itr != a_Clients.end();)
 	{
-		return;
+		if (!(*itr)->WantsSendChunk(a_ChunkX, a_ChunkZ))
+		{
+			itr = a_Clients.erase(itr);
+		}
+		else
+		{
+			itr++;
+		}
 	}
 
 	// If the chunk has no clients, no need to packetize it:
-	if (!m_World->HasChunkAnyClients(a_ChunkX, a_ChunkZ))
+	if (!m_World.HasChunkAnyClients(a_ChunkX, a_ChunkZ))
 	{
 		return;
 	}
 
 	// If the chunk is not valid, do nothing - whoever needs it has queued it for loading / generating
-	if (!m_World->IsChunkValid(a_ChunkX, a_ChunkZ))
+	if (!m_World.IsChunkValid(a_ChunkX, a_ChunkZ))
 	{
 		return;
 	}
 
 	// If the chunk is not lighted, queue it for relighting and get notified when it's ready:
-	if (!m_World->IsChunkLighted(a_ChunkX, a_ChunkZ))
+	if (!m_World.IsChunkLighted(a_ChunkX, a_ChunkZ))
 	{
-		m_World->QueueLightChunk(a_ChunkX, a_ChunkZ, cpp14::make_unique<cNotifyChunkSender>(this));
+		m_World.QueueLightChunk(a_ChunkX, a_ChunkZ, cpp14::make_unique<cNotifyChunkSender>(*this, m_World));
 		return;
 	}
 
 	// Query and prepare chunk data:
-	if (!m_World->GetChunkData(a_ChunkX, a_ChunkZ, *this))
+	if (!m_World.GetChunkData(a_ChunkX, a_ChunkZ, *this))
 	{
 		return;
 	}
 	cChunkDataSerializer Data(m_BlockTypes, m_BlockMetas, m_BlockLight, m_BlockSkyLight, m_BiomeMap);
 
-	// Send:
-	if (a_Client == nullptr)
-	{
-		m_World->BroadcastChunkData(a_ChunkX, a_ChunkZ, Data);
-	}
-	else
+	for (auto client : a_Clients)
 	{
-		a_Client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
-	}
+		// Send:
+		client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
 
-	// Send block-entity packets:
-	for (sBlockCoords::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
-	{
-		if (a_Client == nullptr)
-		{
-			m_World->BroadcastBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ);
-		}
-		else
+		// Send block-entity packets:
+		for (auto Pos : m_BlockEntities)
 		{
-			m_World->SendBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ, *a_Client);
-		}
-	}  // for itr - m_Packets[]
+			m_World.SendBlockEntity(Pos.x, Pos.y, Pos.z, *client);
+		}  // for itr - m_Packets[]
+
+	}
 	m_BlockEntities.clear();
 
 	// TODO: Send entity spawn packets
@@ -325,7 +283,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Clien
 
 void cChunkSender::BlockEntity(cBlockEntity * a_Entity)
 {
-	m_BlockEntities.push_back(sBlockCoord(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ()));
+	m_BlockEntities.push_back(a_Entity->GetPos());
 }
 
 
diff --git a/src/ChunkSender.h b/src/ChunkSender.h
index 1376baeb3..b0c48b92b 100644
--- a/src/ChunkSender.h
+++ b/src/ChunkSender.h
@@ -29,6 +29,9 @@ Note that it may be called by world's BroadcastToChunk() if the client is still
 #include "ChunkDef.h"
 #include "ChunkDataCallback.h"
 
+#include <unordered_set>
+#include <unordered_map>
+
 
 
 
@@ -53,87 +56,64 @@ class cChunkSender:
 {
 	typedef cIsThread super;
 public:
-	cChunkSender(void);
+	cChunkSender(cWorld & a_World);
 	~cChunkSender();
 
 	enum eChunkPriority
 	{
 		E_CHUNK_PRIORITY_HIGH   = 0,
-		E_CHUNK_PRIORITY_MEDIUM = 1,
-		E_CHUNK_PRIORITY_LOW    = 2,
+		PRIORITY_BROADCAST,
+		E_CHUNK_PRIORITY_MEDIUM,
+		E_CHUNK_PRIORITY_LOW,
+		
 	};
 	
-	bool Start(cWorld * a_World);
+	bool Start();
 	
 	void Stop(void);
 	
-	/// Notifies that a chunk has become ready and it should be sent to all its clients
-	void ChunkReady(int a_ChunkX, int a_ChunkZ);
-	
 	/// Queues a chunk to be sent to a specific client
 	void QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, cClientHandle * a_Client);
+	void QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, std::list<cClientHandle *> a_Client);
 	
 	/// Removes the a_Client from all waiting chunk send operations
 	void RemoveClient(cClientHandle * a_Client);
 	
 protected:
+	
+	struct sChunkQueue
+	{
+		eChunkPriority m_Priority;
+		cChunkCoords m_Chunk;
+
+		bool operator <(const sChunkQueue & a_Other) const { return this->m_Priority < a_Other.m_Priority; }
+	};
 
 	/// Used for sending chunks to specific clients
 	struct sSendChunk
 	{
-		int m_ChunkX;
-		int m_ChunkZ;
-		cClientHandle * m_Client;
-		
-		sSendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client) :
-			m_ChunkX(a_ChunkX),
-			m_ChunkZ(a_ChunkZ),
-			m_Client(a_Client)
-		{
-		}
-		
-		bool operator ==(const sSendChunk & a_Other)
-		{
-			return (
-				(a_Other.m_ChunkX == m_ChunkX) &&
-				(a_Other.m_ChunkZ == m_ChunkZ) &&
-				(a_Other.m_Client == m_Client)
-			);
-		}
-	} ;
-	typedef std::list<sSendChunk> sSendChunkList;
-
-	struct sBlockCoord
-	{
-		int m_BlockX;
-		int m_BlockY;
-		int m_BlockZ;
-		
-		sBlockCoord(int a_BlockX, int a_BlockY, int a_BlockZ) :
-			m_BlockX(a_BlockX),
-			m_BlockY(a_BlockY),
-			m_BlockZ(a_BlockZ)
+		cChunkCoords m_Chunk;
+		std::unordered_set<cClientHandle *> m_Clients;
+		eChunkPriority m_Priority;
+		sSendChunk(cChunkCoords a_Chunk, eChunkPriority a_Priority) :
+			m_Chunk(a_Chunk),
+			m_Priority(a_Priority)
 		{
 		}
-	} ;
-
-	typedef std::vector<sBlockCoord> sBlockCoords;
+	};
 	
-	cWorld * m_World;
+	cWorld & m_World;
 	
 	cCriticalSection  m_CS;
-	cChunkCoordsList  m_ChunksReady;
-	sSendChunkList    m_SendChunksLowPriority;
-	sSendChunkList    m_SendChunksMediumPriority;
-	sSendChunkList    m_SendChunksHighPriority;
+	std::priority_queue<sChunkQueue> m_SendChunks;
+	std::unordered_map<cChunkCoords, sSendChunk, cChunkCoordsHash> m_ChunkInfo;
 	cEvent            m_evtQueue;  // Set when anything is added to m_ChunksReady
 	cEvent            m_evtRemoved;  // Set when removed clients are safe to be deleted
 	int               m_RemoveCount;  // Number of threads waiting for a client removal (m_evtRemoved needs to be set this many times)
-	
 	// Data about the chunk that is being sent:
 	// NOTE that m_BlockData[] is inherited from the cChunkDataCollector
 	unsigned char m_BiomeMap[cChunkDef::Width * cChunkDef::Width];
-	sBlockCoords  m_BlockEntities;  // Coords of the block entities to send
+	std::vector<Vector3i> m_BlockEntities;  // Coords of the block entities to send
 	// TODO: sEntityIDs    m_Entities;       // Entity-IDs of the entities to send
 	
 	// cIsThread override:
@@ -146,9 +126,8 @@ protected:
 	virtual void BlockEntity  (cBlockEntity * a_Entity) override;
 
 	/// Sends the specified chunk to a_Client, or to all chunk clients if a_Client == nullptr
-	void SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
+	void SendChunk(int a_ChunkX, int a_ChunkZ, std::unordered_set<cClientHandle *> a_Clients);
 } ;
 
 
 
-
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index d89f7ab77..9ed89e0a3 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -456,7 +456,7 @@ bool cClientHandle::StreamNextChunk(void)
 
 				// If the chunk already loading / loaded -> skip
 				if (
-					(std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), Coords) != m_ChunksToSend.end()) ||
+					(m_ChunksToSend.find(Coords) != m_ChunksToSend.end()) ||
 					(std::find(m_LoadedChunks.begin(), m_LoadedChunks.end(), Coords) != m_LoadedChunks.end())
 				)
 				{
@@ -494,7 +494,7 @@ bool cClientHandle::StreamNextChunk(void)
 
 			// If the chunk already loading / loaded -> skip
 			if (
-				(std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), Coords) != m_ChunksToSend.end()) ||
+				(m_ChunksToSend.find(Coords) != m_ChunksToSend.end()) ||
 				(std::find(m_LoadedChunks.begin(), m_LoadedChunks.end(), Coords) != m_LoadedChunks.end())
 			)
 			{
@@ -541,7 +541,7 @@ void cClientHandle::UnloadOutOfRangeChunks(void)
 			}
 		}
 
-		for (cChunkCoordsList::iterator itr = m_ChunksToSend.begin(); itr != m_ChunksToSend.end();)
+		for (auto itr = m_ChunksToSend.begin(); itr != m_ChunksToSend.end();)
 		{
 			int DiffX = Diff((*itr).m_ChunkX, ChunkPosX);
 			int DiffZ = Diff((*itr).m_ChunkZ, ChunkPosZ);
@@ -583,7 +583,7 @@ void cClientHandle::StreamChunk(int a_ChunkX, int a_ChunkZ, cChunkSender::eChunk
 		{
 			cCSLock Lock(m_CSChunkLists);
 			m_LoadedChunks.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
-			m_ChunksToSend.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
+			m_ChunksToSend.emplace(a_ChunkX, a_ChunkZ);
 		}
 		World->SendChunkTo(a_ChunkX, a_ChunkZ, a_Priority, this);
 	}
@@ -2179,15 +2179,12 @@ void cClientHandle::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializ
 	bool Found = false;
 	{
 		cCSLock Lock(m_CSChunkLists);
-		for (cChunkCoordsList::iterator itr = m_ChunksToSend.begin(); itr != m_ChunksToSend.end(); ++itr)
+		auto itr = m_ChunksToSend.find(cChunkCoords{a_ChunkX, a_ChunkZ});
+		if (itr != m_ChunksToSend.end())
 		{
-			if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))
-			{
-				m_ChunksToSend.erase(itr);
-				Found = true;
-				break;
-			}
-		}  // for itr - m_ChunksToSend[]
+			m_ChunksToSend.erase(itr);
+			Found = true;
+		}
 	}
 	if (!Found)
 	{
@@ -2950,7 +2947,7 @@ bool cClientHandle::WantsSendChunk(int a_ChunkX, int a_ChunkZ)
 	}
 	
 	cCSLock Lock(m_CSChunkLists);
-	return (std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), cChunkCoords(a_ChunkX, a_ChunkZ)) != m_ChunksToSend.end());
+	return m_ChunksToSend.find(cChunkCoords(a_ChunkX, a_ChunkZ)) != m_ChunksToSend.end();
 }
 
 
@@ -2966,9 +2963,9 @@ void cClientHandle::AddWantedChunk(int a_ChunkX, int a_ChunkZ)
 	
 	LOGD("Adding chunk [%d, %d] to wanted chunks for client %p", a_ChunkX, a_ChunkZ, this);
 	cCSLock Lock(m_CSChunkLists);
-	if (std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), cChunkCoords(a_ChunkX, a_ChunkZ)) == m_ChunksToSend.end())
+	if (m_ChunksToSend.find(cChunkCoords(a_ChunkX, a_ChunkZ)) == m_ChunksToSend.end())
 	{
-		m_ChunksToSend.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
+		m_ChunksToSend.emplace(a_ChunkX, a_ChunkZ);
 	}
 }
 
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index 13b5f87e4..27acc4d37 100644
--- a/src/ClientHandle.h
+++ b/src/ClientHandle.h
@@ -377,10 +377,10 @@ private:
 	AString m_Password;
 	Json::Value m_Properties;
 
-	cCriticalSection m_CSChunkLists;
-	cChunkCoordsList m_LoadedChunks;  // Chunks that the player belongs to
-	cChunkCoordsList m_ChunksToSend;  // Chunks that need to be sent to the player (queued because they weren't generated yet or there's not enough time to send them)
-	cChunkCoordsList m_SentChunks;    // Chunks that are currently sent to the client
+	cCriticalSection                                   m_CSChunkLists;
+	cChunkCoordsList                                   m_LoadedChunks;  // Chunks that the player belongs to
+	std::unordered_set<cChunkCoords, cChunkCoordsHash> m_ChunksToSend;  // Chunks that need to be sent to the player (queued because they weren't generated yet or there's not enough time to send them)
+	cChunkCoordsList                                   m_SentChunks;    // Chunks that are currently sent to the client
 
 	cProtocol * m_Protocol;
 
diff --git a/src/World.cpp b/src/World.cpp
index f7d2165c7..3ff8e0723 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -186,6 +186,7 @@ cWorld::cWorld(const AString & a_WorldName, eDimension a_Dimension, const AStrin
 	m_Scoreboard(this),
 	m_MapManager(this),
 	m_GeneratorCallbacks(*this),
+	m_ChunkSender(*this),
 	m_TickThread(*this)
 {
 	LOGD("cWorld::cWorld(\"%s\")", a_WorldName.c_str());
@@ -509,7 +510,7 @@ void cWorld::Start(void)
 	m_Lighting.Start(this);
 	m_Storage.Start(this, m_StorageSchema, m_StorageCompressionFactor);
 	m_Generator.Start(m_GeneratorCallbacks, m_GeneratorCallbacks, IniFile);
-	m_ChunkSender.Start(this);
+	m_ChunkSender.Start();
 	m_TickThread.Start();
 
 	// Init of the spawn monster time (as they are supposed to have different spawn rate)
@@ -1326,6 +1327,30 @@ bool cWorld::DoWithChunk(int a_ChunkX, int a_ChunkZ, cChunkCallback & a_Callback
 
 
 
+bool cWorld::DoWithChunk(int a_ChunkX, int a_ChunkZ, std::function<bool(cChunk &)>  a_Callback)
+{
+	struct cCallBackWrapper : cChunkCallback
+	{
+		cCallBackWrapper(std::function<bool(cChunk &)> a_InnerCallback) :
+			m_Callback(a_InnerCallback)
+		{
+		}
+		
+		virtual bool Item(cChunk * a_Chunk)
+		{
+			return m_Callback(*a_Chunk);
+		}
+
+	private:
+		std::function<bool(cChunk &)> m_Callback;
+	} callback(a_Callback);
+	return m_ChunkMap->DoWithChunk(a_ChunkX, a_ChunkZ, callback);
+}
+
+
+
+
+
 bool cWorld::DoWithChunkAt(Vector3i a_BlockPos, std::function<bool(cChunk &)>  a_Callback)
 {
 	return m_ChunkMap->DoWithChunkAt(a_BlockPos, a_Callback);
@@ -2001,15 +2026,6 @@ void cWorld::BroadcastChat(const cCompositeChat & a_Message, const cClientHandle
 
 
 
-void cWorld::BroadcastChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude)
-{
-	m_ChunkMap->BroadcastChunkData(a_ChunkX, a_ChunkZ, a_Serializer, a_Exclude);
-}
-
-
-
-
-
 void cWorld::BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude)
 {
 	m_ChunkMap->BroadcastCollectEntity(a_Entity, a_Player, a_Exclude);
@@ -2461,10 +2477,23 @@ void cWorld::SetChunkData(cSetChunkData & a_SetChunkData)
 	// If a client is requesting this chunk, send it to them:
 	int ChunkX = a_SetChunkData.GetChunkX();
 	int ChunkZ = a_SetChunkData.GetChunkZ();
-	if (m_ChunkMap->HasChunkAnyClients(ChunkX, ChunkZ))
-	{
-		m_ChunkSender.ChunkReady(ChunkX, ChunkZ);
-	}
+	cChunkSender & ChunkSender = m_ChunkSender;
+	DoWithChunk(
+		ChunkX, ChunkZ,
+		[&ChunkSender] (cChunk & a_Chunk) -> bool
+		{
+			if (a_Chunk.HasAnyClients())
+			{
+				ChunkSender.QueueSendChunkTo(
+					a_Chunk.GetPosX(),
+					a_Chunk.GetPosZ(),
+					cChunkSender::PRIORITY_BROADCAST,
+					a_Chunk.GetAllClients()
+				);
+			}
+			return true;
+		}
+	);
 
 	// Save the chunk right after generating, so that we don't have to generate it again on next run
 	if (a_SetChunkData.ShouldMarkDirty())
diff --git a/src/World.h b/src/World.h
index 064b50165..078a25562 100644
--- a/src/World.h
+++ b/src/World.h
@@ -231,7 +231,6 @@ public:
 	void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = nullptr);
 	// tolua_end
 
-	void BroadcastChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastCollectEntity              (const cEntity & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastDestroyEntity              (const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);
 	void BroadcastEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = nullptr);
@@ -609,6 +608,7 @@ public:
 	
 	/** Calls the callback for the chunk specified, with ChunkMapCS locked; returns false if the chunk doesn't exist, otherwise returns the same value as the callback */
 	bool DoWithChunk(int a_ChunkX, int a_ChunkZ, cChunkCallback & a_Callback);
+	bool DoWithChunk(int a_ChunkX, int a_ChunkZ, std::function<bool(cChunk &)> a_Callback);
 
 	/** Calls the callback for the chunk at the block position specified, with ChunkMapCS locked; returns false if the chunk doesn't exist, otherwise returns the same value as the callback **/
 	bool DoWithChunkAt(Vector3i a_BlockPos, std::function<bool(cChunk &)> a_Callback);