//----------------------------------------------------------------------------- // Make a temporary filename //----------------------------------------------------------------------------- char *CScriptLib::MakeTemporaryFilename( char const *pchModPath, char *pPath, int pathSize ) { char *pBuffer = _tempnam( pchModPath, "mgd_" ); if ( pBuffer[0] == '\\' ) { pBuffer++; } if ( pBuffer[strlen( pBuffer )-1] == '.' ) { pBuffer[strlen( pBuffer )-1] = '\0'; } V_snprintf( pPath, pathSize, "%s.tmp", pBuffer ); free( pBuffer ); return pPath; }
bool SaveItem(specialitemload_t const &item) { unsigned long long profileid = item.steamid.ConvertToUint64(); item.itemmutex->Lock(); unsigned int index = item.itemlist->Find(profileid); if(item.itemlist->IsValidIndex(index)) { char query[1024]; char petname[512]; CUtlVector<CSpecialItem *> *items = item.itemlist->Element(index); item.itemmutex->Unlock(); //Msg("[ITEMDBG] Saving/deleting old item list.\n"); for(int i = 0; i < items->Count(); i++) { //Msg("[ITEMDBG] - Saving/deleting item %i\n", i); item.itemmutex->Lock(); CSpecialItem *olditem = items->Element(i); m_SQL->EscapeString(petname, olditem->m_szPetName, strlen(olditem->m_szPetName)); V_snprintf(query, sizeof(query), "UPDATE `specialitems` SET `petname` = '%s', `equipped` = %i WHERE `id` = %i LIMIT 1", petname, olditem->m_bEquipped, olditem->m_iIndex); item.itemmutex->Unlock(); //Msg("[ITEMDBG] %s\n", query); m_SQL->Query(query); delete olditem->m_pItem; delete olditem; } item.itemmutex->Lock(); item.itemlist->RemoveAt(index); item.itemmutex->Unlock(); delete items; } else { item.itemmutex->Unlock(); } return true; }
//----------------------------------------------------------------------------- // BugDlg_UploadBugSubmission // // Expects fully qualified source paths //----------------------------------------------------------------------------- bool BugDlg_UploadBugSubmission( int bugID, char const *pSavefile, char const *pScreenshot, char const *pBspFile, char const *pVmfFile ) { char szFilename[MAX_PATH]; char szLocalfile[MAX_PATH]; char szRemotefile[MAX_PATH]; bool bSuccess = true; if ( pSavefile && pSavefile[0] ) { V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pSavefile ); Sys_StripPath( pSavefile, szFilename, sizeof( szFilename ) ); V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename ); Sys_NormalizePath( szLocalfile, false ); Sys_NormalizePath( szRemotefile, false ); if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, false ) ) { bSuccess = false; } } if ( pScreenshot && pScreenshot[0] ) { V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pScreenshot ); Sys_StripPath( pScreenshot, szFilename, sizeof( szFilename ) ); V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename ); Sys_NormalizePath( szLocalfile, false ); Sys_NormalizePath( szRemotefile, false ); if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, true ) ) { bSuccess = false; } } if ( pBspFile && pBspFile[0] ) { V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pBspFile ); Sys_StripPath( pBspFile, szFilename, sizeof( szFilename ) ); V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename ); Sys_NormalizePath( szLocalfile, false ); Sys_NormalizePath( szRemotefile, false ); if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, true ) ) { bSuccess = false; } } return bSuccess; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- boost::python::object PyFS_ReadFile( const char *filepath, const char *pathid, bool optimalalloc, int maxbytes, int startingbyte, bool textmode ) { if( !filepath ) { PyErr_SetString(PyExc_IOError, "No filepath specified" ); throw boost::python::error_already_set(); } if( !SrcPyPathIsInGameFolder( filepath ) ) { PyErr_SetString(PyExc_IOError, "filesystem module only allows paths in the game folder" ); throw boost::python::error_already_set(); } if( !filesystem->FileExists( filepath, pathid ) ) { PyErr_SetString(PyExc_IOError, "File does not exists" ); throw boost::python::error_already_set(); } int iExpectedSize = maxbytes == 0 ? filesystem->Size( filepath, pathid ) : maxbytes - 1; void *buffer = NULL; int len = filesystem->ReadFileEx( filepath, pathid, &buffer, true, optimalalloc, maxbytes, startingbyte ); if( len != iExpectedSize ) { char buf[256]; V_snprintf( buf, sizeof( buf ), "Failed to read file. Expected file size %d, got %d instead", iExpectedSize, len ); PyErr_SetString( PyExc_IOError, buf ); throw boost::python::error_already_set(); } boost::python::object content( boost::python::handle<>( PyBytes_FromStringAndSize( (const char *)buffer, (Py_ssize_t)len ) ) ); if( textmode ) content = content.attr("decode")("utf-8"); // TODO: improve. Look at how Python "wt" mode handles text if( optimalalloc ) filesystem->FreeOptimalReadBuffer( buffer ); else free( buffer ); buffer = NULL; return content; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- boost::python::list PyFS_ListDir( const char *pPath, const char *pPathID, const char *pWildCard ) { if( !pPath || !pWildCard ) return boost::python::list(); const char *pFileName; char wildcard[MAX_PATH]; FileFindHandle_t fh; boost::python::list result; // TODO: Do we need to add a slash in case there is no slash? V_snprintf(wildcard, MAX_PATH, "%s%s", pPath, pWildCard); pFileName = filesystem->FindFirstEx( wildcard, pPathID, &fh ); while( pFileName ) { result.append( boost::python::object( pFileName ) ); pFileName = filesystem->FindNext( fh ); } filesystem->FindClose( fh ); return result; }
void CEventLog::FormatPlayer( CBaseEntity *ent, char *str, int len ) const { if ( !str || len <= 0 ) { return; } CBasePlayer *player = ToBasePlayer( ent ); const char *playerName = "Unknown"; int userID = 0; const char *networkIDString = ""; const char *teamName = ""; int areaID = 0; if ( player ) { playerName = player->GetPlayerName(); userID = player->GetUserID(); networkIDString = player->GetNetworkIDString(); CTeam *team = player->GetTeam(); if ( team ) { teamName = team->GetName(); } } #ifdef USE_NAV_MESH if ( ent && ent->MyCombatCharacterPointer() ) { CNavArea *area = ent->MyCombatCharacterPointer()->GetLastKnownArea(); if ( area ) { areaID = area->GetID(); } } #endif // USE_NAV_MESH V_snprintf( str, len, "\"%s<%i><%s><%s><Area %d>\"", playerName, userID, networkIDString, teamName, areaID ); }
void CASW_Briefing::SelectMarine( int nOrder, int nProfileIndex, int nPreferredLobbySlot ) { // for now, just select him C_ASW_Player *pPlayer = C_ASW_Player::GetLocalASWPlayer(); if ( !pPlayer ) return; if ( IsOfflineGame() ) { pPlayer->RosterSelectMarineForSlot( nProfileIndex, nPreferredLobbySlot ); } else { pPlayer->RosterSelectSingleMarine( nProfileIndex ); } if ( gpGlobals->curtime - m_flLastSelectionChatterTime < 1.0f ) return; CASW_Marine_Profile *pProfile = Briefing()->GetMarineProfileByProfileIndex( nProfileIndex ); if ( pProfile ) { char szSelectionSound[ CHATTER_STRING_SIZE ]; V_snprintf( szSelectionSound, sizeof( szSelectionSound ), "%s%d", pProfile->m_Chatter[ CHATTER_SELECTION ], RandomInt( 0, pProfile->m_iChatterCount[ CHATTER_SELECTION ] - 1 ) ); CSoundParameters params; if ( C_BaseEntity::GetParametersForSound( szSelectionSound, params, NULL ) ) { EmitSound_t playparams( params ); playparams.m_nChannel = CHAN_STATIC; playparams.m_bEmitCloseCaption = false; CLocalPlayerFilter filter; C_BaseEntity::EmitSound( filter, -1, playparams ); m_flLastSelectionChatterTime = gpGlobals->curtime; } } }
//----------------------------------------------------------------------------- // Purpose: Strip off the last directory from dirName // Input : *dirName - // maxlen - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool V_StripLastDir( char *dirName, int maxlen ) { if( dirName[0] == 0 || !V_stricmp( dirName, "./" ) || !V_stricmp( dirName, ".\\" ) ) return false; int len = V_strlen( dirName ); Assert( len < maxlen ); // skip trailing slash if ( PATHSEPARATOR( dirName[len-1] ) ) { len--; } while ( len > 0 ) { if ( PATHSEPARATOR( dirName[len-1] ) ) { dirName[len] = 0; V_FixSlashes( dirName, CORRECT_PATH_SEPARATOR ); return true; } len--; } // Allow it to return an empty string and true. This can happen if something like "tf2/" is passed in. // The correct behavior is to strip off the last directory ("tf2") and return true. if( len == 0 ) { V_snprintf( dirName, maxlen, ".%c", CORRECT_PATH_SEPARATOR ); return true; } return true; }
void SendPatchCommandToUIs( DWORD dwInstallerProcessId ) { Msg( "SendPatchCommandToUIs\n "); CUtlVector<char> data; data.AddToTail( VMPI_SERVICE_UI_PROTOCOL_VERSION ); data.AddToTail( VMPI_SERVICE_TO_UI_PATCHING ); // This arg tells the UI whether to exit after running the command or not. data.AddToTail( 1 ); // First argument is the working directory, which is the cache path in this case. data.AddMultipleToTail( V_strlen( g_FileCachePath ) + 1, g_FileCachePath ); // Second argument is the command line. char waitAndRestartExe[MAX_PATH], serviceUIExe[MAX_PATH], commandLine[1024 * 8]; V_ComposeFileName( g_FileCachePath, "WaitAndRestart.exe", waitAndRestartExe, sizeof( waitAndRestartExe ) ); V_ComposeFileName( g_BaseAppPath, "vmpi_service_ui.exe", serviceUIExe, sizeof( serviceUIExe ) ); // We're running the UI from the same directory this exe is in. char strSeconds[64]; V_snprintf( strSeconds, sizeof( strSeconds ), "*%lu", dwInstallerProcessId ); // IMPORTANT to use BuildCommandLineFromArgs here because it'll handle slashes and quotes correctly. // If we don't do that, the command often won't work. CUtlVector<char*> args; args.AddToTail( waitAndRestartExe ); args.AddToTail( strSeconds ); args.AddToTail( g_BaseAppPath ); args.AddToTail( serviceUIExe ); BuildCommandLineFromArgs( args, commandLine, sizeof( commandLine ) ); data.AddMultipleToTail( V_strlen( commandLine ) + 1, commandLine ); if ( g_pConnMgr ) { g_pConnMgr->SendPacket( -1, data.Base(), data.Count() ); Sleep( 1000 ); // Make sure this packet goes out. } }
static HANDLE CreateTempFile( CUtlString &WritePath, CUtlString &FileName ) { char tempFileName[MAX_PATH]; if ( WritePath.IsEmpty() ) { // use a safe name in the cwd char *pBuffer = tmpnam( NULL ); if ( !pBuffer ) { return INVALID_HANDLE_VALUE; } if ( pBuffer[0] == '\\' ) { pBuffer++; } if ( pBuffer[strlen( pBuffer )-1] == '.' ) { pBuffer[strlen( pBuffer )-1] = '\0'; } V_snprintf( tempFileName, sizeof( tempFileName ), "_%s.tmp", pBuffer ); } else { // generate safe name at the desired prefix char uniqueFilename[MAX_PATH]; SYSTEMTIME sysTime; \ GetLocalTime( &sysTime ); sprintf( uniqueFilename, "%d_%d_%d_%d_%d.tmp", sysTime.wDay, sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds ); \ V_ComposeFileName( WritePath.String(), uniqueFilename, tempFileName, sizeof( tempFileName ) ); } FileName = tempFileName; HANDLE hFile = CreateFile( tempFileName, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); return hFile; }
static HANDLE CreateTempFile( CUtlString &WritePath, CUtlString &FileName ) { char tempFileName[MAX_PATH]; if ( WritePath.IsEmpty() ) { // use a safe name in the cwd char *pBuffer = tmpnam( NULL ); if ( !pBuffer ) { return INVALID_HANDLE_VALUE; } if ( pBuffer[0] == '\\' ) { pBuffer++; } if ( pBuffer[strlen( pBuffer )-1] == '.' ) { pBuffer[strlen( pBuffer )-1] = '\0'; } V_snprintf( tempFileName, sizeof( tempFileName ), "_%s.tmp", pBuffer ); } else { char uniqueFilename[MAX_PATH]; static int counter = 0; time_t now = time( NULL ); struct tm *tm = localtime( &now ); sprintf( uniqueFilename, "%d_%d_%d_%d_%d.tmp", tm->tm_wday, tm->tm_hour, tm->tm_min, tm->tm_sec, ++counter ); \ V_ComposeFileName( WritePath.String(), uniqueFilename, tempFileName, sizeof( tempFileName ) ); } FileName = tempFileName; FILE *hFile = fopen( tempFileName, "rw+" ); return (HANDLE)hFile; }
bool CommandMenu::LoadFromKeyValues( KeyValues * params ) { if ( !params ) return false; V_snprintf( m_CurrentTeam, 4, "%i", GetLocalPlayerTeam() ); V_FileBase( engine->GetLevelName(), m_CurrentMap, sizeof(m_CurrentMap) ); if ( params != m_MenuKeys ) { if ( m_MenuKeys ) m_MenuKeys->deleteThis(); m_MenuKeys = params->MakeCopy(); // save keyvalues } // iterate through all menu items KeyValues * subkey = m_MenuKeys->GetFirstSubKey(); while ( subkey ) { if ( subkey->GetDataType() == KeyValues::TYPE_NONE ) { if ( !LoadFromKeyValuesInternal( subkey, 0 ) ) // recursive call return false; } subkey = subkey->GetNextKey(); } UpdateMenu(); return true; }
FSReturnCode_t FileSystem_LoadSearchPaths( CFSSearchPathsInit &initInfo ) { if ( !initInfo.m_pFileSystem || !initInfo.m_pDirectoryName ) return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_LoadSearchPaths: Invalid parameters specified." ); KeyValues *pMainFile, *pFileSystemInfo, *pSearchPaths; FSReturnCode_t retVal = LoadGameInfoFile( initInfo.m_pDirectoryName, pMainFile, pFileSystemInfo, pSearchPaths ); if ( retVal != FS_OK ) return retVal; // All paths except those marked with |gameinfo_path| are relative to the base dir. char baseDir[MAX_PATH]; if ( !FileSystem_GetBaseDir( baseDir, sizeof( baseDir ) ) ) return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetBaseDir failed." ); initInfo.m_ModPath[0] = 0; #define GAMEINFOPATH_TOKEN "|gameinfo_path|" #define BASESOURCEPATHS_TOKEN "|all_source_engine_paths|" bool bLowViolence = IsLowViolenceBuild(); bool bFirstGamePath = true; for ( KeyValues *pCur=pSearchPaths->GetFirstValue(); pCur; pCur=pCur->GetNextValue() ) { const char *pPathID = pCur->GetName(); const char *pLocation = pCur->GetString(); if ( Q_stristr( pLocation, GAMEINFOPATH_TOKEN ) == pLocation ) { pLocation += strlen( GAMEINFOPATH_TOKEN ); FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, initInfo.m_pDirectoryName, pLocation, bLowViolence ); } else if ( Q_stristr( pLocation, BASESOURCEPATHS_TOKEN ) == pLocation ) { // This is a special identifier that tells it to add the specified path for all source engine versions equal to or prior to this version. // So in Orange Box, if they specified: // |all_source_engine_paths|hl2 // it would add the ep2\hl2 folder and the base (ep1-era) hl2 folder. // // We need a special identifier in the gameinfo.txt here because the base hl2 folder exists in different places. // In the case of a game or a Steam-launched dedicated server, all the necessary prior engine content is mapped in with the Steam depots, // so we can just use the path as-is. // In the case of an hldsupdatetool dedicated server, the base hl2 folder is "..\..\hl2" (since we're up in the 'orangebox' folder). pLocation += strlen( BASESOURCEPATHS_TOKEN ); // Add the Orange-box path (which also will include whatever the depots mapped in as well if we're // running a Steam-launched app). FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, baseDir, pLocation, bLowViolence ); if ( FileSystem_IsHldsUpdateToolDedicatedServer() ) { // If we're using the hldsupdatetool dedicated server, then go up a directory to get the ep1-era files too. char ep1EraPath[MAX_PATH]; V_snprintf( ep1EraPath, sizeof( ep1EraPath ), "..%c%s", CORRECT_PATH_SEPARATOR, pLocation ); FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, baseDir, ep1EraPath, bLowViolence ); } } else { FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, baseDir, pLocation, bLowViolence ); } } pMainFile->deleteThis(); // // Set up search paths for add-ons // if ( IsPC() ) { #ifdef ENGINE_DLL FileSystem_UpdateAddonSearchPaths( initInfo.m_pFileSystem ); #endif } // these specialized tool paths are not used on 360 and cause a costly constant perf tax, so inhibited if ( IsPC() ) { // Create a content search path based on the game search path const char *pGameRoot = getenv( GAMEROOT_TOKEN ); const char *pContentRoot = getenv( CONTENTROOT_TOKEN ); if ( pGameRoot && pContentRoot ) { int nLen = initInfo.m_pFileSystem->GetSearchPath( "GAME", false, NULL, 0 ); char *pSearchPath = (char*)stackalloc( nLen * sizeof(char) ); initInfo.m_pFileSystem->GetSearchPath( "GAME", false, pSearchPath, nLen ); char *pPath = pSearchPath; while( pPath ) { char *pSemiColon = strchr( pPath, ';' ); if ( pSemiColon ) { *pSemiColon = 0; } Q_StripTrailingSlash( pPath ); Q_FixSlashes( pPath ); const char *pCurPath = pPath; pPath = pSemiColon ? pSemiColon + 1 : NULL; char pRelativePath[MAX_PATH]; char pContentPath[MAX_PATH]; if ( !Q_MakeRelativePath( pCurPath, pGameRoot, pRelativePath, sizeof(pRelativePath) ) ) continue; Q_ComposeFileName( pContentRoot, pRelativePath, pContentPath, sizeof(pContentPath) ); initInfo.m_pFileSystem->AddSearchPath( pContentPath, "CONTENT" ); } // Add the "platform" directory as a game searchable path char pPlatformPath[MAX_PATH]; Q_ComposeFileName( pGameRoot, "platform", pPlatformPath, sizeof(pPlatformPath) ); initInfo.m_pFileSystem->AddSearchPath( pPlatformPath, "GAME", PATH_ADD_TO_TAIL ); initInfo.m_pFileSystem->AddSearchPath( pContentRoot, "CONTENTROOT" ); initInfo.m_pFileSystem->AddSearchPath( pGameRoot, "GAMEROOT" ); } else { // Come up with some reasonable default int nLen = initInfo.m_pFileSystem->GetSearchPath( "MOD", false, NULL, 0 ); char *pSearchPath = (char*)stackalloc( nLen * sizeof(char) ); initInfo.m_pFileSystem->GetSearchPath( "MOD", false, pSearchPath, nLen ); char *pSemiColon = strchr( pSearchPath, ';' ); if ( pSemiColon ) { *pSemiColon = 0; } char pGameRootPath[MAX_PATH]; Q_strncpy( pGameRootPath, pSearchPath, sizeof(pGameRootPath) ); Q_StripTrailingSlash( pGameRootPath ); Q_StripFilename( pGameRootPath ); char pContentRootPath[MAX_PATH]; Q_strncpy( pContentRootPath, pGameRootPath, sizeof(pContentRootPath) ); char *pGame = Q_stristr( pContentRootPath, "game" ); if ( pGame ) { Q_strcpy( pGame, "content" ); } initInfo.m_pFileSystem->AddSearchPath( pContentRootPath, "CONTENTROOT" ); initInfo.m_pFileSystem->AddSearchPath( pGameRootPath, "GAMEROOT" ); } // Also, mark specific path IDs as "by request only". That way, we won't waste time searching in them // when people forget to specify a search path. initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "contentroot", true ); initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "gameroot", true ); initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "content", true ); } // Also, mark specific path IDs as "by request only". That way, we won't waste time searching in them // when people forget to specify a search path. initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "executable_path", true ); initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "gamebin", true ); initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "mod", true ); // Add the write path last. if ( initInfo.m_ModPath[0] != 0 ) { initInfo.m_pFileSystem->AddSearchPath( initInfo.m_ModPath, "DEFAULT_WRITE_PATH", PATH_ADD_TO_TAIL ); } #ifdef _DEBUG initInfo.m_pFileSystem->PrintSearchPaths(); #endif #if defined( ENABLE_RUNTIME_STACK_TRANSLATION ) && !defined( _X360 ) //copy search paths to stack tools so it can grab pdb's from all over. But only on P4 or Steam Beta builds if( (CommandLine()->FindParm( "-steam" ) == 0) || //not steam (CommandLine()->FindParm( "-internalbuild" ) != 0) ) //steam beta is ok { char szSearchPaths[4096]; //int CBaseFileSystem::GetSearchPath( const char *pathID, bool bGetPackFiles, char *pPath, int nMaxLen ) int iLength1 = initInfo.m_pFileSystem->GetSearchPath( "EXECUTABLE_PATH", false, szSearchPaths, 4096 ); if( iLength1 == 1 ) iLength1 = 0; int iLength2 = initInfo.m_pFileSystem->GetSearchPath( "GAMEBIN", false, szSearchPaths + iLength1, 4096 - iLength1 ); if( (iLength2 > 1) && (iLength1 > 1) ) { szSearchPaths[iLength1 - 1] = ';'; //replace first null terminator } const char *szAdditionalPath = CommandLine()->ParmValue( "-AdditionalPDBSearchPath" ); if( szAdditionalPath && szAdditionalPath[0] ) { int iLength = iLength1; if( iLength2 > 1 ) iLength += iLength2; if( iLength != 0 ) { szSearchPaths[iLength - 1] = ';'; //replaces null terminator } V_strncpy( &szSearchPaths[iLength], szAdditionalPath, 4096 - iLength ); } //Append the perforce symbol server last. Documentation says that "srv*\\perforce\symbols" should work, but it doesn't. //"symsrv*symsrv.dll*\\perforce\symbols" which the docs say is the same statement, works. { V_strncat( szSearchPaths, ";symsrv*symsrv.dll*\\\\perforce\\symbols", 4096 ); } SetStackTranslationSymbolSearchPath( szSearchPaths ); //MessageBox( NULL, szSearchPaths, "Search Paths", 0 ); } #endif return FS_OK; }
// glUseProgram() will be called as a side effect! bool CGLMShaderPair::SetProgramPair( CGLMProgram *vp, CGLMProgram *fp ) { m_valid = false; // assume failure // true result means successful link and query bool vpgood = (vp!=NULL) && (vp->m_descs[ kGLMGLSL ].m_valid); bool fpgood = (fp!=NULL) && (fp->m_descs[ kGLMGLSL ].m_valid); if ( !fpgood ) { // fragment side allowed to be "null". fp = m_ctx->m_pNullFragmentProgram; } if ( vpgood && fpgood ) { if ( vp->m_nCentroidMask != fp->m_nCentroidMask ) { Warning( "CGLMShaderPair::SetProgramPair: Centroid masks differ at link time of vertex shader %s and pixel shader %s!\n", vp->m_shaderName, fp->m_shaderName ); } // attempt link. but first, detach any previously attached programs if (m_vertexProg) { gGL->glDetachObjectARB(m_program, m_vertexProg->m_descs[kGLMGLSL].m_object.glsl); m_vertexProg = NULL; } if (m_fragmentProg) { gGL->glDetachObjectARB(m_program, m_fragmentProg->m_descs[kGLMGLSL].m_object.glsl); m_fragmentProg = NULL; } // now attach gGL->glAttachObjectARB( m_program, vp->m_descs[kGLMGLSL].m_object.glsl ); m_vertexProg = vp; gGL->glAttachObjectARB( m_program, fp->m_descs[kGLMGLSL].m_object.glsl ); m_fragmentProg = fp; // force the locations for input attributes v0-vN to be at locations 0-N // use the vertex attrib map to know which slots are live or not... oy! we don't have that map yet... but it's OK. // fallback - just force v0-v15 to land in locations 0-15 as a standard. if ( vp->m_descs[kGLMGLSL].m_valid ) { for( int i = 0; i < 16; i++ ) { char tmp[16]; sprintf(tmp, "v%d", i); // v0 v1 v2 ... et al gGL->glBindAttribLocationARB( m_program, i, tmp ); } } if (CommandLine()->CheckParm("-dumpallshaders")) { // Dump all shaders, for debugging. FILE* pFile = fopen("shaderdump.txt", "a+"); if (pFile) { fprintf(pFile, "--------------VP:%s\n%s\n", vp->m_shaderName, vp->m_text); fprintf(pFile, "--------------FP:%s\n%s\n", fp->m_shaderName, fp->m_text); fclose(pFile); } } // now link gGL->glLinkProgramARB( m_program ); // check for success GLint result = 0; gGL->glGetObjectParameterivARB(m_program,GL_OBJECT_LINK_STATUS_ARB,&result); // want GL_TRUE if (result == GL_TRUE) { // success m_valid = true; m_revision++; } else { GLint length = 0; GLint laux = 0; // do some digging gGL->glGetObjectParameterivARB(m_program,GL_OBJECT_INFO_LOG_LENGTH_ARB,&length); GLcharARB *logString = (GLcharARB *)malloc(length * sizeof(GLcharARB)); gGL->glGetInfoLogARB(m_program, length, &laux, logString); char *vtemp = strdup(vp->m_text); vtemp[ vp->m_descs[kGLMGLSL].m_textOffset + vp->m_descs[kGLMGLSL].m_textLength ] = 0; char *ftemp = strdup(fp->m_text); ftemp[ fp->m_descs[kGLMGLSL].m_textOffset + fp->m_descs[kGLMGLSL].m_textLength ] = 0; GLMPRINTF(("-D- ----- GLSL link failed: \n %s ",logString )); GLMPRINTF(("-D- ----- GLSL vertex program selected: %08x (handle %08x)", vp, vp->m_descs[kGLMGLSL].m_object.glsl )); GLMPRINTTEXT(( vtemp + vp->m_descs[kGLMGLSL].m_textOffset, eDebugDump, GLMPRINTTEXT_NUMBEREDLINES )); GLMPRINTF(("-D- ----- GLSL fragment program selected: %08x (handle %08x)", fp, vp->m_descs[kGLMGLSL].m_object.glsl )); GLMPRINTTEXT(( ftemp + fp->m_descs[kGLMGLSL].m_textOffset, eDebugDump, GLMPRINTTEXT_NUMBEREDLINES )); GLMPRINTF(("-D- -----end-----" )); free( ftemp ); free( vtemp ); free( logString ); } } else { // fail Assert(!"Can't link these programs"); } if (m_valid) { gGL->glUseProgram( m_program ); m_ctx->NewLinkedProgram(); m_locVertexParams = gGL->glGetUniformLocationARB( m_program, "vc"); m_locVertexBoneParams = gGL->glGetUniformLocationARB( m_program, "vcbones"); m_locVertexScreenParams = gGL->glGetUniformLocationARB( m_program, "vcscreen"); m_nScreenWidthHeight = 0xFFFFFFFF; m_locVertexInteger0 = gGL->glGetUniformLocationARB( m_program, "i0"); m_bHasBoolOrIntUniforms = false; if ( m_locVertexInteger0 >= 0 ) m_bHasBoolOrIntUniforms = true; for ( uint i = 0; i < cMaxVertexShaderBoolUniforms; i++ ) { char buf[256]; V_snprintf( buf, sizeof(buf), "b%d", i ); m_locVertexBool[i] = gGL->glGetUniformLocationARB( m_program, buf ); if ( m_locVertexBool[i] != - 1 ) m_bHasBoolOrIntUniforms = true; } for ( uint i = 0; i < cMaxFragmentShaderBoolUniforms; i++ ) { char buf[256]; V_snprintf( buf, sizeof(buf), "fb%d", i ); m_locFragmentBool[i] = gGL->glGetUniformLocationARB( m_program, buf ); if ( m_locFragmentBool[i] != - 1 ) m_bHasBoolOrIntUniforms = true; } m_locFragmentParams = gGL->glGetUniformLocationARB( m_program, "pc"); for (uint i = 0; i < kGLMNumProgramTypes; i++) { m_NumUniformBufferParams[i] = 0; if (i == kGLMVertexProgram) { if (m_locVertexParams < 0) continue; } else if (m_locFragmentParams < 0) continue; const uint nNum = (i == kGLMVertexProgram) ? m_vertexProg->m_descs[kGLMGLSL].m_highWater : m_fragmentProg->m_descs[kGLMGLSL].m_highWater; uint j; for (j = 0; j < nNum; j++) { char buf[256]; V_snprintf(buf, sizeof(buf), "%cc[%i]", "vp"[i], j); // Grab the handle of each array element, so we can more efficiently update array elements in the middle. int l = m_UniformBufferParams[i][j] = gGL->glGetUniformLocationARB( m_program, buf ); if ( l < 0 ) break; } m_NumUniformBufferParams[i] = j; } m_locFragmentFakeSRGBEnable = gGL->glGetUniformLocationARB( m_program, "flSRGBWrite"); m_fakeSRGBEnableValue = -1.0f; for( int sampler=0; sampler<16; sampler++) { char tmp[16]; sprintf(tmp, "sampler%d", sampler); // sampler0 .. sampler1.. etc GLint nLoc = gGL->glGetUniformLocationARB( m_program, tmp ); m_locSamplers[sampler] = nLoc; if ( nLoc >= 0 ) { gGL->glUniform1iARB( nLoc, sampler ); } } } else { m_locVertexParams = -1; m_locVertexBoneParams = -1; m_locVertexScreenParams = -1; m_nScreenWidthHeight = 0xFFFFFFFF; m_locVertexInteger0 = -1; memset( m_locVertexBool, 0xFF, sizeof( m_locVertexBool ) ); memset( m_locFragmentBool, 0xFF, sizeof( m_locFragmentBool ) ); m_bHasBoolOrIntUniforms = false; m_locFragmentParams = -1; m_locFragmentFakeSRGBEnable = -1; m_fakeSRGBEnableValue = -999; memset( m_locSamplers, 0xFF, sizeof( m_locSamplers ) ); m_revision = 0; } return m_valid; }
FSReturnCode_t FileSystem_LoadSearchPaths( CFSSearchPathsInit &initInfo ) { if ( !initInfo.m_pFileSystem || !initInfo.m_pDirectoryName ) return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_LoadSearchPaths: Invalid parameters specified." ); KeyValues *pMainFile, *pFileSystemInfo, *pSearchPaths; FSReturnCode_t retVal = LoadGameInfoFile( initInfo.m_pDirectoryName, pMainFile, pFileSystemInfo, pSearchPaths ); if ( retVal != FS_OK ) return retVal; // All paths except those marked with |gameinfo_path| are relative to the base dir. char baseDir[MAX_PATH]; if ( !FileSystem_GetBaseDir( baseDir, sizeof( baseDir ) ) ) return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetBaseDir failed." ); initInfo.m_ModPath[0] = 0; #define GAMEINFOPATH_TOKEN "|gameinfo_path|" #define BASESOURCEPATHS_TOKEN "|all_source_engine_paths|" bool bLowViolence = IsLowViolenceBuild(); bool bFirstGamePath = true; for ( KeyValues *pCur=pSearchPaths->GetFirstValue(); pCur; pCur=pCur->GetNextValue() ) { const char *pPathID = pCur->GetName(); const char *pLocation = pCur->GetString(); if ( Q_stristr( pLocation, GAMEINFOPATH_TOKEN ) == pLocation ) { pLocation += strlen( GAMEINFOPATH_TOKEN ); FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, initInfo.m_pDirectoryName, pLocation, bLowViolence ); } else if ( Q_stristr( pLocation, BASESOURCEPATHS_TOKEN ) == pLocation ) { // This is a special identifier that tells it to add the specified path for all source engine versions equal to or prior to this version. // So in Orange Box, if they specified: // |all_source_engine_paths|hl2 // it would add the ep2\hl2 folder and the base (ep1-era) hl2 folder. // // We need a special identifier in the gameinfo.txt here because the base hl2 folder exists in different places. // In the case of a game or a Steam-launched dedicated server, all the necessary prior engine content is mapped in with the Steam depots, // so we can just use the path as-is. // In the case of an hldsupdatetool dedicated server, the base hl2 folder is "..\..\hl2" (since we're up in the 'orangebox' folder). pLocation += strlen( BASESOURCEPATHS_TOKEN ); // Add the Orange-box path (which also will include whatever the depots mapped in as well if we're // running a Steam-launched app). FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, baseDir, pLocation, bLowViolence ); if ( FileSystem_IsHldsUpdateToolDedicatedServer() ) { // If we're using the hldsupdatetool dedicated server, then go up a directory to get the ep1-era files too. char ep1EraPath[MAX_PATH]; V_snprintf( ep1EraPath, sizeof( ep1EraPath ), "..%c%s", CORRECT_PATH_SEPARATOR, pLocation ); FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, baseDir, ep1EraPath, bLowViolence ); } } else { FileSystem_AddLoadedSearchPath( initInfo, pPathID, &bFirstGamePath, baseDir, pLocation, bLowViolence ); } } pMainFile->deleteThis(); // Also, mark specific path IDs as "by request only". That way, we won't waste time searching in them // when people forget to specify a search path. initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "executable_path", true ); initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "gamebin", true ); initInfo.m_pFileSystem->MarkPathIDByRequestOnly( "mod", true ); if ( initInfo.m_ModPath[0] != 0 ) { // Add the write path last. initInfo.m_pFileSystem->AddSearchPath( initInfo.m_ModPath, "DEFAULT_WRITE_PATH", PATH_ADD_TO_TAIL ); } #ifdef _DEBUG initInfo.m_pFileSystem->PrintSearchPaths(); #endif return FS_OK; }
void CNB_Skill_Panel::OnThink() { BaseClass::OnThink(); if ( !MarineSkills() || !Briefing() ) return; CASW_Marine_Profile *pProfile = Briefing()->GetMarineProfileByProfileIndex( m_nProfileIndex ); if ( !pProfile ) return; int nMaxSkillPoints = MarineSkills()->GetMaxSkillPoints( pProfile->GetSkillMapping( m_nSkillSlot ) ); const char *szImageName = MarineSkills()->GetSkillImage( pProfile->GetSkillMapping( m_nSkillSlot ) ); if ( V_strcmp( m_szLastSkillImage, szImageName ) ) { V_snprintf( m_szLastSkillImage, sizeof( m_szLastSkillImage ), "%s", szImageName ); char buffer[ 256 ]; V_snprintf( buffer, sizeof( buffer ), "vgui/%s", szImageName ); color32 white; white.r = 255; white.g = 255; white.b = 255; white.a = 255; color32 dull; dull.r = 192; dull.g = 192; dull.b = 192; dull.a = 255; m_pSkillButton->SetImage( CBitmapButton::BUTTON_ENABLED, buffer, white ); m_pSkillButton->SetImage( CBitmapButton::BUTTON_DISABLED, buffer, dull ); m_pSkillButton->SetImage( CBitmapButton::BUTTON_PRESSED, buffer, white ); V_snprintf( buffer, sizeof( buffer ), "vgui/%s_over", szImageName ); m_pSkillButton->SetImage( CBitmapButton::BUTTON_ENABLED_MOUSE_OVER, buffer, white ); } m_pSkillButton->SetEnabled( m_bSpendPointsMode && CanSpendPoint() ); m_pSkillLabel->SetText( MarineSkills()->GetSkillName( pProfile->GetSkillMapping( m_nSkillSlot ) ) ); wchar_t wszPointsBuffer[ 24 ]; _snwprintf( wszPointsBuffer, sizeof( wszPointsBuffer ), L"%d / %d", m_nSkillPoints, nMaxSkillPoints ); m_pSkillNumberLabel->SetText( wszPointsBuffer ); m_pSkillBar->ClearMinMax(); m_pSkillBar->AddMinMax( 0, nMaxSkillPoints ); m_pSkillBar->Init( m_nSkillPoints, m_nSkillPoints, 0.1f, true, false ); if ( IsCursorOver() ) { if (!g_hBriefingTooltip.Get()) { g_hBriefingTooltip = new BriefingTooltip(GetParent(), "MedalsTooltip"); } else if ( g_hBriefingTooltip->GetParent() != GetParent() ) { g_hBriefingTooltip->SetParent( GetParent() ); } if ( g_hBriefingTooltip.Get() && IsFullyVisible() && g_hBriefingTooltip.Get()->GetTooltipPanel() != this ) { int tx, ty, w, h; tx = ty = 0; LocalToScreen(tx, ty); GetSize(w, h); tx += w * 0.5f; ty -= h * 0.01f; g_hBriefingTooltip.Get()->SetTooltip( this, MarineSkills()->GetSkillName( pProfile->GetSkillMapping( m_nSkillSlot ) ), MarineSkills()->GetSkillDescription( pProfile->GetSkillMapping( m_nSkillSlot ) ), tx, ty ); } } }
void CPhysicsSystem::PhysicsSimulate() { CMiniProfilerGuard mpg(&g_mp_PhysicsSimulate); VPROF_BUDGET( "CPhysicsSystem::PhysicsSimulate", VPROF_BUDGETGROUP_PHYSICS ); float frametime = gpGlobals->frametime; if ( physenv ) { g_Collisions.BufferTouchEvents( true ); #ifdef _DEBUG physenv->DebugCheckContacts(); #endif frametime *= cl_phys_timescale.GetFloat(); int maxTicks = cl_phys_maxticks.GetInt(); if ( maxTicks ) { float maxFrameTime = physenv->GetDeltaFrameTime( maxTicks ) - 1e-4f; frametime = clamp( frametime, 0, maxFrameTime ); } physenv->Simulate( frametime ); int activeCount = physenv->GetActiveObjectCount(); g_mp_active_object_count.Add(activeCount); IPhysicsObject **pActiveList = NULL; if ( activeCount ) { PHYS_PROFILE(aUpdateActiveObjects) pActiveList = (IPhysicsObject **)stackalloc( sizeof(IPhysicsObject *)*activeCount ); physenv->GetActiveObjects( pActiveList ); for ( int i = 0; i < activeCount; i++ ) { C_BaseEntity *pEntity = reinterpret_cast<C_BaseEntity *>(pActiveList[i]->GetGameData()); if ( pEntity ) { //const CCollisionProperty *collProp = pEntity->CollisionProp(); //debugoverlay->AddBoxOverlay( collProp->GetCollisionOrigin(), collProp->OBBMins(), collProp->OBBMaxs(), collProp->GetCollisionAngles(), 190, 190, 0, 0, 0.01 ); if ( pEntity->CollisionProp()->DoesVPhysicsInvalidateSurroundingBox() ) { pEntity->CollisionProp()->MarkSurroundingBoundsDirty(); } pEntity->VPhysicsUpdate( pActiveList[i] ); IPhysicsShadowController *pShadow = pActiveList[i]->GetShadowController(); if ( pShadow ) { // active shadow object, check for error Vector pos, targetPos; QAngle rot, targetAngles; pShadow->GetTargetPosition( &targetPos, &targetAngles ); pActiveList[i]->GetPosition( &pos, &rot ); Vector delta = targetPos - pos; float dist = VectorNormalize(delta); bool bBlocked = false; if ( dist > cl_phys_block_dist.GetFloat() ) { Vector vel; pActiveList[i]->GetImplicitVelocity( &vel, NULL ); float proj = DotProduct(vel, delta); if ( proj < dist * cl_phys_block_fraction.GetFloat() ) { bBlocked = true; //Msg("%s was blocked %.3f (%.3f proj)!\n", pEntity->GetClassname(), dist, proj ); } } Vector targetAxis; float deltaTargetAngle; RotationDeltaAxisAngle( rot, targetAngles, targetAxis, deltaTargetAngle ); if ( fabsf(deltaTargetAngle) > 0.5f ) { AngularImpulse angVel; pActiveList[i]->GetImplicitVelocity( NULL, &angVel ); float proj = DotProduct( angVel, targetAxis ) * Sign(deltaTargetAngle); if ( proj < (fabsf(deltaTargetAngle) * cl_phys_block_fraction.GetFloat()) ) { bBlocked = true; //Msg("%s was rot blocked %.3f proj %.3f!\n", pEntity->GetClassname(), deltaTargetAngle, proj ); } } if ( bBlocked ) { C_BaseEntity *pBlocker = FindPhysicsBlocker( pActiveList[i] ); if ( pBlocker ) { if ( IsBlockedShouldDisableCollisions( pEntity ) ) { PhysDisableEntityCollisions( pEntity, pBlocker ); pActiveList[i]->RecheckContactPoints(); // GetClassname returns a pointer to the same buffer always! //Msg("%s blocked !", pEntity->GetClassname() ); Msg("by %s\n", pBlocker->GetClassname() ); } } } } } } } #if 0 if ( cl_visualize_physics_shadows.GetBool() ) { int entityCount = NUM_ENT_ENTRIES; for ( int i = 0; i < entityCount; i++ ) { IClientEntity *pClientEnt = cl_entitylist->GetClientEntity(i); if ( !pClientEnt ) continue; C_BaseEntity *pEntity = pClientEnt->GetBaseEntity(); if ( !pEntity ) continue; Vector pos; QAngle angle; IPhysicsObject *pObj = pEntity->VPhysicsGetObject(); if ( !pObj || !pObj->GetShadowController() ) continue; pObj->GetShadowPosition( &pos, &angle ); debugoverlay->AddBoxOverlay( pos, pEntity->CollisionProp()->OBBMins(), pEntity->CollisionProp()->OBBMaxs(), angle, 255, 255, 0, 32, 0 ); char tmp[256]; V_snprintf( tmp, sizeof(tmp),"%s, (%s)\n", pEntity->GetClassname(), VecToString(angle) ); debugoverlay->AddTextOverlay( pos, 0, tmp ); } } #endif g_Collisions.BufferTouchEvents( false ); g_Collisions.FrameUpdate(); } physicssound::PlayImpactSounds( m_impactSounds ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CefRefPtr<CefDictionaryValue> PyToCefDictionaryValue( boost::python::object d ) { CefRefPtr<CefDictionaryValue> result = CefDictionaryValue::Create(); boost::python::object items = d.attr("items")(); boost::python::object iterator = items.attr("__iter__")(); boost::python::ssize_t length = boost::python::len(items); for( boost::python::ssize_t u = 0; u < length; u++ ) { boost::python::object item = iterator.attr( PY_NEXT_METHODNAME )(); boost::python::object value = item[1]; boost::python::object valuetype = fntype( value ); CefString cefkey = boost::python::extract< const char * >( boost::python::str( item[0] ) ); if( value == boost::python::object() ) { result->SetNull( cefkey ); } else if( valuetype == builtins.attr("int") ) { result->SetInt( cefkey, boost::python::extract<int>(value) ); } else if( valuetype == builtins.attr("float") ) { result->SetDouble( cefkey, boost::python::extract<float>(value) ); } else if( valuetype == builtins.attr("str") ) { const char *pStr = boost::python::extract<const char *>(value); result->SetString( cefkey, pStr ); } #if PY_VERSION_HEX < 0x03000000 else if( valuetype == builtins.attr("unicode") ) { const wchar_t *pStr = PyUnicode_AS_UNICODE( value.ptr() ); if( !pStr ) { PyErr_SetString(PyExc_ValueError, "PyToCefDictionaryValue: Invalid unicode object in message list" ); throw boost::python::error_already_set(); } result->SetString( cefkey, pStr ); } #endif // PY_VERSION_HEX < 0x03000000 else if( valuetype == builtins.attr("bool") ) { result->SetBool( cefkey, boost::python::extract<bool>(value) ); } #if PY_VERSION_HEX >= 0x03000000 else if( fnisinstance( value, boost::python::object( builtins.attr("list") ) ) || valuetype == builtins.attr("tuple") || valuetype == builtins.attr("set") || valuetype == builtins.attr("map") ) #else else if( fnisinstance( value, boost::python::object( builtins.attr("list") ) ) || valuetype == builtins.attr("tuple") || valuetype == builtins.attr("set") ) #endif // PY_VERSION_HEX >= 0x03000000 { result->SetList( cefkey, PyToCefValueList( value ) ); } else if( fnisinstance( value, boost::python::object( builtins.attr("dict") ) ) ) { result->SetDictionary( cefkey, PyToCefDictionaryValue( value ) ); } else if( valuetype == srcbuiltins.attr("Color") ) { Color c = boost::python::extract<Color>(value); result->SetString( cefkey, UTIL_VarArgs("rgba(%d, %d, %d, %.2f)", c.r(), c.g(), c.b(), c.a() / 255.0f) ); } else { const char *pObjectTypeStr = boost::python::extract<const char *>( boost::python::str( valuetype ) ); const char *pObjectStr = boost::python::extract<const char *>( boost::python::str( value ) ); char buf[512]; V_snprintf( buf, sizeof(buf), "PyToCefDictionaryValue: Unsupported type \"%s\" for object \"%s\" in message list", pObjectTypeStr, pObjectStr ); PyErr_SetString(PyExc_ValueError, buf ); throw boost::python::error_already_set(); } } return result; }
//--------------------------------------------------------------------------------- // Initializes python. //--------------------------------------------------------------------------------- bool CPythonManager::Initialize( void ) { // Construct a path to the python engine directory. char szPythonHome[MAX_GAME_PATH]; V_snprintf(szPythonHome, MAX_GAME_PATH, "%s/Python3", g_GamePaths.GetSPDir()); V_FixSlashes(szPythonHome); DevMsg(1, "[SP] Python home path set to %s\n", szPythonHome); // Convert to wide char for python. wchar_t wszPythonHome[1024]; V_strtowcs(szPythonHome, -1, wszPythonHome, 1024); // Set that as the python home directory. Py_SetPythonHome(wszPythonHome); Py_SetProgramName(wszPythonHome); Py_SetPath(wszPythonHome); // Initialize python and its namespaces. Py_Initialize(); // Print some information DevMsg(1, "Python version %s initialized!\n", Py_GetVersion()); // Make sure sys is imported. PyRun_SimpleString("import sys"); // Add the Python API path. AddToSysPath("/packages/source-python"); // Add operating system specific paths. #if defined(WIN32) AddToSysPath("/Python3/plat-win"); #else AddToSysPath("/Python3/plat-linux"); // We've got a bunch of linux shared objects here we need to load. AddToSysPath("/Python3/lib-dynload"); #endif // Site packages for any extra packages... AddToSysPath("/packages/site-packages"); // Add the custom packages path. AddToSysPath("/packages/custom"); // And of course, the plugins directory for script imports. AddToSysPath("/plugins"); // Initialize all converters InitConverters(); // Initialize all submodules modulsp_init(); // Import the main module file. DevMsg(1, "[SP] Importing main module..\n"); BEGIN_BOOST_PY() python::import("__init__"); END_BOOST_PY_NORET(); // Noret because we have more stuff to do after this import. DevMsg(0, "[Source.Python] Loaded successfully.\n"); return true; }
//----------------------------------------------------------------------------- // Purpose: loads per-map manifest! //----------------------------------------------------------------------------- void ParseParticleEffectsMap( const char *pMapName, bool bLoadSheets, IFileList *pFilesToReload ) { MEM_ALLOC_CREDIT(); CUtlVector<CUtlString> files; char szMapManifestFilename[MAX_PATH]; szMapManifestFilename[0] = NULL; if ( pMapName && *pMapName ) { V_snprintf( szMapManifestFilename, sizeof( szMapManifestFilename ), "maps/%s_particles.txt", pMapName ); } // Open the manifest file, and read the particles specified inside it KeyValues *manifest = new KeyValues( szMapManifestFilename ); if ( manifest->LoadFromFile( filesystem, szMapManifestFilename, "GAME" ) ) { DevMsg( "Successfully loaded particle effects manifest '%s' for map '%s'\n", szMapManifestFilename, pMapName ); for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() ) { if ( !Q_stricmp( sub->GetName(), "file" ) ) { // Ensure the particles are in the particles directory char szPath[ 512 ]; Q_strncpy( szPath, sub->GetString(), sizeof( szPath ) ); Q_StripFilename( szPath ); char *pszPath = (szPath[0] == '!') ? &szPath[1] : &szPath[0]; if ( pszPath && pszPath[0] && !Q_stricmp( pszPath, "particles" ) ) { files.AddToTail( sub->GetString() ); continue; } else { Warning( "CParticleMgr::LevelInit: Manifest '%s' contains a particle file '%s' that's not under the particles directory. Custom particles must be placed in the particles directory.\n", szMapManifestFilename, sub->GetString() ); } } else { Warning( "CParticleMgr::LevelInit: Manifest '%s' with bogus file type '%s', expecting 'file'\n", szMapManifestFilename, sub->GetName() ); } } } else { // Don't print a warning, and don't proceed any further if the file doesn't exist! return; } int nCount = files.Count(); if ( !nCount ) { return; } g_pParticleSystemMgr->ShouldLoadSheets( bLoadSheets ); for ( int i = 0; i < nCount; ++i ) { // If we've been given a list of particles to reload, only reload those. if ( !pFilesToReload || (pFilesToReload && pFilesToReload->IsFileInList( files[i] )) ) { g_pParticleSystemMgr->ReadParticleConfigFile( files[i], true, true ); } } g_pParticleSystemMgr->DecommitTempMemory(); }
bool IsValidSteamID(const char *pchSteamID, char *pszErr, int maxerr) { if(!strcmp(pchSteamID, "STEAM_ID_PENDING")) { return true; } if(!strcmp(pchSteamID, "BOT")) { return true; } if(strncmp(pchSteamID, "STEAM_", 6) && strncmp(pchSteamID, "[U:1:", 5)) { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Unexpected SteamID format. Expected STEAM_ or [U:1:###]."); return false; } if(!strncmp(pchSteamID, "STEAM_", 6)) { if(!isdigit(pchSteamID[6])) { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected digit after STEAM_"); return false; } if(pchSteamID[7] != ':') { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected colon after STEAM_#"); return false; } if(!isdigit(pchSteamID[8])) { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected digit after STEAM_#:"); return false; } unsigned char middledigit = (pchSteamID[8] - '0'); if(middledigit != 0 && middledigit != 1) { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected only 0 or 1 after STEAM_#:"); return false; } if(pchSteamID[9] != ':') { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected colon after STEAM_#:#"); return false; } int steamidlen = strlen(pchSteamID); if(steamidlen <= 10) { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected at least one digit after STEAM_#:#:"); return false; } for(int i = 10; i < steamidlen; i++) { if(!isdigit(pchSteamID[i])) { if(pszErr) V_snprintf(pszErr, maxerr, "[SOURCEOP] Expected only digits after STEAM_#:#:"); return false; } } } else { int steamidlen = strlen( pchSteamID ); if ( steamidlen <= 5 ) { if ( pszErr ) V_snprintf( pszErr, maxerr, "[SOURCEOP] Expected at least one digit after [U:1:" ); return false; } if ( !isdigit( pchSteamID[3] ) ) { if ( pszErr ) V_snprintf( pszErr, maxerr, "[SOURCEOP] Expected a digit after [U:" ); return false; } if ( pchSteamID[steamidlen - 1] != ']' ) { if ( pszErr ) V_snprintf( pszErr, maxerr, "[SOURCEOP] The last character must be ']'" ); return false; } for ( int i = 5; i < steamidlen; i++ ) { if ( pchSteamID[i] == ']' && i != steamidlen - 1 ) { if ( pszErr ) V_snprintf( pszErr, maxerr, "[SOURCEOP] ']' can only be the last character" ); return false; } if ( !isdigit( pchSteamID[i] ) && pchSteamID[i] != ']' ) { if ( pszErr ) V_snprintf( pszErr, maxerr, "[SOURCEOP] Expected only digits between [U:1: and ]" ); return false; } } } return true; }
char *V_pretifynum( int64 value ) { static char output[ NUM_PRETIFYMEM_BUFFERS ][ 32 ]; static int current; char *out = output[ current ]; current = ( current + 1 ) & ( NUM_PRETIFYMEM_BUFFERS -1 ); *out = 0; // Render the leading -, if necessary if ( value < 0 ) { char *pchRender = out + V_strlen( out ); V_snprintf( pchRender, 32, "-" ); value = -value; } // Render quadrillions if ( value >= 1000000000000 ) { char *pchRender = out + V_strlen( out ); V_snprintf( pchRender, 32, "%d,", value / 1000000000000 ); } // Render trillions if ( value >= 1000000000000 ) { char *pchRender = out + V_strlen( out ); V_snprintf( pchRender, 32, "%d,", value / 1000000000000 ); } // Render billions if ( value >= 1000000000 ) { char *pchRender = out + V_strlen( out ); V_snprintf( pchRender, 32, "%d,", value / 1000000000 ); } // Render millions if ( value >= 1000000 ) { char *pchRender = out + V_strlen( out ); if ( value >= 1000000000 ) V_snprintf( pchRender, 32, "%03d,", ( value / 1000000 ) % 1000 ); else V_snprintf( pchRender, 32, "%d,", ( value / 1000000 ) % 1000 ); } // Render thousands if ( value >= 1000 ) { char *pchRender = out + V_strlen( out ); if ( value >= 1000000 ) V_snprintf( pchRender, 32, "%03d,", ( value / 1000 ) % 1000 ); else V_snprintf( pchRender, 32, "%d,", ( value / 1000 ) % 1000 ); } // Render units char *pchRender = out + V_strlen( out ); if ( value > 1000 ) V_snprintf( pchRender, 32, "%03d", value % 1000 ); else V_snprintf( pchRender, 32, "%d", value % 1000 ); return out; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void PySingleToCefValueList( boost::python::object value, CefListValue *result, int i ) { boost::python::object jsobject = _cef.attr("JSObject"); boost::python::object valuetype = fntype( value ); if( value == boost::python::object() ) { result->SetNull( i ); } else if( valuetype == builtins.attr("int") ) { result->SetInt( i, boost::python::extract<int>(value) ); } else if( valuetype == builtins.attr("float") ) { result->SetDouble( i, boost::python::extract<float>(value) ); } else if( valuetype == builtins.attr("str") ) { const char *pStr = boost::python::extract<const char *>(value); result->SetString( i, pStr ); } #if PY_VERSION_HEX < 0x03000000 else if( valuetype == builtins.attr("unicode") ) { const wchar_t *pStr = PyUnicode_AS_UNICODE( value.ptr() ); if( !pStr ) { PyErr_SetString(PyExc_ValueError, "PyToCefValueList: Invalid unicode object in message list" ); throw boost::python::error_already_set(); } result->SetString( i, pStr ); } #endif // PY_VERSION_HEX < 0x03000000 else if( valuetype == builtins.attr("bool") ) { result->SetBool( i, boost::python::extract<bool>(value) ); } #if PY_VERSION_HEX >= 0x03000000 else if( fnisinstance( value, boost::python::object( builtins.attr("list") ) ) || valuetype == builtins.attr("tuple") || valuetype == builtins.attr("set") || valuetype == builtins.attr("map") ) #else else if( fnisinstance( value, boost::python::object( builtins.attr("list") ) ) || valuetype == builtins.attr("tuple") || valuetype == builtins.attr("set") ) #endif // PY_VERSION_HEX >= 0x03000000 { result->SetList( i, PyToCefValueList( value ) ); } else if( fnisinstance( value, boost::python::object( builtins.attr("dict") ) ) ) { result->SetDictionary( i, PyToCefDictionaryValue( value ) ); } else if( valuetype == srcbuiltins.attr("Color") ) { Color c = boost::python::extract<Color>(value); result->SetString( i, UTIL_VarArgs("rgba(%d, %d, %d, %.2f)", c.r(), c.g(), c.b(), c.a() / 255.0f) ); } else if( valuetype == jsobject ) { PyJSObject *pJSObject = boost::python::extract< PyJSObject * >( value ); WarsCefJSObject_t warsCefJSObject; V_strncpy( warsCefJSObject.uuid, pJSObject->GetJSObject()->GetIdentifier().ToString().c_str(), sizeof( warsCefJSObject.uuid ) ); CefRefPtr<CefBinaryValue> pRefData = CefBinaryValue::Create( &warsCefJSObject, sizeof( warsCefJSObject ) ); result->SetBinary( i, pRefData ); } else { const char *pObjectTypeStr = boost::python::extract<const char *>( boost::python::str( valuetype ) ); const char *pObjectStr = boost::python::extract<const char *>( boost::python::str( value ) ); char buf[512]; V_snprintf( buf, sizeof(buf), "PyToCefValueList: Unsupported type \"%s\" for object \"%s\" in message list", pObjectTypeStr, pObjectStr ); PyErr_SetString( PyExc_ValueError, buf ); throw boost::python::error_already_set(); } }
bool LoadItem(specialitemload_t const &item) { unsigned long long profileid = item.steamid.ConvertToUint64(); char query[1024]; V_snprintf(query, sizeof(query), "SELECT `id`, `itemdef`, `petname`, `equipped`, `level`, `quality` FROM `specialitems` WHERE `owner` = %llu AND `active` = 'Y' ORDER BY `id` ASC", profileid); //Msg("[ITEMDBG] %s\n", query); m_SQL->Query(query); item.itemmutex->Lock(); unsigned int index = item.itemlist->Find(profileid); if(item.itemlist->IsValidIndex(index)) { // this should be checked first in NetworkIDValidated // but this could still happen if two NetworkIDValidated occur for the same ID // while items still loading Msg("[ITEMDBG] Item list already exists for %s.\n", item.steamid.Render()); item.itemmutex->Unlock(); return true; } item.itemmutex->Unlock(); CUtlVector<CSpecialItem *> *items = new CUtlVector<CSpecialItem *>; CSOPMySQLRow row = m_SQL->NextRow(); while(!row.IsNull()) { CSpecialItem *newspecialitem = new CSpecialItem; newspecialitem->m_iIndex = atoi(row.Column(0)); V_strncpy(newspecialitem->m_szPetName, row.Column(2), sizeof(newspecialitem->m_szPetName)); newspecialitem->m_bEquipped = atoi(row.Column(3)) != 0; CEconItemView *newitem = new CEconItemView; //Msg("[ITEMDBG] Test: %i %i\n", sizeof(CEconItemView), sizeof(CEconItemAttribute)); newspecialitem->m_pItem = newitem; newitem->m_bInitialized = false; newitem->m_iEntityLevel = atoi(row.Column(4)); newitem->m_iEntityQuality = atoi(row.Column(5)); newitem->m_iGlobalIndex = 0; newitem->m_iGlobalIndexHigh = 0; newitem->m_iGlobalIndexLow = 0; newitem->m_iAccountID = item.steamid.GetAccountID(); newitem->m_iItemDefinitionIndex = atoi(row.Column(1)); newitem->m_iPosition = 0; newitem->m_pUnk = NULL; newitem->m_attributes.m_Attributes.EnsureCapacity(16); //Msg("[ITEMDBG] Adding item %i type %i level %i quality %i\n", newitem->m_iGlobalIndex, newitem->m_iItemDefinitionIndex, newitem->m_iEntityLevel, newitem->m_iEntityQuality); items->AddToTail(newspecialitem); row = m_SQL->NextRow(); } m_SQL->FreeResult(); // now go and get all the attributes for(int i = 0; i < items->Count(); i++) { CSpecialItem *curspecialitem = items->Element(i); CEconItemView *curitem = curspecialitem->m_pItem; V_snprintf(query, sizeof(query), "SELECT `attribdef`, `value` FROM `specialitems_attributes` WHERE `itemid` = %i", (int)curspecialitem->m_iIndex); //Msg("[ITEMDBG] %s\n", query); m_SQL->Query(query); CSOPMySQLRow row = m_SQL->NextRow(); while(!row.IsNull()) { CEconItemAttribute newAttrib; newAttrib.m_iAttribDef = atoi(row.Column(0)); newAttrib.m_flVal = atof(row.Column(1)); newAttrib.m_flInitialValue = newAttrib.m_flVal; newAttrib.m_nRefundableCurrency = 0; newAttrib.m_bSetBonus = false; //Msg("[ITEMDBG] Adding attribute to item %i def %i val %f\n", (int)curitem->m_iGlobalIndex, newAttrib.m_iAttribDef, newAttrib.m_flVal); curitem->m_attributes.m_Attributes.AddToTail(newAttrib); row = m_SQL->NextRow(); } m_SQL->FreeResult(); } item.itemmutex->Lock(); index = item.itemlist->Find(profileid); if(item.itemlist->IsValidIndex(index)) { // this should be checked first in NetworkIDValidated // but this could still happen if two NetworkIDValidated occur for the same ID // while items still loading Msg("[ITEMDBG] Item list already exists when inserting for %s.\n", item.steamid.Render()); // free list for(int i = 0; i < items->Count(); i++) { delete items->Element(i)->m_pItem; delete items->Element(i); } delete items; } else { item.itemlist->Insert(profileid, items); } item.itemmutex->Unlock(); return true; }
//----------------------------------------------------------------------------- // BugDlg_Submit // //----------------------------------------------------------------------------- bool BugDlg_Submit( HWND hWnd ) { char title[1024]; char miscInfo[1024]; char basename[MAX_PATH]; char filename[MAX_PATH]; char positionName[MAX_PATH]; char orientationName[MAX_PATH]; char buildName[MAX_PATH]; char mapName[MAX_PATH]; bool bSuccess = false; sprintf( positionName, "%f %f %f", g_bug_mapInfo.position[0], g_bug_mapInfo.position[1], g_bug_mapInfo.position[2] ); SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, positionName ); sprintf( orientationName, "%f %f %f", g_bug_mapInfo.angle[0], g_bug_mapInfo.angle[1], g_bug_mapInfo.angle[2] ); SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, orientationName ); sprintf( buildName, "%d", g_bug_mapInfo.build ); SetDlgItemText( g_bug_hWnd, IDC_BUG_BUILD_LABEL, buildName ); V_FileBase( g_bug_mapInfo.mapPath, mapName, sizeof( mapName ) ); char *pExtension = V_stristr( mapName, ".bsp" ); if ( pExtension ) { *pExtension = '\0'; } pExtension = V_stristr( mapName, ".360" ); if ( pExtension ) { *pExtension = '\0'; } V_snprintf( miscInfo, sizeof( miscInfo ), "skill %d", g_bug_mapInfo.skill ); // Stuff bug data files up to server g_bug_pReporter->StartNewBugReport(); g_bug_pReporter->SetOwner( g_bug_pReporter->GetUserNameForDisplayName( g_bug_szOwner ) ); g_bug_pReporter->SetSubmitter( NULL ); if ( mapName[0] ) V_snprintf( title, sizeof( title ), "%s: %s", mapName, g_bug_szTitle ); else V_snprintf( title, sizeof( title ), "%s", g_bug_szTitle ); g_bug_pReporter->SetTitle( title ); g_bug_pReporter->SetDescription( g_bug_szDescription ); g_bug_pReporter->SetLevel( mapName ); g_bug_pReporter->SetPosition( positionName ); g_bug_pReporter->SetOrientation( orientationName ); g_bug_pReporter->SetBuildNumber( buildName ); g_bug_pReporter->SetSeverity( g_bug_szSeverity ); g_bug_pReporter->SetPriority( g_bug_szPriority ); g_bug_pReporter->SetArea( g_bug_szArea ); g_bug_pReporter->SetMapNumber( g_bug_szMapNumber ); g_bug_pReporter->SetReportType( g_bug_szReportType ); g_bug_pReporter->SetMiscInfo( miscInfo ); g_bug_pReporter->SetDriverInfo( "" ); g_bug_pReporter->SetExeName( "" ); g_bug_pReporter->SetGameDirectory( "" ); g_bug_pReporter->SetRAM( 0 ); g_bug_pReporter->SetCPU( 0 ); g_bug_pReporter->SetProcessor( "" ); g_bug_pReporter->SetDXVersion( 0, 0, 0, 0 ); g_bug_pReporter->SetOSVersion( "" ); g_bug_pReporter->ResetIncludedFiles(); g_bug_pReporter->SetZipAttachmentName( "" ); if ( g_bug_szScreenshot[0] ) { if ( g_bug_bCompressScreenshot ) { BugDlg_CompressScreenshot(); } // strip the fully qualified path into filename only Sys_StripPath( g_bug_szScreenshot, basename, sizeof( basename ) ); V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename ); Sys_NormalizePath( filename, false ); g_bug_pReporter->SetScreenShot( filename ); } if ( g_bug_szSavegame[0] ) { // strip the fully qualified path into filename only Sys_StripPath( g_bug_szSavegame, basename, sizeof( basename ) ); V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename ); Sys_NormalizePath( filename, false ); g_bug_pReporter->SetSaveGame( filename ); } if ( g_bug_szBSPName[0] ) { // strip the fully qualified path into filename only Sys_StripPath( g_bug_szBSPName, basename, sizeof( basename ) ); V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename ); Sys_NormalizePath( filename, false ); g_bug_pReporter->SetBSPName( filename ); } int bugID = -1; bSuccess = g_bug_pReporter->CommitBugReport( bugID ); if ( bSuccess ) { if ( !BugDlg_UploadBugSubmission( bugID, g_bug_szSavegame, g_bug_szScreenshot, g_bug_szBSPName, NULL ) ) { Sys_MessageBox( BUG_ERRORTITLE, "Unable to upload files to bug repository!\n" ); bSuccess = false; } } else { Sys_MessageBox( BUG_ERRORTITLE, "Unable to post bug report to database!\n" ); } if ( bSuccess ) { if ( g_Games[g_bug_GameType].bUsesSystem1 ) { ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: PVCS submission succeeded for bug! (%d)\n", bugID ); } else { ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: BugBait submission succeeded for bug!\n" ); } } else { ConsoleWindowPrintf( XBX_CLR_RED, "Bug Reporter: Submission failed\n" ); } return bSuccess; }
void CMultiplayRules::GetNextLevelName( char *pszNextMap, int bufsize, bool bRandom /* = false */ ) { const char *mapcfile = mapcyclefile.GetString(); Assert( mapcfile != NULL ); // Check the time of the mapcycle file and re-populate the list of level names if the file has been modified const int nMapCycleTimeStamp = filesystem->GetPathTime( mapcfile, "GAME" ); if ( 0 == nMapCycleTimeStamp ) { // Map cycle file does not exist, make a list containing only the current map char *szCurrentMapName = new char[32]; Q_strncpy( szCurrentMapName, STRING(gpGlobals->mapname), 32 ); m_MapList.AddToTail( szCurrentMapName ); } else { // If map cycle file has changed or this is the first time through ... if ( m_nMapCycleTimeStamp != nMapCycleTimeStamp ) { // Reset map index and map cycle timestamp m_nMapCycleTimeStamp = nMapCycleTimeStamp; m_nMapCycleindex = 0; // Clear out existing map list. Not using Purge() because I don't think that it will do a 'delete []' for ( int i = 0; i < m_MapList.Count(); i++ ) { delete [] m_MapList[i]; } m_MapList.RemoveAll(); // Repopulate map list from mapcycle file int nFileLength; char *aFileList = (char*)UTIL_LoadFileForMe( mapcfile, &nFileLength ); if ( aFileList && nFileLength ) { V_SplitString( aFileList, "\n", m_MapList ); for ( int i = 0; i < m_MapList.Count(); i++ ) { bool bIgnore = false; // Strip out the spaces in the name StripChar( m_MapList[i] , '\r'); StripChar( m_MapList[i] , ' '); if ( !engine->IsMapValid( m_MapList[i] ) ) { bIgnore = true; // If the engine doesn't consider it a valid map remove it from the lists char szWarningMessage[MAX_PATH]; V_snprintf( szWarningMessage, MAX_PATH, "Invalid map '%s' included in map cycle file. Ignored.\n", m_MapList[i] ); Warning( szWarningMessage ); } else if ( !Q_strncmp( m_MapList[i], "//", 2 ) ) { bIgnore = true; } if ( bIgnore ) { delete [] m_MapList[i]; m_MapList.Remove( i ); --i; } } UTIL_FreeFile( (byte *)aFileList ); } } } // If somehow we have no maps in the list then add the current one if ( 0 == m_MapList.Count() ) { char *szDefaultMapName = new char[32]; Q_strncpy( szDefaultMapName, STRING(gpGlobals->mapname), 32 ); m_MapList.AddToTail( szDefaultMapName ); } if ( bRandom ) { m_nMapCycleindex = RandomInt( 0, m_MapList.Count() - 1 ); } // Here's the return value Q_strncpy( pszNextMap, m_MapList[m_nMapCycleindex], bufsize); }
char *V_pretifymem( float value, int digitsafterdecimal /*= 2*/, bool usebinaryonek /*= false*/ ) { static char output[ NUM_PRETIFYMEM_BUFFERS ][ 32 ]; static int current; float onekb = usebinaryonek ? 1024.0f : 1000.0f; float onemb = onekb * onekb; char *out = output[ current ]; current = ( current + 1 ) & ( NUM_PRETIFYMEM_BUFFERS -1 ); char suffix[ 8 ]; // First figure out which bin to use if ( value > onemb ) { value /= onemb; V_snprintf( suffix, sizeof( suffix ), " MB" ); } else if ( value > onekb ) { value /= onekb; V_snprintf( suffix, sizeof( suffix ), " KB" ); } else { V_snprintf( suffix, sizeof( suffix ), " bytes" ); } char val[ 32 ]; // Clamp to >= 0 digitsafterdecimal = max( digitsafterdecimal, 0 ); // If it's basically integral, don't do any decimals if ( FloatMakePositive( value - (int)value ) < 0.00001 ) { V_snprintf( val, sizeof( val ), "%i%s", (int)value, suffix ); } else { char fmt[ 32 ]; // Otherwise, create a format string for the decimals V_snprintf( fmt, sizeof( fmt ), "%%.%if%s", digitsafterdecimal, suffix ); V_snprintf( val, sizeof( val ), fmt, value ); } // Copy from in to out char *i = val; char *o = out; // Search for decimal or if it was integral, find the space after the raw number char *dot = strstr( i, "." ); if ( !dot ) { dot = strstr( i, " " ); } // Compute position of dot int pos = dot - i; // Don't put a comma if it's <= 3 long pos -= 3; while ( *i ) { // If pos is still valid then insert a comma every third digit, except if we would be // putting one in the first spot if ( pos >= 0 && !( pos % 3 ) ) { // Never in first spot if ( o != out ) { *o++ = ','; } } // Count down comma position pos--; // Copy rest of data as normal *o++ = *i++; } // Terminate *o = 0; return out; }
IClient *CForwardManager::OnSpectatorConnect(netadr_t & address, int nProtocol, int iChallenge, int iClientChallenge, int nAuthProtocol, const char *pchName, const char *pchPassword, const char *pCookie, int cbCookie) #endif { if (!pCookie || (size_t)cbCookie < sizeof(uint64)) RETURN_META_VALUE(MRES_IGNORED, nullptr); #if SOURCE_ENGINE == SE_CSGO // CS:GO doesn't send the player name in pchName, but only in the client info convars. // Try to extract the name from the protobuf msg. char playerName[MAX_PLAYER_NAME_LENGTH]; if (ExtractPlayerName(pSplitPlayerConnectVector, playerName, sizeof(playerName))) pchName = playerName; #endif char ipString[16]; V_snprintf(ipString, sizeof(ipString), "%u.%u.%u.%u", address.ip[0], address.ip[1], address.ip[2], address.ip[3]); V_strncpy(passwordBuffer, pchPassword, 255); // SourceTV doesn't validate steamids?! char rejectReason[255]; m_SpectatorPreConnectFwd->PushString(pchName); m_SpectatorPreConnectFwd->PushStringEx(passwordBuffer, 255, SM_PARAM_STRING_UTF8 | SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK); m_SpectatorPreConnectFwd->PushString(ipString); m_SpectatorPreConnectFwd->PushStringEx(rejectReason, 255, SM_PARAM_STRING_UTF8 | SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK); cell_t retVal = 1; m_SpectatorPreConnectFwd->Execute(&retVal); IServer *server = META_IFACEPTR(IServer); if (retVal == 0) { if (m_bHasRejectConnectionOffset) { #if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_LEFT4DEAD || SOURCE_ENGINE == SE_LEFT4DEAD2 SH_MCALL(server, CHLTVServer_RejectConnection)(address, rejectReason); #else SH_MCALL(server, CHLTVServer_RejectConnection)(address, iClientChallenge, rejectReason); #endif } RETURN_META_VALUE(MRES_SUPERCEDE, nullptr); } // Call the original function. #if SOURCE_ENGINE == SE_CSGO IClient *client = SH_MCALL(server, CHLTVServer_ConnectClient)(address, nProtocol, iChallenge, nAuthProtocol, pchName, passwordBuffer, pCookie, cbCookie, pSplitPlayerConnectVector, bUnknown, platform, pUnknown, iUnknown); #elif SOURCE_ENGINE == SE_LEFT4DEAD || SOURCE_ENGINE == SE_LEFT4DEAD2 IClient *client = SH_MCALL(server, CHLTVServer_ConnectClient)(address, nProtocol, iChallenge, nAuthProtocol, pchName, passwordBuffer, pCookie, cbCookie, pSplitPlayerConnectVector, bUnknown); #else IClient *client = SH_MCALL(server, CHLTVServer_ConnectClient)(address, nProtocol, iChallenge, iClientChallenge, nAuthProtocol, pchName, passwordBuffer, pCookie, cbCookie); #endif if (!client) RETURN_META_VALUE(MRES_SUPERCEDE, nullptr); HookClient(client); HLTVServerWrapper *wrapper = g_HLTVServers.GetWrapper(server); if (wrapper) { HLTVClientWrapper *clientWrapper = wrapper->GetClient(client->GetPlayerSlot() + 1); clientWrapper->Initialize(ipString, pchPassword, client); } m_SpectatorConnectedFwd->PushCell(client->GetPlayerSlot() + 1); m_SpectatorConnectedFwd->Execute(); // Don't call the hooked function again, just return its value. RETURN_META_VALUE(MRES_SUPERCEDE, client); }
//--------------------------------------------------------------------------------- // This function will load libraries and return true if they load successfully. // //--------------------------------------------------------------------------------- void* SPLoadLibrary( IVEngineServer* engine, const char* libraryPath ) { DevMsg(1, MSG_PREFIX "Loading library: %s\n", libraryPath); char szFullPath[MAX_PATH_LENGTH]; char szGamePath[MAX_PATH_LENGTH]; char szError[MAX_PATH_LENGTH]; V_strncpy(szError, "[SP-LOADER] - No error found\n", MAX_PATH_LENGTH); engine->GetGameDir(szGamePath, MAX_PATH_LENGTH); GenerateSymlink(szGamePath); V_snprintf(szFullPath, sizeof(szFullPath), "%s/addons/source-python/%s", szGamePath, libraryPath); // Fix up the slahes. V_FixSlashes(szFullPath); #if defined(_WIN32) void* hModule = (void *)LoadLibrary(szFullPath); if (!hModule) { // I hate windows programming... DWORD nErrorCode = GetLastError(); LPVOID lpMsgBuf; DWORD nBufferLength = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, nErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL ); if(nBufferLength == 0) { V_snprintf(szError, sizeof(szError), "[SP-LOADER] Could not obtain a valid translation for error. (Code: %d)\n", nErrorCode); } else { char szResult[MAX_ERROR_LENGTH]; memset(szResult, '\0', MAX_ERROR_LENGTH); // Too lazy to bring across any windows functions, cast myself from wide to narrow for (unsigned int i=0; i < nBufferLength; ++i) { szResult[i] = static_cast<char>(static_cast<LPCSTR>(lpMsgBuf)[i]); } V_snprintf(szError, sizeof(szError), "[SP-LOADER] (Code: %d) %s", nErrorCode, szResult/*.c_str()*/); LocalFree(lpMsgBuf); } } #else void* hModule = (void *)dlopen(szFullPath, RTLD_NOW | RTLD_GLOBAL); if (!hModule) { V_snprintf(szError, sizeof(szError), "[SP-LOADER] Error Reported: %s\n", dlerror()); } #endif if( !hModule ) { Warning("=========================================================================\n"); Warning("[SP-LOADER] Could not load library: %s\n", libraryPath); Warning(szError); Warning("=========================================================================\n"); return hModule; } return hModule; }
//----------------------------------------------------------------------------- // Generate a tree containing files from a reslist. Returns TRUE if successful. //----------------------------------------------------------------------------- bool LoadReslist( const char *pReslistName, CUtlRBTree< CUtlString, int > *pTree ) { CUtlBuffer buffer; if ( !scriptlib->ReadFileToBuffer( pReslistName, buffer, true ) ) { return false; } char szBasename[MAX_PATH]; V_FileBase( pReslistName, szBasename, sizeof( szBasename ) ); characterset_t breakSet; CharacterSetBuild( &breakSet, "" ); // parse reslist char szToken[MAX_PATH]; char szBspName[MAX_PATH]; szBspName[0] = '\0'; for ( ;; ) { int nTokenSize = buffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); if ( nTokenSize <= 0 ) { break; } // reslists are pc built, filenames can be sloppy V_strlower( szToken ); V_FixSlashes( szToken ); V_RemoveDotSlashes( szToken ); // can safely cull filetypes that are ignored by queued loader at runtime bool bKeep = false; const char *pExt = V_GetFileExtension( szToken ); if ( !pExt ) { // unknown continue; } else if ( !V_stricmp( pExt, "vmt" ) || !V_stricmp( pExt, "vhv" ) || !V_stricmp( pExt, "mdl" ) || !V_stricmp( pExt, "raw" ) || !V_stricmp( pExt, "wav" ) ) { bKeep = true; } else if ( !V_stricmp( pExt, "mp3" ) ) { // change to .wav V_SetExtension( szToken, ".wav", sizeof( szToken ) ); bKeep = true; } else if ( !V_stricmp( pExt, "bsp" ) ) { // reslists erroneously have multiple bsps if ( !V_stristr( szToken, szBasename ) ) { // wrong one, cull it continue; } else { // right one, save it strcpy( szBspName, szToken ); bKeep = true; } } if ( bKeep ) { FindOrAddFileToResourceList( szToken, pTree ); } } if ( !szBspName[0] ) { // reslist is not bsp derived, nothing more to do return true; } CUtlVector< CUtlString > bspList; bool bOK = GetDependants_BSP( szBspName, &bspList ); if ( !bOK ) { return false; } // add all the bsp dependants to the resource list for ( int i=0; i<bspList.Count(); i++ ) { FindOrAddFileToResourceList( bspList[i].String(), pTree ); } // iterate all the models in the resource list, get all their dependents CUtlVector< CUtlString > modelList; for ( int i = pTree->FirstInorder(); i != pTree->InvalidIndex(); i = pTree->NextInorder( i ) ) { const char *pExt = V_GetFileExtension( pTree->Element( i ).String() ); if ( !pExt || V_stricmp( pExt, "mdl" ) ) { continue; } if ( !GetDependants_MDL( pTree->Element( i ).String(), &modelList ) ) { return false; } } // add all the model dependents to the resource list for ( int i=0; i<modelList.Count(); i++ ) { FindOrAddFileToResourceList( modelList[i].String(), pTree ); } // check for optional commentary, include wav dependencies char szCommentaryName[MAX_PATH]; V_ComposeFileName( g_szGamePath, szBspName, szCommentaryName, sizeof( szCommentaryName ) ); V_StripExtension( szCommentaryName, szCommentaryName, sizeof( szCommentaryName ) ); V_strncat( szCommentaryName, "_commentary.txt", sizeof( szCommentaryName ) ); CUtlBuffer commentaryBuffer; if ( ReadFileToBuffer( szCommentaryName, commentaryBuffer, true, true ) ) { // any single token may be quite large to due to text char szCommentaryToken[8192]; for ( ;; ) { int nTokenSize = commentaryBuffer.ParseToken( &breakSet, szCommentaryToken, sizeof( szCommentaryToken ) ); if ( nTokenSize < 0 ) { break; } if ( nTokenSize > 0 && !V_stricmp( szCommentaryToken, "commentaryfile" ) ) { // get the commentary file nTokenSize = commentaryBuffer.ParseToken( &breakSet, szCommentaryToken, sizeof( szCommentaryToken ) ); if ( nTokenSize > 0 ) { // skip past sound chars char *pName = szCommentaryToken; while ( *pName && IsSoundChar( *pName ) ) { pName++; } char szWavFile[MAX_PATH]; V_snprintf( szWavFile, sizeof( szWavFile ), "sound/%s", pName ); FindOrAddFileToResourceList( szWavFile, pTree ); } } } } // check for optional blacklist char szBlacklist[MAX_PATH]; V_ComposeFileName( g_szGamePath, "reslistfixes_xbox.xsc", szBlacklist, sizeof( szBlacklist ) ); CUtlBuffer blacklistBuffer; if ( ReadFileToBuffer( szBlacklist, blacklistBuffer, true, true ) ) { for ( ;; ) { int nTokenSize = blacklistBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); if ( nTokenSize <= 0 ) { break; } bool bAdd; if ( !V_stricmp( szToken, "-" ) ) { bAdd = false; } else if ( !V_stricmp( szToken, "+" ) ) { bAdd = true; } else { // bad syntax, skip line Msg( "Bad Syntax, expecting '+' or '-' as first token in reslist fixup file '%s'.\n", szBlacklist ); continue; } // get entry nTokenSize = blacklistBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); if ( nTokenSize <= 0 ) { break; } if ( bAdd ) { FindOrAddFileToResourceList( szToken, pTree ); } else { RemoveFileFromResourceList( szToken, pTree ); } } } return true; }