Revert "Chunk queue collapsing"

MCServer/Plugins/MagicCarpet

@@ -1 +1 @@
-Subproject commit 493f2dfa6d39f134e37c4c614cf8d6ffd10c825f
+Subproject commit 94da343b62f0498a5843247f36d6ee00cbeb8f21

src/BlockEntities/BlockEntity.h

@@ -85,7 +85,6 @@ 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; }

src/Chunk.cpp

@@ -2852,6 +2852,22 @@ 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)

src/Chunk.h

@@ -319,6 +319,7 @@ 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);

src/ChunkMap.cpp

@@ -409,6 +409,22 @@ 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);

src/ChunkMap.h

@@ -73,6 +73,7 @@ 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);

src/ChunkSender.cpp

@@ -13,7 +13,6 @@
 #include "BlockEntities/BlockEntity.h"
 #include "Protocol/ChunkDataSerializer.h"
 #include "ClientHandle.h"
-#include "Chunk.h"
 
 
 
@@ -29,29 +28,25 @@ class cNotifyChunkSender :
 {
 	virtual void Call(int a_ChunkX, int a_ChunkZ) override
 	{
-		cChunkSender & ChunkSender = m_ChunkSender;
+		m_ChunkSender->ChunkReady(a_ChunkX, a_ChunkZ);
-		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;
+	cChunkSender * m_ChunkSender;
-
-	cWorld & m_World;
 public:
-	cNotifyChunkSender(cChunkSender & a_ChunkSender, cWorld & a_World) : m_ChunkSender(a_ChunkSender), m_World(a_World) {}
+	cNotifyChunkSender(cChunkSender * a_ChunkSender) : m_ChunkSender(a_ChunkSender) {}
-
-
 };
 
-cChunkSender::cChunkSender(cWorld & a_World) :
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cChunkSender:
+
+cChunkSender::cChunkSender(void) :
 	super("ChunkSender"),
-	m_World(a_World),
+	m_World(nullptr),
 	m_RemoveCount(0)
 {
 }
@@ -69,9 +64,10 @@ cChunkSender::~cChunkSender()
 
 
 
-bool cChunkSender::Start()
+bool cChunkSender::Start(cWorld * a_World)
 {
 	m_ShouldTerminate = false;
+	m_World = a_World;
 	return super::Start();
 }
 
@@ -90,30 +86,12 @@ void cChunkSender::Stop(void)
 
 
 
-void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, cClientHandle * a_Client)
+void cChunkSender::ChunkReady(int a_ChunkX, int a_ChunkZ)
 {
-	ASSERT(a_Client != nullptr);
+	// 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
 	{
-		cChunkCoords Chunk{a_ChunkX, a_ChunkZ};
 		cCSLock Lock(m_CS);
-		auto iter = m_ChunkInfo.find(Chunk);
+		m_ChunksReady.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
-		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();
 }
@@ -122,29 +100,40 @@ void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a
 
 
 
-
+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);
 	{
-		cChunkCoords Chunk{a_ChunkX, a_ChunkZ};
+		sSendChunk Chunk(a_ChunkX, a_ChunkZ, a_Client);
+
 		cCSLock Lock(m_CS);
-		auto iter = m_ChunkInfo.find(Chunk);
+		if (
-		if (iter != m_ChunkInfo.end())
+			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 & info = iter->second;
+			// Already queued, bail out
-			if (info.m_Priority > a_Priority)
+			return;
-			{
-				m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
-				info.m_Priority = a_Priority;
-			}
-			info.m_Clients.insert(a_Clients.begin(), a_Clients.end());
 		}
-		else
+
+		switch (a_Priority)
 		{
-			m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
+			case E_CHUNK_PRIORITY_LOW:
-			auto info = sSendChunk{Chunk, a_Priority};
+			{
-			info.m_Clients.insert(a_Clients.begin(), a_Clients.end());
+				m_SendChunksLowPriority.push_back(Chunk);
-			m_ChunkInfo.emplace(Chunk, info);
+				break;
+			}
+			case E_CHUNK_PRIORITY_MEDIUM:
+			{
+				m_SendChunksMediumPriority.push_back(Chunk);
+				break;
+			}
+			case E_CHUNK_PRIORITY_HIGH:
+			{
+				m_SendChunksHighPriority.push_back(Chunk);
+				break;
+			}
 		}
 	}
 	m_evtQueue.Set();
