void CPlayer::Snap(int SnappingClient)
{
if(!IsDummy() && !Server()->ClientIngame(m_ClientID))
return;
CNetObj_PlayerInfo *pPlayerInfo = static_cast<CNetObj_PlayerInfo *>(Server()->SnapNewItem(NETOBJTYPE_PLAYERINFO, m_ClientID, sizeof(CNetObj_PlayerInfo)));
if(!pPlayerInfo)
return;
pPlayerInfo->m_PlayerFlags = m_PlayerFlags&PLAYERFLAG_CHATTING;
if(Server()->IsAuthed(m_ClientID))
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_ADMIN;
if(!GameServer()->m_pController->IsPlayerReadyMode() || m_IsReadyToPlay)
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_READY;
if(m_RespawnDisabled && (!GetCharacter() || !GetCharacter()->IsAlive()))
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_DEAD;
if(SnappingClient != -1 && (m_Team == TEAM_SPECTATORS || m_DeadSpecMode) && SnappingClient == m_SpectatorID)
pPlayerInfo->m_PlayerFlags |= PLAYERFLAG_WATCHING;
pPlayerInfo->m_Latency = SnappingClient == -1 ? m_Latency.m_Min : GameServer()->m_apPlayers[SnappingClient]->m_aActLatency[m_ClientID];
pPlayerInfo->m_Score = m_Score;
if(m_ClientID == SnappingClient && (m_Team == TEAM_SPECTATORS || m_DeadSpecMode))
{
CNetObj_SpectatorInfo *pSpectatorInfo = static_cast<CNetObj_SpectatorInfo *>(Server()->SnapNewItem(NETOBJTYPE_SPECTATORINFO, m_ClientID, sizeof(CNetObj_SpectatorInfo)));
if(!pSpectatorInfo)
return;
pSpectatorInfo->m_SpectatorID = m_SpectatorID;
pSpectatorInfo->m_X = m_ViewPos.x;
pSpectatorInfo->m_Y = m_ViewPos.y;
}
// demo recording
if(SnappingClient == -1)
{
CNetObj_De_ClientInfo *pClientInfo = static_cast<CNetObj_De_ClientInfo *>(Server()->SnapNewItem(NETOBJTYPE_DE_CLIENTINFO, m_ClientID, sizeof(CNetObj_De_ClientInfo)));
if(!pClientInfo)
return;
pClientInfo->m_Local = 0;
pClientInfo->m_Team = m_Team;
StrToInts(pClientInfo->m_aName, 4, Server()->ClientName(m_ClientID));
StrToInts(pClientInfo->m_aClan, 3, Server()->ClientClan(m_ClientID));
pClientInfo->m_Country = Server()->ClientCountry(m_ClientID);
for(int p = 0; p < 6; p++)
{
StrToInts(pClientInfo->m_aaSkinPartNames[p], 6, m_TeeInfos.m_aaSkinPartNames[p]);
pClientInfo->m_aUseCustomColors[p] = m_TeeInfos.m_aUseCustomColors[p];
pClientInfo->m_aSkinPartColors[p] = m_TeeInfos.m_aSkinPartColors[p];
}
}
}
void P3DBranchModel::Save
(P3DOutputStringStream
*TargetStream,
P3DMaterialSaver *MaterialSaver) const
{
P3DOutputStringFmtStream FmtStream(TargetStream);
FmtStream.WriteString("ss","BranchGroupName",GetName());
FmtStream.WriteString("sb","IsDummy",IsDummy());
if (BranchingAlg != 0)
{
BranchingAlg->Save(TargetStream);
}
else
{
FmtStream.WriteString("ss","BranchingAlg","__None__");
}
if (StemModel != 0)
{
StemModel->Save(TargetStream);
}
else
{
FmtStream.WriteString("ss","StemModel","__None__");
}
if (MaterialInstance != 0)
{
MaterialSaver->Save(TargetStream,MaterialInstance);
}
else
{
FmtStream.WriteString("ss","Material","__None__");
}
VisRangeState.Save(TargetStream);
FmtStream.WriteString("su","BranchModelCount",SubBranchCount);
for (unsigned int SubBranchIndex = 0; SubBranchIndex < SubBranchCount; SubBranchIndex++)
{
SubBranches[SubBranchIndex]->Save(TargetStream,MaterialSaver);
}
}
void BerkeleyDatabase::Flush(bool shutdown)
{
if (!IsDummy()) {
env->Flush(shutdown);
if (shutdown) {
LOCK(cs_db);
g_dbenvs.erase(env->Directory().string());
env = nullptr;
} else {
// TODO: To avoid g_dbenvs.erase erasing the environment prematurely after the
// first database shutdown when multiple databases are open in the same
// environment, should replace raw database `env` pointers with shared or weak
// pointers, or else separate the database and environment shutdowns so
// environments can be shut down after databases.
env->m_fileids.erase(strFile);
}
}
}
nuiRect nuiTextRun::GetRect() const
{
if (IsDummy())
return nuiRect(mAdvanceX, mAdvanceY);
nuiFontInfo finfo;
mStyle.GetFont()->GetInfo(finfo);
// const nuiTextGlyph& rGlyph(*it);
// nuiGlyphInfo info;
// rGlyph.mpFont->GetGlyphInfo(info, rGlyph.Index, nuiFontBase::eGlyphBitmap);
// nuiSize w = info.AdvanceX;
// // nuiSize h = finfo.AdvanceMaxH;
// nuiSize x = rGlyph.X + info.BearingX;
// nuiSize y = rGlyph.Y - finfo.Ascender;
// nuiSize h = finfo.Height;
//
// nuiRect rr(r);
// r.Union(rr, nuiRect(x, y, w, h));
// return r;
return nuiRect();
}
bool BerkeleyDatabase::Backup(const std::string& strDest)
{
if (IsDummy()) {
return false;
}
while (true)
{
{
LOCK(cs_db);
if (!env->mapFileUseCount.count(strFile) || env->mapFileUseCount[strFile] == 0)
{
// Flush log data to the dat file
env->CloseDb(strFile);
env->CheckpointLSN(strFile);
env->mapFileUseCount.erase(strFile);
// Copy wallet file
fs::path pathSrc = env->Directory() / strFile;
fs::path pathDest(strDest);
if (fs::is_directory(pathDest))
pathDest /= strFile;
try {
if (fs::equivalent(pathSrc, pathDest)) {
LogPrintf("cannot backup to wallet source file %s\n", pathDest.string());
return false;
}
fs::copy_file(pathSrc, pathDest, fs::copy_option::overwrite_if_exists);
LogPrintf("copied %s to %s\n", strFile, pathDest.string());
return true;
} catch (const fs::filesystem_error& e) {
LogPrintf("error copying %s to %s - %s\n", strFile, pathDest.string(), fsbridge::get_filesystem_error_message(e));
return false;
}
}
}
MilliSleep(100);
}
}
float nuiTextRun::GetAscender() const
{
if (IsDummy())
return 0;
return mStyle.GetFont()->GetAscender();
}
void BerkeleyDatabase::ReloadDbEnv()
{
if (!IsDummy()) {
env->ReloadDbEnv();
}
}
void CPlayer::Tick()
{
if(!IsDummy() && !Server()->ClientIngame(m_ClientID))
return;
Server()->SetClientScore(m_ClientID, m_Score);
// do latency stuff
{
IServer::CClientInfo Info;
if(Server()->GetClientInfo(m_ClientID, &Info))
{
m_Latency.m_Accum += Info.m_Latency;
m_Latency.m_AccumMax = max(m_Latency.m_AccumMax, Info.m_Latency);
m_Latency.m_AccumMin = min(m_Latency.m_AccumMin, Info.m_Latency);
}
// each second
if(Server()->Tick()%Server()->TickSpeed() == 0)
{
m_Latency.m_Avg = m_Latency.m_Accum/Server()->TickSpeed();
m_Latency.m_Max = m_Latency.m_AccumMax;
m_Latency.m_Min = m_Latency.m_AccumMin;
m_Latency.m_Accum = 0;
m_Latency.m_AccumMin = 1000;
m_Latency.m_AccumMax = 0;
}
}
if(m_pCharacter && !m_pCharacter->IsAlive())
{
delete m_pCharacter;
m_pCharacter = 0;
}
if(!GameServer()->m_pController->IsGamePaused())
{
if(!m_pCharacter && m_Team == TEAM_SPECTATORS && m_SpectatorID == SPEC_FREEVIEW)
m_ViewPos -= vec2(clamp(m_ViewPos.x-m_LatestActivity.m_TargetX, -500.0f, 500.0f), clamp(m_ViewPos.y-m_LatestActivity.m_TargetY, -400.0f, 400.0f));
if(!m_pCharacter && m_DieTick+Server()->TickSpeed()*3 <= Server()->Tick() && !m_DeadSpecMode)
Respawn();
if(m_pCharacter)
{
if(m_pCharacter->IsAlive())
m_ViewPos = m_pCharacter->m_Pos;
}
else if(m_Spawning && m_RespawnTick <= Server()->Tick())
TryRespawn();
if(!m_DeadSpecMode && m_LastActionTick != Server()->Tick())
++m_InactivityTickCounter;
}
else
{
++m_RespawnTick;
++m_DieTick;
++m_ScoreStartTick;
++m_LastActionTick;
++m_TeamChangeTick;
}
}
void BerkeleyDatabase::Flush(bool shutdown)
{
if (!IsDummy()) {
env->Flush(shutdown);
}
}
void ShaderSettings::Prepare(ID3D11Device* device, ID3D11DeviceContext* device_context) const {
if (!IsDummy()) {
constant_buffer->Prepare(device, device_context, buffer_register);
}
}