Reinstate "Chunk queue collapsing"
This reinstates commitf36acb6835
and reverts commitadfbc42c02
.
This commit is contained in:
parent
d436a71cbc
commit
dd4b415051
@ -1 +1 @@
|
|||||||
Subproject commit 94da343b62f0498a5843247f36d6ee00cbeb8f21
|
Subproject commit 493f2dfa6d39f134e37c4c614cf8d6ffd10c825f
|
@ -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; }
|
||||||
|
@ -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)
|
||||||
|
@ -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);
|
||||||
|
@ -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);
|
||||||
|
@ -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);
|
||||||
|
@ -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());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@ -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);
|
||||||
} ;
|
} ;
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
@ -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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -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;
|
||||||
|
|
||||||
|
@ -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())
|
||||||
|
@ -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);
|
||||||
|
Loading…
Reference in New Issue
Block a user