void CModelSoundsCache::Save( CUtlBuffer& buf )
{
buf.PutShort( sounds.Count() );
for ( int i = 0; i < sounds.Count(); ++i )
{
buf.PutString( GetSoundName( i ) );
}
}
void CNetworkStringTableContainer::WriteStringTables( CUtlBuffer& buf )
{
int numTables = m_Tables.Size();
buf.PutInt( numTables );
for ( int i = 0; i < numTables; i++ )
{
CNetworkStringTable *table = m_Tables[ i ];
buf.PutString( table->GetTableName() );
table->WriteStringTable( buf );
}
}
//-----------------------------------------------------------------------------
// Purpose: Fills buffer with list of maps from this mod
//-----------------------------------------------------------------------------
void CServerRemoteAccess::GetMapList(CUtlBuffer &value)
{
// search the directory structure.
char mapwild[MAX_QPATH];
char friendly_com_gamedir[ MAX_OSPATH ];
strcpy(mapwild, "maps/*.bsp");
Q_strncpy( friendly_com_gamedir, com_gamedir, sizeof(friendly_com_gamedir) );
Q_strlower( friendly_com_gamedir );
char const *findfn = Sys_FindFirst( mapwild, NULL, 0 );
while ( findfn )
{
char curDir[MAX_PATH];
_snprintf(curDir, MAX_PATH, "maps/%s", findfn);
g_pFileSystem->GetLocalPath(curDir, curDir, MAX_PATH);
// limit maps displayed to ones for the mod only
if (strstr(curDir, friendly_com_gamedir))
{
// clean up the map name
char mapName[MAX_PATH];
strcpy(mapName, findfn);
char *extension = strstr(mapName, ".bsp");
if (extension)
{
*extension = 0;
}
// write into buffer
value.PutString(mapName);
value.PutString("\n");
}
findfn = Sys_FindNext( NULL, 0 );
}
Sys_FindClose();
value.PutChar(0);
}
void CSceneCache::Save( CUtlBuffer& buf )
{
buf.PutUnsignedInt( msecs );
unsigned short c = GetSoundCount();
buf.PutShort( c );
Assert( sounds.Count() <= 65536 );
for ( int i = 0; i < c; ++i )
{
buf.PutString( GetSoundName( i ) );
}
}
void CCompiledKeyValuesWriter::WriteStringTable( CUtlBuffer& buf )
{
int i;
CUtlVector< int > offsets;
CUtlBuffer stringBuffer;
offsets.AddToTail( stringBuffer.TellPut() );
stringBuffer.PutString( "" );
// save all the rest
int c = m_StringTable.GetNumStrings();
for ( i = 1; i < c; i++)
{
offsets.AddToTail( stringBuffer.TellPut() );
stringBuffer.PutString( m_StringTable.String( i ) );
}
buf.Put( offsets.Base(), offsets.Count() * sizeof( int ) );
buf.PutInt( stringBuffer.TellPut() );
buf.Put( stringBuffer.Base(), stringBuffer.TellPut() );
}
void CServerRemoteAccess::GetMapList(CUtlBuffer &value)
{
const char *findfn;
char *extension;
char curDir[MAX_PATH];
char mapName[MAX_PATH];
char mapwild[64];
Q_strcpy(mapwild, "maps/*.bsp");
for (findfn = Sys_FindFirst(mapwild, 0); findfn; findfn = Sys_FindNext(0))
{
Q_snprintf(curDir, ARRAYSIZE(curDir), "maps/%s", findfn);
#ifdef REHLDS_CHECKS
curDir[ARRAYSIZE(curDir) - 1] = 0;
#endif
FS_GetLocalPath(curDir, curDir, ARRAYSIZE(curDir));
if (Q_strstr(curDir, com_gamedir))
{
#ifdef REHLDS_CHECKS
Q_strncpy(mapName, findfn, ARRAYSIZE(mapName));
mapName[ARRAYSIZE(mapName) - 1] = 0;
#else
Q_strcpy(mapName, findfn);
#endif
extension = Q_strstr(mapName, ".bsp");
if (extension)
*extension = 0;
value.PutString(mapName);
value.PutString("\n");
}
}
Sys_FindClose();
value.PutChar(0);
}
//-----------------------------------------------------------------------------
// Serialize a floating point number in text mode in a readably friendly fashion
//-----------------------------------------------------------------------------
static void SerializeFloat( CUtlBuffer &buf, float f )
{
Assert( buf.IsText() );
// FIXME: Print this in a way that we never lose precision
char pTemp[256];
int nLen = Q_snprintf( pTemp, sizeof(pTemp), "%.10f", f );
while ( nLen > 0 && pTemp[nLen-1] == '0' )
{
--nLen;
pTemp[nLen] = 0;
}
if ( nLen > 0 && pTemp[nLen-1] == '.' )
{
--nLen;
pTemp[nLen] = 0;
}
buf.PutString( pTemp );
}
void BasicGameStats_t::SaveToBuffer( CUtlBuffer& buf )
{
buf.PutInt( m_nSecondsToCompleteGame );
m_Summary.SaveToBuffer( buf );
int c = m_MapTotals.Count();
buf.PutInt( c );
for ( int i = m_MapTotals.First(); i != m_MapTotals.InvalidIndex(); i = m_MapTotals.Next( i ) )
{
char const *name = m_MapTotals.GetElementName( i );
BasicGameStatsRecord_t &rec = m_MapTotals[ i ];
buf.PutString( name );
rec.SaveToBuffer( buf );
}
buf.PutChar( (char)m_nHL2ChaptureUnlocked );
buf.PutChar( m_bSteam ? 1 : 0 );
buf.PutChar( m_bCyberCafe ? 1 : 0 );
buf.PutShort( (short)m_nDXLevel );
}
void CNetworkStringTable::WriteStringTable( CUtlBuffer& buf )
{
int numstrings = GetNumStrings();
buf.PutInt( numstrings );
for ( int i = 0 ; i < numstrings; i++ )
{
buf.PutString( GetString( i ) );
int userDataSize;
const void *pUserData = GetStringUserData( i, &userDataSize );
if ( userDataSize > 0 )
{
buf.PutChar( 1 );
buf.PutShort( (short)userDataSize );
buf.Put( pUserData, userDataSize );
}
else
{
buf.PutChar( 0 );
}
}
}
void CChoreoActor::SaveToBuffer( CUtlBuffer& buf, CChoreoScene *pScene )
{
int i, c;
buf.PutString( GetName() );
c = GetNumChannels();
buf.PutShort( c );
for ( i = 0; i < c; i++ )
{
CChoreoChannel *channel = GetChannel( i );
Assert( channel );
channel->SaveToBuffer( buf, pScene );
}
/*
if ( Q_strlen( a->GetFacePoserModelName() ) > 0 )
{
FilePrintf( buf, level + 1, "faceposermodel \"%s\"\n", a->GetFacePoserModelName() );
}
*/
buf.PutChar( GetActive() ? 1 : 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Finds the value of a particular server variable
//-----------------------------------------------------------------------------
bool CServerRemoteAccess::LookupValue(const char *variable, CUtlBuffer &value)
{
Assert(value.IsText());
// first see if it's a cvar
const char *strval = LookupStringValue(variable);
if (strval)
{
value.PutString(strval);
value.PutChar(0);
}
else if (!stricmp(variable, "stats"))
{
char stats[512];
GetStatsString(stats, sizeof(stats));
value.PutString(stats);
value.PutChar(0);
}
else if (!stricmp(variable, "banlist"))
{
// returns a list of banned users and ip's
GetUserBanList(value);
}
else if (!stricmp(variable, "playerlist"))
{
GetPlayerList(value);
}
else if (!stricmp(variable, "maplist"))
{
GetMapList(value);
}
else if (!stricmp(variable, "uptime"))
{
int timeSeconds = (int)(Plat_FloatTime());
value.PutInt(timeSeconds);
value.PutChar(0);
}
else if (!stricmp(variable, "ipaddress"))
{
char addr[25];
Q_snprintf( addr, sizeof(addr), "%s:%i", net_local_adr.ToString(true), sv.GetUDPPort());
value.PutString( addr );
value.PutChar(0);
}
else if (!stricmp(variable, "mapcycle"))
{
ConVarRef mapcycle( "mapcyclefile" );
if ( mapcycle.IsValid() )
{
// send the mapcycle list file
FileHandle_t f = g_pFileSystem->Open(mapcycle.GetString(), "rb" );
if ( f == FILESYSTEM_INVALID_HANDLE )
return true;
int len = g_pFileSystem->Size(f);
char *mapcycleData = (char *)_alloca( len+1 );
if ( len && g_pFileSystem->Read( mapcycleData, len, f ) )
{
mapcycleData[len] = 0; // Make sure it's null terminated.
value.PutString((const char *)mapcycleData);
value.PutChar(0);
}
else
{
value.PutString( "" );
value.PutChar(0);
}
g_pFileSystem->Close( f );
}
}
else
{
// value not found, null terminate
value.PutChar(0);
return false;
}
return true;
}
bool CServerRemoteAccess::LookupValue(const char *variable, CUtlBuffer &value)
{
const char* strval = LookupStringValue(variable);
if (strval)
{
value.PutString(strval);
value.PutChar(0);
return true;
}
if (!Q_stricmp(variable, "stats"))
{
char stats[512];
GetStatsString(stats, sizeof(stats));
value.PutString(stats);
value.PutChar(0);
return true;
}
if (!Q_stricmp(variable, "banlist"))
{
GetUserBanList(value);
return true;
}
if (!Q_stricmp(variable, "playerlist"))
{
GetPlayerList(value);
return true;
}
if (!Q_stricmp(variable, "maplist"))
{
GetMapList(value);
return true;
}
if (!Q_stricmp(variable, "uptime"))
{
value.PutInt(int(Sys_FloatTime() - Host_GetStartTime()));
value.PutChar(0);
return true;
}
if (!Q_stricmp(variable, "ipaddress"))
{
value.PutString(NET_AdrToString(net_local_adr));
value.PutChar(0);
return true;
}
if (!Q_stricmp(variable, "mapcycle"))
{
int len;
void* mapcyclelist = COM_LoadFileForMe(mapcyclefile.string, &len);
if (mapcyclelist && len)
{
value.PutString((char*)mapcyclelist);
value.PutChar(0);
COM_FreeFile(mapcyclelist);
}
return true;
}
value.PutChar(0);
return false;
}
size_t CGEWebRequest::WriteData( void *ptr, size_t size, size_t nmemb, void *userdata )
{
CUtlBuffer *result = (CUtlBuffer*) userdata;
result->PutString( (char*)ptr );
return size * nmemb;
}
bool KeyValues::WriteAsBinary(CUtlBuffer &buffer)
{
if (buffer.IsText())
return false;
if (!buffer.IsValid())
return false;
for (KeyValues *dat = this; dat != NULL; dat = dat->m_pPeer)
{
buffer.PutUnsignedChar(dat->m_iDataType);
buffer.PutString(dat->GetName());
switch (dat->m_iDataType)
{
case TYPE_NONE:
{
dat->m_pSub->WriteAsBinary(buffer);
break;
}
case TYPE_STRING:
{
if (dat->m_sValue && *(dat->m_sValue))
{
buffer.PutString(dat->m_sValue);
}
else
{
buffer.PutString("");
}
break;
}
case TYPE_WSTRING:
{
Assert(!"TYPE_WSTRING");
break;
}
case TYPE_INT:
{
buffer.PutInt(dat->m_iValue);
break;
}
case TYPE_UINT64:
{
buffer.PutDouble(*((double *)dat->m_sValue));
break;
}
case TYPE_FLOAT:
{
buffer.PutFloat(dat->m_flValue);
break;
}
case TYPE_COLOR:
{
buffer.PutUnsignedChar(dat->m_Color[0]);
buffer.PutUnsignedChar(dat->m_Color[1]);
buffer.PutUnsignedChar(dat->m_Color[2]);
buffer.PutUnsignedChar(dat->m_Color[3]);
break;
}
case TYPE_PTR:
{
buffer.PutUnsignedInt((int)dat->m_pValue);
}
default:
{
break;
}
}
}
buffer.PutUnsignedChar(TYPE_NUMTYPES);
return buffer.IsValid();
}
