summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/BlockEntities/BlockEntity.h1
-rw-r--r--src/Chunk.cpp16
-rw-r--r--src/Chunk.h1
-rw-r--r--src/ChunkMap.cpp16
-rw-r--r--src/ChunkMap.h1
-rw-r--r--src/ChunkSender.cpp242
-rw-r--r--src/ChunkSender.h81
-rw-r--r--src/ClientHandle.cpp27
-rw-r--r--src/ClientHandle.h8
-rw-r--r--src/World.cpp57
-rw-r--r--src/World.h2
11 files changed, 261 insertions, 191 deletions
diff --git a/src/BlockEntities/BlockEntity.h b/src/BlockEntities/BlockEntity.h
index 71367efb6..85f75a523 100644
--- a/src/BlockEntities/BlockEntity.h
+++ b/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; }
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index 02bc2ba8c..7af669163 100644
--- a/src/Chunk.cpp
+++ b/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)
diff --git a/src/Chunk.h b/src/Chunk.h
index fd9ea0b0c..f57769107 100644
--- a/src/Chunk.h
+++ b/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);
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index 4db73971c..2f38e4cd6 100644
--- a/src/ChunkMap.cpp
+++ b/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);
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 916a3433d..964188bbe 100644
--- a/src/ChunkMap.h
+++ b/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);
diff --git a/src/ChunkSender.cpp b/src/ChunkSender.cpp
index 877aacfc5..2f18ea75c 100644
--- a/src/ChunkSender.cpp
+++ b/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_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;
- }
- );
+ m_ChunkSender->ChunkReady(a_ChunkX, a_ChunkZ);
}
- cChunkSender & m_ChunkSender;
-
- cWorld & m_World;
+ cChunkSender * m_ChunkSender;
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);
- 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_ChunksReady.push_back(cChunkCoords(a_ChunkX, a_ChunkZ));
}
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, std::list<cClientHandle *> a_Clients)
+void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a_Priority, cClientHandle * a_Client)
{
+ 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 (iter != m_ChunkInfo.end())
+ 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 & 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_Clients.begin(), a_Clients.end());
+ // Already queued, bail out
+ return;
}
- else
+
+ switch (a_Priority)
{
- 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);
+ 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:
+ {
+ 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;
- clients.erase(a_Client); // nop for sets that do not contain a_Client
- }
-
+ 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();)
+ {
+ 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)
+
+ if (!m_SendChunksHighPriority.empty())
+ {
+ // Take one from the queue:
+ sSendChunk Chunk(m_SendChunksHighPriority.front());
+ m_SendChunksHighPriority.pop_front();
+ Lock.Unlock();
- // 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())
+ SendChunk(Chunk.m_ChunkX, Chunk.m_ChunkZ, Chunk.m_Client);
+ }
+ else if (!m_ChunksReady.empty())
{
- continue;
+ // Take one from the queue:
+ cChunkCoords Coords(m_ChunksReady.front());
+ m_ChunksReady.pop_front();
+ Lock.Unlock();
+
+ SendChunk(Coords.m_ChunkX, Coords.m_ChunkZ, nullptr);
}
-
- std::unordered_set<cClientHandle *> clients;
- std::swap(itr->second.m_Clients, clients);
- m_ChunkInfo.erase(itr);
+ else if (!m_SendChunksMediumPriority.empty())
+ {
+ // Take one from the queue:
+ sSendChunk Chunk(m_SendChunksMediumPriority.front());
+ m_SendChunksMediumPriority.pop_front();
+ Lock.Unlock();
- 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, clients);
+ 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
+ }
} // 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))
- {
- itr = a_Clients.erase(itr);
- }
- else
- {
- itr++;
- }
+ return;
}
// 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)
+ {
+ m_World->BroadcastChunkData(a_ChunkX, a_ChunkZ, Data);
+ }
+ else
{
- // Send:
- client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
+ a_Client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
+ }
- // Send block-entity packets:
- for (auto Pos : m_BlockEntities)
+ // Send block-entity packets:
+ for (sBlockCoords::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr)
+ {
+ if (a_Client == nullptr)
{
- m_World.SendBlockEntity(Pos.x, Pos.y, Pos.z, *client);
- } // for itr - m_Packets[]
-
- }
+ 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()));
}
diff --git a/src/ChunkSender.h b/src/ChunkSender.h
index b0c48b92b..1376baeb3 100644
--- a/src/ChunkSender.h
+++ b/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,
- E_CHUNK_PRIORITY_LOW,
-
+ E_CHUNK_PRIORITY_MEDIUM = 1,
+ E_CHUNK_PRIORITY_LOW = 2,
};
- 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;
- std::unordered_set<cClientHandle *> m_Clients;
- eChunkPriority m_Priority;
- sSendChunk(cChunkCoords a_Chunk, eChunkPriority a_Priority) :
- m_Chunk(a_Chunk),
- m_Priority(a_Priority)
+ 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)
+ {
+ }
+ } ;
+
+ typedef std::vector<sBlockCoord> sBlockCoords;
- cWorld & m_World;
+ cWorld * m_World;
cCriticalSection m_CS;
- std::priority_queue<sChunkQueue> m_SendChunks;
- std::unordered_map<cChunkCoords, sSendChunk, cChunkCoordsHash> m_ChunkInfo;
+ cChunkCoordsList m_ChunksReady;
+ 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);
} ;
+
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 9ed89e0a3..d89f7ab77 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 (
- (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});
- if (itr != m_ChunksToSend.end())
+ for (cChunkCoordsList::iterator itr = m_ChunksToSend.begin(); itr != m_ChunksToSend.end(); ++itr)
{
- m_ChunksToSend.erase(itr);
- Found = true;
- }
+ if ((itr->m_ChunkX == a_ChunkX) && (itr->m_ChunkZ == a_ChunkZ))
+ {
+ 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));
}
}
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index 27acc4d37..13b5f87e4 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
- 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
+ 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
cProtocol * m_Protocol;
diff --git a/src/World.cpp b/src/World.cpp
index 3ff8e0723..f7d2165c7 100644
--- a/src/World.cpp
+++ b/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;
- 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;
- }
- );
+ if (m_ChunkMap->HasChunkAnyClients(ChunkX, ChunkZ))
+ {
+ m_ChunkSender.ChunkReady(ChunkX, ChunkZ);
+ }
// 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 078a25562..064b50165 100644
--- a/src/World.h
+++ b/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);