@@ -158,12 +147,33 @@ void cChunkSender::RemoveClient(cClientHandle * a_Client)
 {
 	{
 		cCSLock Lock(m_CS);
-		for (auto && pair : m_ChunkInfo)
+		for (sSendChunkList::iterator itr = m_SendChunksLowPriority.begin(); itr != m_SendChunksLowPriority.end();)
 		{
-			auto && clients = pair.second.m_Clients;
+			if (itr->m_Client == a_Client)
-			clients.erase(a_Client);  // nop for sets that do not contain a_Client
+			{
-		}
+				itr = m_SendChunksLowPriority.erase(itr);
-
+				continue;
+			}
+			++itr;
+		}  // for itr - m_SendChunksLowPriority[]
+		for (sSendChunkList::iterator itr = m_SendChunksMediumPriority.begin(); itr != m_SendChunksMediumPriority.end();)
+		{
+			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[]
 		m_RemoveCount++;
 	}
 	m_evtQueue.Set();
@@ -179,7 +189,7 @@ void cChunkSender::Execute(void)
 	while (!m_ShouldTerminate)
 	{
 		cCSLock Lock(m_CS);
-		do
+		while (m_ChunksReady.empty() && m_SendChunksLowPriority.empty() && m_SendChunksMediumPriority.empty() && m_SendChunksHighPriority.empty())
 		{
 			int RemoveCount = m_RemoveCount;
 			m_RemoveCount = 0;
@@ -193,24 +203,52 @@ void cChunkSender::Execute(void)
 			{
 				return;
 			}
-		} while (m_SendChunks.empty());
+		}  // while (empty)
 
-		// Take one from the queue:
+		if (!m_SendChunksHighPriority.empty())
-		auto Chunk = m_SendChunks.top().m_Chunk;
-		m_SendChunks.pop();
-		auto itr = m_ChunkInfo.find(Chunk);
-		if (itr == m_ChunkInfo.end())
 		{
-			continue;
+			// Take one from the queue:
+			sSendChunk Chunk(m_SendChunksHighPriority.front());
+			m_SendChunksHighPriority.pop_front();
+			Lock.Unlock();
+
+			SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, Chunk.m_Client);
 		}
-		
+		else if (!m_ChunksReady.empty())
-		std::unordered_set<cClientHandle *> clients;
+		{
-		std::swap(itr->second.m_Clients, clients);
+			// Take one from the queue:
-		m_ChunkInfo.erase(itr);
+			cChunkCoords Coords(m_ChunksReady.front());
+			m_ChunksReady.pop_front();
+			Lock.Unlock();
+			
+			SendChunk(Coords.m_ChunkX, Coords.m_ChunkZ, nullptr);
+		}
+		else if (!m_SendChunksMediumPriority.empty())
+		{
+			// Take one from the queue:
+			sSendChunk Chunk(m_SendChunksMediumPriority.front());
+			m_SendChunksMediumPriority.pop_front();
+			Lock.Unlock();
 
+			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++)
-		SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, clients);
+		{
+			m_evtRemoved.Set();  // Notify that the removed clients are safe to be deleted
+		}
 	}  // while (!mShouldTerminate)
 }
 
@@ -218,60 +256,64 @@ void cChunkSender::Execute(void)
 
 
 
