1
0

Reinstate "Chunk queue collapsing"

This reinstates commit f36acb6835
     and reverts commit adfbc42c02.
This commit is contained in:
Tiger Wang 2015-06-10 15:16:05 +01:00
parent d436a71cbc
commit dd4b415051
12 changed files with 194 additions and 264 deletions

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

View File

@ -85,6 +85,7 @@ public:
// tolua_begin // tolua_begin
// Position, in absolute block coordinates: // 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 GetPosX(void) const { return m_PosX; }
int GetPosY(void) const { return m_PosY; } int GetPosY(void) const { return m_PosY; }
int GetPosZ(void) const { return m_PosZ; } int GetPosZ(void) const { return m_PosZ; }

View File

@ -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) 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) for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)

View File

@ -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 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 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 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 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 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); void BroadcastEntityEffect (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = nullptr);

View File

@ -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) void cChunkMap::BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude)
{ {
cCSLock Lock(m_CSLayers); cCSLock Lock(m_CSLayers);

View File

@ -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 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 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 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 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 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); void BroadcastDestroyEntity(const cEntity & a_Entity, const cClientHandle * a_Exclude = nullptr);

View File

@ -13,6 +13,7 @@
#include "BlockEntities/BlockEntity.h" #include "BlockEntities/BlockEntity.h"
#include "Protocol/ChunkDataSerializer.h" #include "Protocol/ChunkDataSerializer.h"
#include "ClientHandle.h" #include "ClientHandle.h"
#include "Chunk.h"
@ -28,25 +29,29 @@ class cNotifyChunkSender :
{ {
virtual void Call(int a_ChunkX, int a_ChunkZ) override 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; cChunkSender & m_ChunkSender;
cWorld & m_World;
public: public:
cNotifyChunkSender(cChunkSender * a_ChunkSender) : m_ChunkSender(a_ChunkSender) {} cNotifyChunkSender(cChunkSender & a_ChunkSender, cWorld & a_World) : m_ChunkSender(a_ChunkSender), m_World(a_World) {}
}; };
cChunkSender::cChunkSender(cWorld & a_World) :
////////////////////////////////////////////////////////////////////////////////
// cChunkSender:
cChunkSender::cChunkSender(void) :
super("ChunkSender"), super("ChunkSender"),
m_World(nullptr), m_World(a_World),
m_RemoveCount(0) m_RemoveCount(0)
{ {
} }
@ -64,10 +69,9 @@ cChunkSender::~cChunkSender()
bool cChunkSender::Start(cWorld * a_World) bool cChunkSender::Start()
{ {
m_ShouldTerminate = false; m_ShouldTerminate = false;
m_World = a_World;
return super::Start(); 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); 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(); 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); cCSLock Lock(m_CS);
if ( auto iter = m_ChunkInfo.find(Chunk);
std::find(m_SendChunksLowPriority.begin(), m_SendChunksLowPriority.end(), Chunk) != m_SendChunksLowPriority.end() || if (iter != m_ChunkInfo.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()
)
{ {
// Already queued, bail out auto & info = iter->second;
return; 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());
} }
else
switch (a_Priority)
{ {
case E_CHUNK_PRIORITY_LOW: m_SendChunks.push(sChunkQueue{a_Priority, Chunk});
{ auto info = sSendChunk{Chunk, a_Priority};
m_SendChunksLowPriority.push_back(Chunk); info.m_Clients.insert(a_Clients.begin(), a_Clients.end());
break; m_ChunkInfo.emplace(Chunk, info);
}
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(); m_evtQueue.Set();
@ -147,33 +158,12 @@ void cChunkSender::RemoveClient(cClientHandle * a_Client)
{ {
{ {
cCSLock Lock(m_CS); cCSLock Lock(m_CS);
for (sSendChunkList::iterator itr = m_SendChunksLowPriority.begin(); itr != m_SendChunksLowPriority.end();) for (auto && pair : m_ChunkInfo)
{ {
if (itr->m_Client == a_Client) auto && clients = pair.second.m_Clients;
{ 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_RemoveCount++;
} }
m_evtQueue.Set(); m_evtQueue.Set();
@ -189,7 +179,7 @@ void cChunkSender::Execute(void)
while (!m_ShouldTerminate) while (!m_ShouldTerminate)
{ {
cCSLock Lock(m_CS); cCSLock Lock(m_CS);
while (m_ChunksReady.empty() && m_SendChunksLowPriority.empty() && m_SendChunksMediumPriority.empty() && m_SendChunksHighPriority.empty()) do
{ {
int RemoveCount = m_RemoveCount; int RemoveCount = m_RemoveCount;
m_RemoveCount = 0; m_RemoveCount = 0;
@ -203,52 +193,24 @@ void cChunkSender::Execute(void)
{ {
return; return;
} }
} // while (empty) } while (m_SendChunks.empty());
if (!m_SendChunksHighPriority.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: continue;
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())
{
// 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);
else if (!m_SendChunksMediumPriority.empty()) m_ChunkInfo.erase(itr);
{
// 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(); 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) } // 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: // 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 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; return;
} }
// If the chunk is not valid, do nothing - whoever needs it has queued it for loading / generating // 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; return;
} }
// If the chunk is not lighted, queue it for relighting and get notified when it's ready: // 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; return;
} }
// Query and prepare chunk data: // Query and prepare chunk data:
if (!m_World->GetChunkData(a_ChunkX, a_ChunkZ, *this)) if (!m_World.GetChunkData(a_ChunkX, a_ChunkZ, *this))
{ {
return; return;
} }
cChunkDataSerializer Data(m_BlockTypes, m_BlockMetas, m_BlockLight, m_BlockSkyLight, m_BiomeMap); cChunkDataSerializer Data(m_BlockTypes, m_BlockMetas, m_BlockLight, m_BlockSkyLight, m_BiomeMap);
// Send: for (auto client : a_Clients)
if (a_Client == nullptr)
{ {
m_World->BroadcastChunkData(a_ChunkX, a_ChunkZ, Data); // Send:
} client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
else
{
a_Client->SendChunkData(a_ChunkX, a_ChunkZ, Data);
}
// Send block-entity packets: // Send block-entity packets:
for (sBlockCoords::iterator itr = m_BlockEntities.begin(); itr != m_BlockEntities.end(); ++itr) for (auto Pos : m_BlockEntities)
{
if (a_Client == nullptr)
{ {
m_World->BroadcastBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ); m_World.SendBlockEntity(Pos.x, Pos.y, Pos.z, *client);
} } // for itr - m_Packets[]
else
{ }
m_World->SendBlockEntity(itr->m_BlockX, itr->m_BlockY, itr->m_BlockZ, *a_Client);
}
} // for itr - m_Packets[]
m_BlockEntities.clear(); m_BlockEntities.clear();
// TODO: Send entity spawn packets // 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) 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());
} }

View File

@ -29,6 +29,9 @@ Note that it may be called by world's BroadcastToChunk() if the client is still
#include "ChunkDef.h" #include "ChunkDef.h"
#include "ChunkDataCallback.h" #include "ChunkDataCallback.h"
#include <unordered_set>
#include <unordered_map>
@ -53,87 +56,64 @@ class cChunkSender:
{ {
typedef cIsThread super; typedef cIsThread super;
public: public:
cChunkSender(void); cChunkSender(cWorld & a_World);
~cChunkSender(); ~cChunkSender();
enum eChunkPriority enum eChunkPriority
{ {
E_CHUNK_PRIORITY_HIGH = 0, E_CHUNK_PRIORITY_HIGH = 0,
E_CHUNK_PRIORITY_MEDIUM = 1, PRIORITY_BROADCAST,
E_CHUNK_PRIORITY_LOW = 2, E_CHUNK_PRIORITY_MEDIUM,
E_CHUNK_PRIORITY_LOW,
}; };
bool Start(cWorld * a_World); bool Start();
void Stop(void); 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 /// 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, 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 /// Removes the a_Client from all waiting chunk send operations
void RemoveClient(cClientHandle * a_Client); void RemoveClient(cClientHandle * a_Client);
protected: 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 /// Used for sending chunks to specific clients
struct sSendChunk struct sSendChunk
{ {
int m_ChunkX; cChunkCoords m_Chunk;
int m_ChunkZ; std::unordered_set<cClientHandle *> m_Clients;
cClientHandle * m_Client; eChunkPriority m_Priority;
sSendChunk(cChunkCoords a_Chunk, eChunkPriority a_Priority) :
sSendChunk(int a_ChunkX, int a_ChunkZ, cClientHandle * a_Client) : m_Chunk(a_Chunk),
m_ChunkX(a_ChunkX), m_Priority(a_Priority)
m_ChunkZ(a_ChunkZ),
m_Client(a_Client)
{ {
} }
};
bool operator ==(const sSendChunk & a_Other) cWorld & m_World;
{
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;
cCriticalSection m_CS; cCriticalSection m_CS;
cChunkCoordsList m_ChunksReady; std::priority_queue<sChunkQueue> m_SendChunks;
sSendChunkList m_SendChunksLowPriority; std::unordered_map<cChunkCoords, sSendChunk, cChunkCoordsHash> m_ChunkInfo;
sSendChunkList m_SendChunksMediumPriority;
sSendChunkList m_SendChunksHighPriority;
cEvent m_evtQueue; // Set when anything is added to m_ChunksReady cEvent m_evtQueue; // Set when anything is added to m_ChunksReady
cEvent m_evtRemoved; // Set when removed clients are safe to be deleted 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) 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: // Data about the chunk that is being sent:
// NOTE that m_BlockData[] is inherited from the cChunkDataCollector // NOTE that m_BlockData[] is inherited from the cChunkDataCollector
unsigned char m_BiomeMap[cChunkDef::Width * cChunkDef::Width]; 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 // TODO: sEntityIDs m_Entities; // Entity-IDs of the entities to send
// cIsThread override: // cIsThread override:
@ -146,9 +126,8 @@ protected:
virtual void BlockEntity (cBlockEntity * a_Entity) override; virtual void BlockEntity (cBlockEntity * a_Entity) override;
/// Sends the specified chunk to a_Client, or to all chunk clients if a_Client == nullptr /// 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);
} ; } ;

View File

@ -456,7 +456,7 @@ bool cClientHandle::StreamNextChunk(void)
// If the chunk already loading / loaded -> skip // If the chunk already loading / loaded -> skip
if ( 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()) (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 the chunk already loading / loaded -> skip
if ( 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()) (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 DiffX = Diff((*itr).m_ChunkX, ChunkPosX);
int DiffZ = Diff((*itr).m_ChunkZ, ChunkPosZ); 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); cCSLock Lock(m_CSChunkLists);
m_LoadedChunks.push_back(cChunkCoords(a_ChunkX, a_ChunkZ)); 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); 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; bool Found = false;
{ {
cCSLock Lock(m_CSChunkLists); 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;
m_ChunksToSend.erase(itr); }
Found = true;
break;
}
} // for itr - m_ChunksToSend[]
} }
if (!Found) if (!Found)
{ {
@ -2950,7 +2947,7 @@ bool cClientHandle::WantsSendChunk(int a_ChunkX, int a_ChunkZ)
} }
cCSLock Lock(m_CSChunkLists); 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); LOGD("Adding chunk [%d, %d] to wanted chunks for client %p", a_ChunkX, a_ChunkZ, this);
cCSLock Lock(m_CSChunkLists); 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);
} }
} }

