void CNetworkStallTickerThread::Run()
{
bool gotLockLastTime=true;
#if WARN_ABOUT_LONG_STALLS_IN_TICKER
CTimeValue started=gEnv->pTimer->GetAsyncTime();
CTimeValue ended;
#endif
SetName("NetworkStallTicker");
while (m_threadRunning)
{
if (gEnv->pNetwork)
{
gEnv->pNetwork->SyncWithGame(eNGS_SleepNetwork);
}
if (gotLockLastTime)
{
CrySleep(33);
}
else
{
CrySleep(1);
}
{
if (gEnv->pNetwork)
{
SCOPED_TICKER_TRY_LOCK;
if (SCOPED_TICKER_HAS_LOCK)
{
gEnv->pNetwork->SyncWithGame(eNGS_MinimalUpdateForLoading);
gotLockLastTime=true;
}
else
{
gotLockLastTime=false;
}
gEnv->pNetwork->SyncWithGame(eNGS_WakeNetwork);
}
#if WARN_ABOUT_LONG_STALLS_IN_TICKER
ended = gEnv->pTimer->GetAsyncTime();
if (ended.GetDifferenceInSeconds(started)>1.f)
{
CryLogAlways("THREADEDLOADING:: No update for %f",ended.GetDifferenceInSeconds(started));
}
started=ended;
#endif
}
}
Stop();
}
void CLuaRemoteDebug::HaltExecutionLoop(lua_State *L, lua_Debug *ar, const char* errorStr)
{
m_pHaltedLuaDebug = ar;
SendLuaState(ar);
SendVariables();
if (errorStr)
{
SendScriptError(errorStr);
}
m_bExecutionStopped = true;
if (INotificationNetwork *pNotificationNetwork = gEnv->pSystem->GetINotificationNetwork())
{
while (m_bExecutionStopped)
{
gEnv->pSystem->ResetWatchdogTimer();
pNotificationNetwork->Update();
CrySleep(50);
}
}
m_pHaltedLuaDebug = NULL;
}
void CDownloadMgr::WaitForDownloadsToFinish(const char** resources, int numResources, float timeout)
{
CDownloadableResourcePtr* pResources=new CDownloadableResourcePtr[numResources];
for (int i=0; i<numResources; ++i)
{
CDownloadableResourcePtr pRes = FindResourceByName(resources[i]);
if (pRes)
{
pRes->StartDownloading();
}
pResources[i] = pRes;
}
CTimeValue startTime = gEnv->pTimer->GetAsyncTime();
while (true)
{
bool allFinished = true;
for (int i=0; i<numResources; ++i)
{
CDownloadableResourcePtr pRes = pResources[i];
if (pRes)
{
CDownloadableResource::TState state = pRes->GetState();
if (state & CDownloadableResource::k_callbackInProgressMask)
{
allFinished = false;
break;
}
}
}
CTimeValue currentTime = gEnv->pTimer->GetAsyncTime();
if (allFinished || currentTime.GetDifferenceInSeconds(startTime) > timeout)
{
break;
}
CrySleep(100);
};
delete [] pResources;
DispatchCallbacks();
}
virtual void Run()
{
SetName("ZLibCompressor");
#if defined (DURANGO)
SetThreadAffinityMask(GetCurrentThread(), BIT(3));
#endif
while(!m_bCancelled || !m_files.empty())
{
m_event.Wait();
uint8* pZLibCompressedBuffer = AllocateBlock();
while(!m_files.empty())
{
CFile* pFile = m_files.pop();
assert(pFile);
PREFAST_ASSUME(pFile);
while(!pFile->Closed() || !pFile->m_blocks.empty())
{
if( pFile->m_blocks.empty() )
{
CrySleep(1); // yield to give other threads a chance to do some work
}
while(!pFile->m_blocks.empty())
{
SZLibBlock* block = pFile->m_blocks.pop();
assert(block);
PREFAST_ASSUME(block);
if(pFile->m_pCompressor->m_bUseZLibCompression)
{
size_t compressedLength = XMLCPB_ZLIB_BUFFER_SIZE;
bool compressionOk = gEnv->pSystem->CompressDataBlock( block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed, pZLibCompressedBuffer, compressedLength );
SZLibBlockHeader zlibHeader;
zlibHeader.m_compressedSize = compressionOk ? compressedLength : SZLibBlockHeader::NO_ZLIB_USED;
zlibHeader.m_uncompressedSize = block->m_ZLibBufferSizeUsed;
pFile->m_bytesWrittenIntoFileUncompressed += block->m_ZLibBufferSizeUsed;
pFile->Write( &zlibHeader, sizeof(SZLibBlockHeader) );
if (compressionOk)
pFile->Write( pZLibCompressedBuffer, compressedLength );
else
pFile->Write( block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed );
}
else
{
pFile->Write(block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed);
}
delete block;
}
}
pFile->Finish();
delete pFile;
}
FreeBlock(pZLibCompressedBuffer);
}
}
void CPacketQueue::Thread()
{
gEnv->pLog->Log(TITLE "Send/Read packets thread started!");
while(!gEnv->pSystem->IsQuitting())
{
send_mutex.lock();
if(packetsInSendQueue>0)
{
//gEnv->pLog->Log("[CryMasterServer] Sending packet...");
SPacket packet;
std::vector <SPacket>::iterator it;
it = SendPackets.begin();
packet.addr = (*it).addr;
packet.data = (*it).data;
packet.size = (*it).size;
send(packet.addr,packet.data,packet.size,0);
SendPackets.erase(it);
packetsInSendQueue--;
}
send_mutex.unlock();
read_mutex.lock();
if(packetsInReadQueue>0)
{
//gEnv->pLog->Log("[CryMasterServer] Reding packet...");
SPacket Packet;
SPlayer Player;
std::vector <SPacket>::iterator it;
it = ReadPackets.begin();
Packet.addr = (*it).addr;
Packet.data = (*it).data;
Packet.size = (*it).size;
EPacketType packetType = gClientEnv->pRsp->GetPacketType(Packet);
switch (packetType)
{
case PACKET_IDENTIFICATION:
gEnv->pLog->Log(TITLE "Identification packet recived");
break;
case PACKET_ACCOUNT:
{
gEnv->pLog->Log(TITLE "Account info packet recived");
gClientEnv->masterPlayer = gClientEnv->pRsp->ReadAccountInfo(Packet);
SPlayer Player;
SUIArguments args;
Player = gClientEnv->masterPlayer;
if(Player.playerId != 0)
{
args.AddArgument(Player.nickname.c_str());
args.AddArgument(Player.level);
args.AddArgument(Player.money);
args.AddArgument(Player.xp);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_AccountInfoResived, args);
}
break;
}
case PACKET_MESSAGE:
{
SMessage Message = gClientEnv->pRsp->ReadMsg(Packet);
if(strcmp(Message.message,""))
{
switch (Message.area)
{
case CHAT_MESSAGE_GLOBAL:
{
gEnv->pLog->Log(TITLE "Global chat message recived");
SUIArguments args;
args.AddArgument(Message.message);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_MsgResived, args);
break;
}
case CHAT_MESSAGE_PRIVATE:
break;
case CHAT_MESSAGE_SYSTEM:
{
gClientEnv->serverResult = Message.message;
gEnv->pLog->Log(TITLE "System message recived [%s]", gClientEnv->serverResult.c_str());
break;
}
default:
break;
}
}
break;
}
case PACKET_REQUEST:
{
gEnv->pLog->Log(TITLE "Request packet recived");
SRequestPacket svRequest = gClientEnv->pRsp->ReadRequest(Packet);
if(!strcmp(svRequest.request,"RemoveGameServer"))
{
SUIArguments args;
args.AddArgument(svRequest.iParam);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_RemoveServer, args);
std::vector <SGameServer>::iterator it;
bool find = false;
// Delete game server
for(it = gClientEnv->pMasterServer->vServers.begin(); it!= gClientEnv->pMasterServer->vServers.end(); ++it)
{
if(it->id == svRequest.iParam)
{
find = true;
break;
}
}
if(find) gClientEnv->pMasterServer->vServers.erase(it);
}
break;
}
case PACKET_MS_INFO:
{
gEnv->pLog->Log(TITLE "Master server info packet recived");
gClientEnv->serverInfo = gClientEnv->pRsp->ReadMasterServerInfo(Packet);
if(gClientEnv->serverInfo.playersOnline)
{
SUIArguments args;
args.AddArgument(gClientEnv->serverInfo.playersOnline);
args.AddArgument(gClientEnv->serverInfo.gameServersOnline);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_ServerInfoResived, args);
}
break;
}
case PACKET_GAME_SERVERS:
{
gEnv->pLog->Log( TITLE "Game servers packet recived");
gClientEnv->pRsp->ReadGameServers(Packet);
break;
}
case PACKET_CONSOLE_COMMAND:
{
gEnv->pLog->Log(TITLE "Console command packet recieved");
gClientEnv->pRsp->ReadConsoleCommandPacket(Packet);
break;
}
default:
gEnv->pLog->Log( TITLE "Unknown packet recived...");
break;
}
ReadPackets.erase(it);
packetsInReadQueue--;
}
read_mutex.unlock();
CrySleep(1);
}
}