-void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, std::unordered_set<cClientHandle *> a_Clients)
+void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client)
 {
+	ASSERT(m_World != nullptr);
 	
 	// Ask the client if it still wants the chunk:
-	for (auto itr = a_Clients.begin(); itr != a_Clients.end();)
+	if ((a_Client != nullptr) && !a_Client->WantsSendChunk(a_ChunkX, a_ChunkZ))
 	{
-		if (!(*itr)->WantsSendChunk(a_ChunkX, a_ChunkZ))
+		return;
-		{
-			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));
+		m_World->QueueLightChunk(a_ChunkX, a_ChunkZ, cpp14::make_unique<cNotifyChunkSender>(this));
 		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);
 
-	for (auto client : a_Clients)
+	// Send:
+	if (a_Client == nullptr)
 	{
-		// Send:
+		m_World->BroadcastChunkData(a_ChunkX, a_ChunkZ, Data);
-		client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
-
-		// Send block-entity packets:
-		for (auto Pos : m_BlockEntities)
-		{
-			m_World.SendBlockEntity(Pos.x, Pos.y, Pos.z, *client);
-		}  // for itr - m_Packets[]
-
 	}
+	else
+	{
+		a_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
+		{
+			m_World->SendBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ, *a_Client);
+		}
+	}  // for itr - m_Packets[]
 	m_BlockEntities.clear();
 
 	// TODO: Send entity spawn packets
@@ -283,7 +325,7 @@ void cChunkSender::SendChunk(int a_ChunkX, int a_ChunkZ, std::unordered_set<cCli
 
 void cChunkSender::BlockEntity(cBlockEntity * a_Entity)
 {
-	m_BlockEntities.push_back(a_Entity->GetPos());
+	m_BlockEntities.push_back(sBlockCoord(a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ()));
 }
 
 

src/ChunkSender.h

@@ -29,9 +29,6 @@ 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>
-
 
 
 
@@ -56,64 +53,87 @@ class cChunkSender:
 {
 	typedef cIsThread super;
 public:
-	cChunkSender(cWorld & a_World);
+	cChunkSender(void);
 	~cChunkSender();
 
 	enum eChunkPriority
 	{
 		E_CHUNK_PRIORITY_HIGH   = 0,
-		PRIORITY_BROADCAST,
+		E_CHUNK_PRIORITY_MEDIUM = 1,
-		E_CHUNK_PRIORITY_MEDIUM,
+		E_CHUNK_PRIORITY_LOW    = 2,
-		E_CHUNK_PRIORITY_LOW,
-		
 	};
 	
-	bool Start();
+	bool Start(cWorld * a_World);
 	
 	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
 	{
-		cChunkCoords m_Chunk;
+		int m_ChunkX;
-		std::unordered_set<cClientHandle *> m_Clients;
+		int m_ChunkZ;
-		eChunkPriority m_Priority;
+		cClientHandle * m_Client;
-		sSendChunk(cChunkCoords a_Chunk, eChunkPriority a_Priority) :
+		
-			m_Chunk(a_Chunk),
+		sSendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client) :
-			m_Priority(a_Priority)
+			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)
+		{
+		}
+	} ;
+
+	typedef std::vector<sBlockCoord> sBlockCoords;
 	
-	cWorld & m_World;
+	cWorld * m_World;
 	
 	cCriticalSection  m_CS;
-	std::priority_queue<sChunkQueue> m_SendChunks;
+	cChunkCoordsList  m_ChunksReady;
-	std::unordered_map<cChunkCoords, sSendChunk, cChunkCoordsHash> m_ChunkInfo;
+	sSendChunkList    m_SendChunksLowPriority;
+	sSendChunkList    m_SendChunksMediumPriority;
+	sSendChunkList    m_SendChunksHighPriority;
 	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];
-	std::vector<Vector3i> m_BlockEntities;  // Coords of the block entities to send
+	sBlockCoords  m_BlockEntities;  // Coords of the block entities to send
 	// TODO: sEntityIDs    m_Entities;       // Entity-IDs of the entities to send
 	
 	// cIsThread override:
@@ -126,8 +146,9 @@ 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, std::unordered_set<cClientHandle *> a_Clients);
+	void SendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client);
 } ;
 
 
 