View File

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

View File

@ -186,6 +186,7 @@ cWorld::cWorld(const AString & a_WorldName, eDimension a_Dimension, const AStrin
m_Scoreboard(this), m_Scoreboard(this),
m_MapManager(this), m_MapManager(this),
m_GeneratorCallbacks(*this), m_GeneratorCallbacks(*this),
m_ChunkSender(*this),
m_TickThread(*this) m_TickThread(*this)
{ {
LOGD("cWorld::cWorld(\"%s\")", a_WorldName.c_str()); LOGD("cWorld::cWorld(\"%s\")", a_WorldName.c_str());
@ -509,7 +510,7 @@ void cWorld::Start(void)
m_Lighting.Start(this); m_Lighting.Start(this);
m_Storage.Start(this, m_StorageSchema, m_StorageCompressionFactor); m_Storage.Start(this, m_StorageSchema, m_StorageCompressionFactor);
m_Generator.Start(m_GeneratorCallbacks, m_GeneratorCallbacks, IniFile); m_Generator.Start(m_GeneratorCallbacks, m_GeneratorCallbacks, IniFile);
m_ChunkSender.Start(this); m_ChunkSender.Start();
m_TickThread.Start(); m_TickThread.Start();
// Init of the spawn monster time (as they are supposed to have different spawn rate) // 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) bool cWorld::DoWithChunkAt(Vector3i a_BlockPos, std::function<bool(cChunk &)> a_Callback)
{ {
return m_ChunkMap->DoWithChunkAt(a_BlockPos, 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) void cWorld::BroadcastCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player, const cClientHandle * a_Exclude)
{ {
m_ChunkMap->BroadcastCollectEntity(a_Entity, a_Player, 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: // If a client is requesting this chunk, send it to them:
int ChunkX = a_SetChunkData.GetChunkX(); int ChunkX = a_SetChunkData.GetChunkX();
int ChunkZ = a_SetChunkData.GetChunkZ(); int ChunkZ = a_SetChunkData.GetChunkZ();
if (m_ChunkMap->HasChunkAnyClients(ChunkX, ChunkZ)) cChunkSender & ChunkSender = m_ChunkSender;
{ DoWithChunk(
m_ChunkSender.ChunkReady(ChunkX, ChunkZ); 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 // Save the chunk right after generating, so that we don't have to generate it again on next run
if (a_SetChunkData.ShouldMarkDirty()) if (a_SetChunkData.ShouldMarkDirty())

View File

@ -231,7 +231,6 @@ public:
void BroadcastChat (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = nullptr); void BroadcastChat (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = nullptr);
// tolua_end // 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 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 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); 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 */ /** 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, 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 **/ /** 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); bool DoWithChunkAt(Vector3i a_BlockPos, std::function<bool(cChunk &)> a_Callback);