//----------------------------------------------------------------------------- // Binary buffer attribute //----------------------------------------------------------------------------- bool Serialize( CUtlBuffer &buf, const CUtlBinaryBlock &src ) { int nLength = src.Length(); if ( !buf.IsText() ) { buf.PutInt( nLength ); if ( nLength != 0 ) { buf.Put( src.Get(), nLength ); } return buf.IsValid(); } // Writes out uuencoded binaries for ( int i = 0; i < nLength; ++i ) { if ( (i % 40) == 0 ) { buf.PutChar( '\n' ); } char b1 = src[i] & 0xF; char b2 = src[i] >> 4; char c1 = ( b1 <= 9 ) ? b1 + '0' : b1 - 10 + 'A'; char c2 = ( b2 <= 9 ) ? b2 + '0' : b2 - 10 + 'A'; buf.PutChar( c2 ); buf.PutChar( c1 ); } buf.PutChar( '\n' ); return buf.IsValid(); }
void BasicGameStatsRecord_t::SaveToBuffer( CUtlBuffer &buf ) { buf.PutInt( m_nCount ); buf.PutInt( m_nSeconds ); buf.PutInt( m_nCommentary ); buf.PutInt( m_nHDR ); buf.PutInt( m_nCaptions ); for ( int i = 0; i < 3; ++i ) { buf.PutInt( m_nSkill[ i ] ); } buf.PutChar( m_bSteam ? 1 : 0 ); buf.PutChar( m_bCyberCafe ? 1 : 0 ); buf.PutInt( m_nDeaths ); }
// build the final pool void GetTableAndPool( CUtlVector< unsigned int > &offsets, CUtlBuffer &buffer ) { offsets.Purge(); buffer.Purge(); offsets.EnsureCapacity( m_StringMap.GetNumStrings() ); buffer.EnsureCapacity( m_nOffset ); unsigned int currentOffset = 0; for ( int i = 0; i < m_StringMap.GetNumStrings(); i++ ) { offsets.AddToTail( currentOffset ); const char *pString = m_StringMap.String( i ); buffer.Put( pString, strlen( pString ) + 1 ); currentOffset += strlen( pString ) + 1; } Assert( currentOffset == m_nOffset ); // align string pool to end on dword boundary while ( buffer.TellMaxPut() & 0x03 ) { buffer.PutChar( '\0' ); m_nOffset++; } }
static void SerializeFloats( CUtlBuffer &buf, int nCount, const float *pFloats ) { for ( int i = 0; i < nCount; ++i ) { SerializeFloat( buf, pFloats[i] ); if ( i != nCount-1 ) { buf.PutChar( ' ' ); } } }
// This is a compressed save of just the data needed to drive phonemes in the engine (no word / sentence text, etc ) //----------------------------------------------------------------------------- // Purpose: // Input : buf - //----------------------------------------------------------------------------- void CSentence::CacheSaveToBuffer( CUtlBuffer& buf ) { Assert( !buf.IsText() ); Assert( m_bIsCached ); buf.PutChar( CACHED_SENTENCE_VERSION ); int i; unsigned short pcount = GetRuntimePhonemeCount(); buf.PutShort( pcount ); for ( i = 0; i < pcount; ++i ) { const CBasePhonemeTag *phoneme = GetRuntimePhoneme( i ); Assert( phoneme ); buf.PutShort( phoneme->GetPhonemeCode() ); buf.PutFloat( phoneme->GetStartTime() ); buf.PutFloat( phoneme->GetEndTime() ); } // Now save out emphasis samples int c = m_EmphasisSamples.Count(); Assert( c <= 32767 ); buf.PutShort( c ); for ( i = 0; i < c; i++ ) { CEmphasisSample *sample = &m_EmphasisSamples[ i ]; Assert( sample ); buf.PutFloat( sample->time ); short scaledValue = clamp( (short)( sample->value * 32767 ), 0, 32767 ); buf.PutShort( scaledValue ); } // And voice duck buf.PutChar( GetVoiceDuck() ? 1 : 0 ); }
//----------------------------------------------------------------------------- // Serialization methods for basic types //----------------------------------------------------------------------------- bool Serialize( CUtlBuffer &buf, const bool &src ) { if ( buf.IsText() ) { buf.Printf( "%d", src ); } else { buf.PutChar( src ); } return buf.IsValid(); }
void CCompiledKeyValuesWriter::WriteData( CUtlBuffer& buf ) { int c = m_Data.Count(); buf.PutInt( c ); for ( int i = 0; i < c; ++i ) { KVInfo_t &info = m_Data[ i ]; buf.PutShort( info.key ); buf.PutShort( info.value ); buf.PutShort( info.GetParent() ); buf.PutChar( info.IsSubTree() ? 1 : 0 ); } }
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 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 CServerRemoteAccess::GetPlayerList(CUtlBuffer &value) { for (int i = 0; i < g_psvs.maxclients; ++i) { client_t* cli = &g_psvs.clients[i]; if (!cli->active || Q_strlen(cli->name) < 1) continue; value.Printf("\"%s\" %s %s %d %d %d %d\n", cli->name, SV_GetIDString(&cli->network_userid), NET_AdrToString(cli->netchan.remote_address), int(cli->latency * 1000.0), (int)cli->packet_loss, (int)cli->edict->v.frags, int(realtime - cli->netchan.connect_time)); } value.PutChar(0); }
void CServerRemoteAccess::GetUserBanList(CUtlBuffer &value) { for (int i = 0; i < numuserfilters; i++) { value.Printf("%i %s : %.3f min\n", i + 1, SV_GetIDString(&userfilters[i].userid), userfilters[i].banTime); } for (int i = 0; i < numuserfilters; i++) { ipfilter_t* f = &ipfilters[i]; value.Printf("%i %i.%i.%i.%i : %.3f min\n", numuserfilters + i + 1, f->compare.octets[0], f->compare.octets[1], f->compare.octets[2], f->compare.octets[3], f->banTime); } value.PutChar(0); }
void CChoreoChannel::SaveToBuffer( CUtlBuffer& buf, CChoreoScene *pScene, IChoreoStringPool *pStringPool ) { buf.PutShort( pStringPool->FindOrAddString( GetName() ) ); int c = GetNumEvents(); Assert( c <= 255 ); buf.PutUnsignedChar( c ); for ( int i = 0; i < c; i++ ) { CChoreoEvent *e = GetEvent( i ); Assert( e ); e->SaveToBuffer( buf, pScene, pStringPool ); } buf.PutChar( GetActive() ? 1 : 0 ); }
//----------------------------------------------------------------------------- // Purpose: fills a buffer with a list of all banned IP addresses //----------------------------------------------------------------------------- void CServerRemoteAccess::GetUserBanList(CUtlBuffer &value) { // add user bans int i; for (i = 0; i < g_UserFilters.Count(); i++) { value.Printf("%i %s : %.3f min\n", i + 1, GetUserIDString(g_UserFilters[i].userid), g_UserFilters[i].banTime); } // add ip filters for (i = 0; i < g_IPFilters.Count() ; i++) { unsigned char b[4]; *(unsigned *)b = g_IPFilters[i].compare; value.Printf("%i %i.%i.%i.%i : %.3f min\n", i + 1 + g_UserFilters.Count(), b[0], b[1], b[2], b[3], g_IPFilters[i].banTime); } value.PutChar(0); }
//----------------------------------------------------------------------------- // Purpose: Fills buffer with details on everyone in the server //----------------------------------------------------------------------------- void CServerRemoteAccess::GetPlayerList(CUtlBuffer &value) { if ( !serverGameClients ) { return; } for ( int i=0 ; i< sv.GetClientCount() ; i++ ) { CGameClient *client = sv.Client(i); if ( !client || !client->IsActive() ) continue; CPlayerState *pl = serverGameClients->GetPlayerState( client->edict ); if ( !pl ) continue; // valid user, add to buffer // format per user, each user seperated by a newline '\n' // "name authID ipAddress ping loss frags time" if ( client->IsFakeClient() ) { value.Printf("\"%s\" %s 0 0 0 %d 0\n", client->GetClientName(), client->GetNetworkIDString(), pl->frags); } else { value.Printf("\"%s\" %s %s %d %d %d %d\n", client->GetClientName(), client->GetNetworkIDString(), client->GetNetChannel()->GetAddress(), (int)(client->GetNetChannel()->GetAvgLatency(FLOW_OUTGOING) * 1000.0f), (int)(client->GetNetChannel()->GetAvgLoss(FLOW_INCOMING)), pl->frags, (int)(client->GetNetChannel()->GetTimeConnected())); } } value.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: 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 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); }
// This is a compressed save of just the data needed to drive phonemes in the engine (no word / sentence text, etc ) //----------------------------------------------------------------------------- // Purpose: // Input : buf - //----------------------------------------------------------------------------- void CSentence::CacheSaveToBuffer( CUtlBuffer& buf, int version ) { Assert( !buf.IsText() ); Assert( m_bIsCached ); int i; unsigned short pcount = GetRuntimePhonemeCount(); // header if ( version == CACHED_SENTENCE_VERSION_ALIGNED ) { buf.PutChar( version ); buf.PutChar( 0 ); buf.PutChar( 0 ); buf.PutChar( 0 ); buf.PutInt( pcount ); } else { buf.PutChar( version ); buf.PutShort( pcount ); } // phoneme if ( version == CACHED_SENTENCE_VERSION_ALIGNED ) { for ( i = 0; i < pcount; ++i ) { const CBasePhonemeTag *phoneme = GetRuntimePhoneme( i ); Assert( phoneme ); buf.PutInt( phoneme->GetPhonemeCode() ); buf.PutFloat( phoneme->GetStartTime() ); buf.PutFloat( phoneme->GetEndTime() ); } } else { for ( i = 0; i < pcount; ++i ) { const CBasePhonemeTag *phoneme = GetRuntimePhoneme( i ); Assert( phoneme ); buf.PutShort( phoneme->GetPhonemeCode() ); buf.PutFloat( phoneme->GetStartTime() ); buf.PutFloat( phoneme->GetEndTime() ); } } // emphasis samples and voice duck int c = m_EmphasisSamples.Count(); Assert( c <= 32767 ); if ( version == CACHED_SENTENCE_VERSION_ALIGNED ) { buf.PutInt( c ); for ( i = 0; i < c; i++ ) { CEmphasisSample *sample = &m_EmphasisSamples[i]; Assert( sample ); buf.PutFloat( sample->time ); buf.PutFloat( sample->value ); } buf.PutInt( GetVoiceDuck() ? 1 : 0 ); } else { buf.PutShort( c ); for ( i = 0; i < c; i++ ) { CEmphasisSample *sample = &m_EmphasisSamples[i]; Assert( sample ); buf.PutFloat( sample->time ); short scaledValue = clamp( (short)( sample->value * 32767 ), (short)0, (short)32767 ); buf.PutShort( scaledValue ); } buf.PutChar( GetVoiceDuck() ? 1 : 0 ); } }
//----------------------------------------------------------------------------- // FIXME: assumes that we don't need to do gamma correction. //----------------------------------------------------------------------------- bool WriteToBuffer( unsigned char *pImageData, CUtlBuffer &buffer, int width, int height, ImageFormat srcFormat, ImageFormat dstFormat ) { TGAHeader_t header; // Fix the dstFormat to match what actually is going to go into the file switch( dstFormat ) { case IMAGE_FORMAT_RGB888: dstFormat = IMAGE_FORMAT_BGR888; break; #if defined( _X360 ) case IMAGE_FORMAT_LINEAR_RGB888: dstFormat = IMAGE_FORMAT_LINEAR_BGR888; break; #endif case IMAGE_FORMAT_RGBA8888: dstFormat = IMAGE_FORMAT_BGRA8888; break; } header.id_length = 0; // comment length header.colormap_type = 0; // ??? switch( dstFormat ) { case IMAGE_FORMAT_BGR888: #if defined( _X360 ) case IMAGE_FORMAT_LINEAR_BGR888: #endif header.image_type = 2; // 24/32 bit uncompressed TGA header.pixel_size = 24; break; case IMAGE_FORMAT_BGRA8888: header.image_type = 2; // 24/32 bit uncompressed TGA header.pixel_size = 32; break; case IMAGE_FORMAT_I8: header.image_type = 1; // 8 bit uncompressed TGA header.pixel_size = 8; break; default: return false; break; } header.colormap_index = 0; header.colormap_length = 0; header.colormap_size = 0; header.x_origin = 0; header.y_origin = 0; header.width = ( unsigned short )width; header.height = ( unsigned short )height; header.attributes = 0x20; // Makes it so we don't have to vertically flip the image buffer.PutChar( header.id_length ); buffer.PutChar( header.colormap_type ); buffer.PutChar( header.image_type ); fputLittleShort( header.colormap_index, buffer ); fputLittleShort( header.colormap_length, buffer ); buffer.PutChar( header.colormap_size ); fputLittleShort( header.x_origin, buffer ); fputLittleShort( header.y_origin, buffer ); fputLittleShort( header.width, buffer ); fputLittleShort( header.height, buffer ); buffer.PutChar( header.pixel_size ); buffer.PutChar( header.attributes ); int nSizeInBytes = width * height * ImageLoader::SizeInBytes( dstFormat ); buffer.EnsureCapacity( buffer.TellPut() + nSizeInBytes ); unsigned char *pDst = (unsigned char*)buffer.PeekPut(); if ( !ImageLoader::ConvertImageFormat( pImageData, srcFormat, pDst, dstFormat, width, height ) ) return false; buffer.SeekPut( CUtlBuffer::SEEK_CURRENT, nSizeInBytes ); return true; }
//----------------------------------------------------------------------------- // 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; }
//----------------------------------------------------------------------------- // Converts a buffer from a CRLF buffer to a CR buffer (and back) // Returns false if no conversion was necessary (and outBuf is left untouched) // If the conversion occurs, outBuf will be cleared. //----------------------------------------------------------------------------- bool CUtlBuffer::ConvertCRLF( CUtlBuffer &outBuf ) { if ( !IsText() || !outBuf.IsText() ) return false; if ( ContainsCRLF() == outBuf.ContainsCRLF() ) return false; int nInCount = TellMaxPut(); outBuf.Purge(); outBuf.EnsureCapacity( nInCount ); bool bFromCRLF = ContainsCRLF(); // Start reading from the beginning int nGet = TellGet(); int nPut = TellPut(); int nGetDelta = 0; int nPutDelta = 0; const char *pBase = (const char*)Base(); int nCurrGet = 0; while ( nCurrGet < nInCount ) { const char *pCurr = &pBase[nCurrGet]; if ( bFromCRLF ) { const char *pNext = Q_strnistr( pCurr, "\r\n", nInCount - nCurrGet ); if ( !pNext ) { outBuf.Put( pCurr, nInCount - nCurrGet ); break; } int nBytes = (size_t)pNext - (size_t)pCurr; outBuf.Put( pCurr, nBytes ); outBuf.PutChar( '\n' ); nCurrGet += nBytes + 2; if ( nGet >= nCurrGet - 1 ) { --nGetDelta; } if ( nPut >= nCurrGet - 1 ) { --nPutDelta; } } else { const char *pNext = Q_strnchr( pCurr, '\n', nInCount - nCurrGet ); if ( !pNext ) { outBuf.Put( pCurr, nInCount - nCurrGet ); break; } int nBytes = (size_t)pNext - (size_t)pCurr; outBuf.Put( pCurr, nBytes ); outBuf.PutChar( '\r' ); outBuf.PutChar( '\n' ); nCurrGet += nBytes + 1; if ( nGet >= nCurrGet ) { ++nGetDelta; } if ( nPut >= nCurrGet ) { ++nPutDelta; } } } Assert( nPut + nPutDelta <= outBuf.TellMaxPut() ); outBuf.SeekGet( SEEK_HEAD, nGet + nGetDelta ); outBuf.SeekPut( SEEK_HEAD, nPut + nPutDelta ); return true; }
void CCompileCaptionsApp::CompileCaptionFile( char const *infile, char const *outfile ) { StringIndex_t maxindex = (StringIndex_t)-1; int maxunicodesize = 0; int totalsize = 0; int c = 0; int curblock = 0; int usedBytes = 0; int blockSize = MAX_BLOCK_SIZE; int freeSpace = 0; CUtlVector< CaptionLookup_t > directory; CUtlBuffer data; CUtlRBTree< unsigned int > hashcollision( 0, 0, DefLessFunc( unsigned int ) ); for ( StringIndex_t i = g_pVGuiLocalize->GetFirstStringIndex(); i != INVALID_LOCALIZE_STRING_INDEX; i = g_pVGuiLocalize->GetNextStringIndex( i ), ++c ) { char const *entryName = g_pVGuiLocalize->GetNameByIndex( i ); CaptionLookup_t entry; entry.SetHash( entryName ); // vprint( 0, "%d / %d: %s == %u\n", c, i, g_pVGuiLocalize->GetNameByIndex( i ), entry.hash ); if ( hashcollision.Find( entry.hash ) != hashcollision.InvalidIndex() ) { Error( "Hash name collision on %s!!!\n", g_pVGuiLocalize->GetNameByIndex( i ) ); } hashcollision.Insert( entry.hash ); const wchar_t *text = g_pVGuiLocalize->GetValueByIndex( i ); if ( verbose ) { vprint( 0, "Processing: '%30.30s' = '%S'\n", entryName, text ); } int len = text ? ( wcslen( text ) + 1 ) * sizeof( short ) : 0; if ( len > maxunicodesize ) { maxindex = i; maxunicodesize = len; } if ( len > blockSize ) { Error( "Caption text file '%s' contains a single caption '%s' of %d bytes (%d is max), change MAX_BLOCK_SIZE in captioncompiler.h to fix!!!\n", g_pVGuiLocalize->GetNameByIndex( i ), entryName, len, blockSize ); } totalsize += len; if ( usedBytes + len >= blockSize ) { ++curblock; int leftover = ( blockSize - usedBytes ); totalsize += leftover; freeSpace += leftover; while ( --leftover >= 0 ) { data.PutChar( 0 ); } usedBytes = len; entry.offset = 0; data.Put( (const void *)text, len ); } else { entry.offset = usedBytes; usedBytes += len; data.Put( (const void *)text, len ); } entry.length = len; entry.blockNum = curblock; directory.AddToTail( entry ); } int leftover = ( blockSize - usedBytes ); totalsize += leftover; freeSpace += leftover; while ( --leftover >= 0 ) { data.PutChar( 0 ); } vprint( 0, "Found %i strings in '%s'\n", c, infile ); if ( maxindex != INVALID_LOCALIZE_STRING_INDEX ) { vprint( 0, "Longest string '%s' = (%i) bytes average(%.3f)\n%", g_pVGuiLocalize->GetNameByIndex( maxindex ), maxunicodesize, (float)totalsize/(float)c ); } vprint( 0, "%d blocks (%d bytes each), %d bytes wasted (%.3f per block average), total bytes %d\n", curblock + 1, blockSize, freeSpace, (float)freeSpace/(float)( curblock + 1 ), totalsize ); vprint( 0, "directory size %d entries, %d bytes, data size %d bytes\n", directory.Count(), directory.Count() * sizeof( CaptionLookup_t ), data.TellPut() ); CompiledCaptionHeader_t header; header.magic = COMPILED_CAPTION_FILEID; header.version = COMPILED_CAPTION_VERSION; header.numblocks = curblock + 1; header.blocksize = blockSize; header.directorysize = directory.Count(); header.dataoffset = 0; // Now write the outfile CUtlBuffer out; out.Put( &header, sizeof( header ) ); out.Put( directory.Base(), directory.Count() * sizeof( CaptionLookup_t ) ); int curOffset = out.TellPut(); // Round it up to the next 512 byte boundary int nBytesDestBuffer = AlignValue( curOffset, 512 ); // align to HD sector int nPadding = nBytesDestBuffer - curOffset; while ( --nPadding >= 0 ) { out.PutChar( 0 ); } out.Put( data.Base(), data.TellPut() ); // Write out a corrected header header.dataoffset = nBytesDestBuffer; int savePos = out.TellPut(); out.SeekPut( CUtlBuffer::SEEK_HEAD, 0 ); out.Put( &header, sizeof( header ) ); out.SeekPut( CUtlBuffer::SEEK_HEAD, savePos ); g_pFullFileSystem->WriteFile( outfile, NULL, out ); // Jeep: this function no longer exisits /*if ( bX360 ) { UpdateOrCreateCaptionFile_X360( g_pFullFileSystem, outfile, NULL, true ); }*/ }
bool C_ASW_Medal_Store::SaveMedalStore() { if ( !m_bLoaded ) return false; KeyValues *kv = new KeyValues( "CLIENTDAT" ); // output missions/campaigns/kills kv->SetInt("MC", m_iMissionsCompleted); kv->SetInt("CC", m_iCampaignsCompleted); kv->SetInt("AK", m_iAliensKilled); kv->SetInt("OMC", m_iOfflineMissionsCompleted); kv->SetInt("OCC", m_iOfflineCampaignsCompleted); kv->SetInt("OAK", m_iOfflineAliensKilled); kv->SetInt( "LPL", m_iXP ); kv->SetInt( "LPP", m_iPromotion ); KeyValues *pSubSection = new KeyValues("NEWEQUIP"); char buffer[64]; if (pSubSection) { for (int i=0;i<m_NewEquipment.Count();i++) { pSubSection->SetInt( "EQUIP", m_NewEquipment[i]); } kv->AddSubKey(pSubSection); } // output player medals pSubSection = new KeyValues("LP"); if (pSubSection) { for (int i=0;i<m_PlayerMedals.Count();i++) { Q_snprintf(buffer, sizeof(buffer), "M%d", i); pSubSection->SetInt(buffer, m_PlayerMedals[i]); } kv->AddSubKey(pSubSection); } for (int k=0;k<ASW_NUM_MARINE_PROFILES;k++) { Q_snprintf(buffer, sizeof(buffer), "LA%d", k); pSubSection = new KeyValues(buffer); if (pSubSection) { for (int i=0;i<m_MarineMedals[k].Count();i++) { Q_snprintf(buffer, sizeof(buffer), "M%d", i); pSubSection->SetInt(buffer, m_MarineMedals[k][i]); } kv->AddSubKey(pSubSection); } } // offline medal store pSubSection = new KeyValues("FP"); if (pSubSection) { for (int i=0;i<m_OfflinePlayerMedals.Count();i++) { Q_snprintf(buffer, sizeof(buffer), "M%d", i); pSubSection->SetInt(buffer, m_OfflinePlayerMedals[i]); } kv->AddSubKey(pSubSection); } for (int k=0;k<ASW_NUM_MARINE_PROFILES;k++) { Q_snprintf(buffer, sizeof(buffer), "FA%d", k); pSubSection = new KeyValues(buffer); if (pSubSection) { for (int i=0;i<m_OfflineMarineMedals[k].Count();i++) { Q_snprintf(buffer, sizeof(buffer), "M%d", i); pSubSection->SetInt(buffer, m_OfflineMarineMedals[k][i]); } kv->AddSubKey(pSubSection); } } CUtlBuffer buf; //( 0, 0, CUtlBuffer::TEXT_BUFFER ); kv->RecursiveSaveToFile( buf, 0 ); // pad buffer with zeroes to make a multiple of 8 int nExtra = buf.TellPut() % 8; while ( nExtra != 0 && nExtra < 8 ) { buf.PutChar( 0 ); nExtra++; } UTIL_EncodeICE( (unsigned char*) buf.Base(), buf.TellPut(), g_ucMedalStoreEncryptionKey ); ISteamUser *pSteamUser = steamapicontext ? steamapicontext->SteamUser() : NULL; if ( !pSteamUser ) return false; char szMedalFile[ 256 ]; Q_snprintf( szMedalFile, sizeof( szMedalFile ), "cfg/clientc_%I64u.dat", pSteamUser->GetSteamID().ConvertToUint64() ); int len = Q_strlen( szMedalFile ); for ( int i = 0; i < len; i++ ) { if ( szMedalFile[ i ] == ':' ) szMedalFile[i] = '_'; } bool bResult = filesystem->WriteFile( szMedalFile, "MOD", buf ); if ( bResult ) { #if defined(NO_STEAM) AssertMsg( false, "SteamCloud not available." ); #else ISteamRemoteStorage *pRemoteStorage = SteamClient() ? ( ISteamRemoteStorage * )SteamClient()->GetISteamGenericInterface( SteamAPI_GetHSteamUser(), SteamAPI_GetHSteamPipe(), STEAMREMOTESTORAGE_INTERFACE_VERSION ) : NULL; if ( asw_steam_cloud.GetBool() && pRemoteStorage ) { WriteFileToRemoteStorage( pRemoteStorage, "PersistentMarines.dat", szMedalFile ); } #endif } return bResult; }
void VMPI_DistributeLightData() { if ( !g_bUseMPI ) return; if ( g_bMPIMaster ) { const char *pVirtualFilename = "--plightdata--"; CUtlBuffer lightFaceData; // write out the light data lightFaceData.EnsureCapacity( pdlightdata->Count() + (numfaces * (MAXLIGHTMAPS+sizeof(int))) ); Q_memcpy( lightFaceData.PeekPut(), pdlightdata->Base(), pdlightdata->Count() ); lightFaceData.SeekPut( CUtlBuffer::SEEK_HEAD, pdlightdata->Count() ); // write out the relevant face info into the stream for ( int i = 0; i < numfaces; i++ ) { for ( int j = 0; j < MAXLIGHTMAPS; j++ ) { lightFaceData.PutChar(g_pFaces[i].styles[j]); } lightFaceData.PutInt(g_pFaces[i].lightofs); } VMPI_FileSystem_CreateVirtualFile( pVirtualFilename, lightFaceData.Base(), lightFaceData.TellMaxPut() ); char cPacketID[2] = { VMPI_VRAD_PACKET_ID, VMPI_SUBPACKETID_PLIGHTDATA_RESULTS }; VMPI_Send2Chunks( cPacketID, sizeof( cPacketID ), pVirtualFilename, strlen( pVirtualFilename ) + 1, VMPI_PERSISTENT ); } else { VMPI_SetCurrentStage( "VMPI_DistributeLightData" ); // Wait until we've received the filename from the master. while ( g_LightResultsFilename.Count() == 0 ) { VMPI_DispatchNextMessage(); } // Open FileHandle_t fp = g_pFileSystem->Open( g_LightResultsFilename.Base(), "rb", VMPI_VIRTUAL_FILES_PATH_ID ); if ( !fp ) Error( "Can't open '%s' to read lighting info.", g_LightResultsFilename.Base() ); int size = g_pFileSystem->Size( fp ); int faceSize = (numfaces*(MAXLIGHTMAPS+sizeof(int))); if ( size > faceSize ) { int lightSize = size - faceSize; CUtlBuffer faceData; pdlightdata->EnsureCount( lightSize ); faceData.EnsureCapacity( faceSize ); g_pFileSystem->Read( pdlightdata->Base(), lightSize, fp ); g_pFileSystem->Read( faceData.Base(), faceSize, fp ); g_pFileSystem->Close( fp ); faceData.SeekPut( CUtlBuffer::SEEK_HEAD, faceSize ); // write out the face data for ( int i = 0; i < numfaces; i++ ) { for ( int j = 0; j < MAXLIGHTMAPS; j++ ) { g_pFaces[i].styles[j] = faceData.GetChar(); } g_pFaces[i].lightofs = faceData.GetInt(); } } } }