+

src/ClientHandle.cpp

@@ -456,7 +456,7 @@ bool cClientHandle::StreamNextChunk(void)
 
 				// If the chunk already loading / loaded -> skip
 				if (
-					(m_ChunksToSend.find(Coords) != m_ChunksToSend.end()) ||
+					(std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), 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 (
-				(m_ChunksToSend.find(Coords) != m_ChunksToSend.end()) ||
+				(std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), 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 (auto itr = m_ChunksToSend.begin(); itr != m_ChunksToSend.end();)
+		for (cChunkCoordsList::iterator 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.emplace(a_ChunkX, a_ChunkZ);
+			m_ChunksToSend.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
 		}
 		World->SendChunkTo(a_ChunkX, a_ChunkZ, a_Priority, this);
 	}
@@ -2179,12 +2179,15 @@ void cClientHandle::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializ
 	bool Found = false;
 	{
 		cCSLock Lock(m_CSChunkLists);
-		auto itr = m_ChunksToSend.find(cChunkCoords{a_ChunkX, a_ChunkZ});
+		for (cChunkCoordsList::iterator itr = m_ChunksToSend.begin(); itr != m_ChunksToSend.end(); ++itr)
-		if (itr != m_ChunksToSend.end())
 		{
-			m_ChunksToSend.erase(itr);
+			if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))
-			Found = true;
+			{
-		}
+				m_ChunksToSend.erase(itr);
+				Found = true;
+				break;
+			}
+		}  // for itr - m_ChunksToSend[]
 	}
 	if (!Found)
 	{
@@ -2947,7 +2950,7 @@ bool cClientHandle::WantsSendChunk(int a_ChunkX, int a_ChunkZ)
 	}
 	
 	cCSLock Lock(m_CSChunkLists);
-	return m_ChunksToSend.find(cChunkCoords(a_ChunkX, a_ChunkZ)) != m_ChunksToSend.end();
+	return (std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), cChunkCoords(a_ChunkX, a_ChunkZ)) != m_ChunksToSend.end());
 }
 
 
@@ -2963,9 +2966,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 (m_ChunksToSend.find(cChunkCoords(a_ChunkX, a_ChunkZ)) == m_ChunksToSend.end())
+	if (std::find(m_ChunksToSend.begin(), m_ChunksToSend.end(), cChunkCoords(a_ChunkX, a_ChunkZ)) == m_ChunksToSend.end())
 	{
-		m_ChunksToSend.emplace(a_ChunkX, a_ChunkZ);
+		m_ChunksToSend.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
 	}
 }
 

src/ClientHandle.h

@@ -377,10 +377,10 @@ private:
 	AString m_Password;
 	Json::Value m_Properties;
 
-	cCriticalSection                                   m_CSChunkLists;
+	cCriticalSection m_CSChunkLists;
-	cChunkCoordsList                                   m_LoadedChunks;  // Chunks that the player belongs to
+	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_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
+	cChunkCoordsList m_SentChunks;    // Chunks that are currently sent to the client
 
 	cProtocol * m_Protocol;
 

src/World.cpp

@@ -186,7 +186,6 @@ 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());
@@ -510,7 +509,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();
+	m_ChunkSender.Start(this);
 	m_TickThread.Start();
 
 	// Init of the spawn monster time (as they are supposed to have different spawn rate)
@@ -1327,30 +1326,6 @@ 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);
@@ -2026,6 +2001,15 @@ 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);
@@ -2477,23 +2461,10 @@ 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();
-	cChunkSender & ChunkSender = m_ChunkSender;
+	if (m_ChunkMap->HasChunkAnyClients(ChunkX, ChunkZ))
-	DoWithChunk(
+	{
-		ChunkX, ChunkZ,
+		m_ChunkSender.ChunkReady(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())

src/World.h

@@ -231,6 +231,7 @@ 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);
@@ -608,7 +609,6 @@ 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);