// This looks for pDBInfoFilename in the same path as pBaseExeFilename. // The file has 3 lines: machine name (with database), database name, username void GetDBInfo( const char *pDBInfoFilename, CDBInfo *pInfo ) { char baseExeFilename[512]; if ( !GetModuleFileName( GetModuleHandle( NULL ), baseExeFilename, sizeof( baseExeFilename ) ) ) Error( "GetModuleFileName failed." ); // Look for the info file in the same directory as the exe. char dbInfoFilename[512]; Q_strncpy( dbInfoFilename, baseExeFilename, sizeof( dbInfoFilename ) ); Q_StripFilename( dbInfoFilename ); if ( dbInfoFilename[0] == 0 ) Q_strncpy( dbInfoFilename, ".", sizeof( dbInfoFilename ) ); Q_strncat( dbInfoFilename, "/", sizeof( dbInfoFilename ), COPY_ALL_CHARACTERS ); Q_strncat( dbInfoFilename, pDBInfoFilename, sizeof( dbInfoFilename ), COPY_ALL_CHARACTERS ); FILE *fp = fopen( dbInfoFilename, "rt" ); if ( !fp ) { Error( "Can't open %s for database info.\n", dbInfoFilename ); } if ( !ReadStringFromFile( fp, pInfo->m_HostName, sizeof( pInfo->m_HostName ) ) || !ReadStringFromFile( fp, pInfo->m_DBName, sizeof( pInfo->m_DBName ) ) || !ReadStringFromFile( fp, pInfo->m_UserName, sizeof( pInfo->m_UserName ) ) ) { Error( "%s is not a valid database info file.\n", dbInfoFilename ); } fclose( fp ); }
static bool FileSystem_GetBaseDir( char *baseDir, int baseDirLen ) { if ( FileSystem_GetExecutableDir( baseDir, baseDirLen ) ) { Q_StripFilename( baseDir ); return true; } return false; }
bool FileSystem_GetExecutableDir( char *exedir, int exeDirLen ) { exedir[0] = 0; if ( s_bUseVProjectBinDir ) { const char *pProject = GetVProjectCmdLineValue(); if ( !pProject ) { // Check their registry. pProject = getenv( GAMEDIR_TOKEN ); } if ( pProject ) { Q_snprintf( exedir, exeDirLen, "%s%c..%cbin", pProject, CORRECT_PATH_SEPARATOR, CORRECT_PATH_SEPARATOR ); return true; } return false; } if ( !Sys_GetExecutableName( exedir, exeDirLen ) ) return false; Q_StripFilename( exedir ); if ( IsX360() ) { // The 360 can have its exe and dlls reside on different volumes // use the optional basedir as the exe dir if ( CommandLine()->FindParm( "-basedir" ) ) { strcpy( exedir, CommandLine()->ParmValue( "-basedir", "" ) ); } } Q_FixSlashes( exedir ); // Return the bin directory as the executable dir if it's not in there // because that's really where we're running from... char ext[MAX_PATH]; Q_StrRight( exedir, 4, ext, sizeof( ext ) ); if ( ext[0] != CORRECT_PATH_SEPARATOR || Q_stricmp( ext+1, "bin" ) != 0 ) { Q_strncat( exedir, CORRECT_PATH_SEPARATOR_S, exeDirLen, COPY_ALL_CHARACTERS ); Q_strncat( exedir, "bin", exeDirLen, COPY_ALL_CHARACTERS ); Q_FixSlashes( exedir ); } return true; }
static int luasrc_include (lua_State *L) { lua_Debug ar1; lua_getstack(L, 1, &ar1); lua_getinfo(L, "f", &ar1); lua_Debug ar2; lua_getinfo(L, ">S", &ar2); int iLength = Q_strlen( ar2.source ); char source[MAX_PATH]; Q_StrRight( ar2.source, iLength-1, source, sizeof( source ) ); Q_StripFilename( source ); char filename[MAX_PATH]; Q_snprintf( filename, sizeof( filename ), "%s\\%s", source, luaL_checkstring(L, 1) ); luasrc_dofile(L, filename); return 0; }
void FileSystem_SetupStandardDirectories( const char *pFilename, const char *pGameInfoPath ) { // Set qdir. if ( !pFilename ) { pFilename = "."; } Q_MakeAbsolutePath( qdir, sizeof( qdir ), pFilename, NULL ); Q_StripFilename( qdir ); Q_strlower( qdir ); if ( qdir[0] != 0 ) { Q_AppendSlash( qdir, sizeof( qdir ) ); } // Set gamedir. Q_MakeAbsolutePath( gamedir, sizeof( gamedir ), pGameInfoPath ); Q_AppendSlash( gamedir, sizeof( gamedir ) ); }
//----------------------------------------------------------------------------- // Adds the platform folder to the search path. //----------------------------------------------------------------------------- void FileSystem_AddSearchPath_Platform( IFileSystem *pFileSystem, const char *szGameInfoPath ) { char platform[MAX_PATH]; if ( pFileSystem->IsSteam() ) { // Steam doesn't support relative paths Q_strncpy( platform, "platform", MAX_PATH ); } else { if ( !Sys_GetExecutableName( platform, sizeof( platform ) ) ) { // fall back to old method if we can't get the executable name Q_strncpy( platform, szGameInfoPath, MAX_PATH ); Q_StripTrailingSlash( platform ); Q_strncat( platform, "/../platform", MAX_PATH, MAX_PATH ); } else { Q_StripFilename( platform ); Q_StripTrailingSlash( platform ); Q_FixSlashes( platform ); // remove bin folder if necessary int nLen = Q_strlen( platform ); if ( ( nLen > 4 ) && platform[ nLen - 4 ] == CORRECT_PATH_SEPARATOR && !Q_stricmp( "bin", platform + ( nLen - 3 ) ) ) { Q_StripLastDir( platform, sizeof( platform ) ); Q_StripTrailingSlash( platform ); } // go into platform folder Q_strncat( platform, "/platform", MAX_PATH, MAX_PATH ); } } pFileSystem->AddSearchPath( platform, "PLATFORM" ); }
int main(int argc, char* argv[]) { char dllName[512]; bool bUseDefault = true; CommandLine()->CreateCmdLine( argc, argv ); // check whether they used the -both switch. If this is specified, vrad will be run // twice, once with -hdr and once without int both_arg=0; for(int arg=1;arg<argc;arg++) if (Q_stricmp(argv[arg],"-both")==0) { both_arg=arg; } char fullPath[512], redirectFilename[512]; MakeFullPath( argv[0], fullPath, sizeof( fullPath ) ); Q_StripFilename( fullPath ); Q_snprintf( redirectFilename, sizeof( redirectFilename ), "%s\\%s", fullPath, "vrad.redirect" ); // First, look for vrad.redirect and load the dll specified in there if possible. CSysModule *pModule = NULL; FILE *fp = fopen( redirectFilename, "rt" ); if ( fp ) { if ( fgets( dllName, sizeof( dllName ), fp ) ) { char *pEnd = strstr( dllName, "\n" ); if ( pEnd ) *pEnd = 0; pModule = Sys_LoadModule( dllName ); if ( pModule ) printf( "Loaded alternate VRAD DLL (%s) specified in vrad.redirect.\n", dllName ); else printf( "Can't find '%s' specified in vrad.redirect.\n", dllName ); } fclose( fp ); } int returnValue; for(int mode=0;mode<2;mode++) { if (mode && (! both_arg)) continue; // If it didn't load the module above, then use the if ( !pModule ) { strcpy( dllName, "vrad.dll" ); pModule = Sys_LoadModule( dllName ); } if( !pModule ) { printf( "vrad_launcher error: can't load %s\n%s", dllName, GetLastErrorString() ); return 1; } CreateInterfaceFn fn = Sys_GetFactory( pModule ); if( !fn ) { printf( "vrad_launcher error: can't get factory from vrad.dll\n" ); Sys_UnloadModule( pModule ); return 2; } int retCode = 0; IVRadDLL *pDLL = (IVRadDLL*)fn( VRAD_INTERFACE_VERSION, &retCode ); if( !pDLL ) { printf( "vrad_launcher error: can't get IVRadDLL interface from vrad.dll\n" ); Sys_UnloadModule( pModule ); return 3; } if (both_arg) strcpy(argv[both_arg],(mode)?"-hdr":"-ldr"); returnValue = pDLL->main( argc, argv ); Sys_UnloadModule( pModule ); pModule=0; } return returnValue; }
int main( int argc, char *argv[] ) { if ( argc < 2 ) { Msg("Usage:\nmakephx [options] <FILESPEC>\ne.g. makephx [-r] *.phy\n"); return 0; } CommandLine()->CreateCmdLine( argc, argv ); g_bRecursive = CommandLine()->FindParm("-r") > 0 ? true : false; g_bQuiet = CommandLine()->FindParm("-quiet") > 0 ? true : false; InitFilesystem( "*.*" ); InitVPhysics(); // disable automatic packing, we want to do this ourselves. physcollision->SetPackOnLoad( false ); MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false ); InstallSpewFunction(); g_pModelConfig = new KeyValues("config"); g_pModelConfig->LoadFromFile( g_pFullFileSystem, "phx.cfg", "GAME" ); g_TotalOut = 0; g_TotalCompress = 0; FileFindHandle_t handle; char fullpath[1024], currentFile[1024], dirName[1024], nameext[256]; strcpy( fullpath, argv[argc-1] ); strcpy( fullpath, ExpandPath( fullpath ) ); strcpy( fullpath, ExpandArg( fullpath ) ); Q_strncpy(dirName, fullpath, sizeof(dirName)); Q_StripFilename(dirName); Q_strncpy(nameext, fullpath + strlen(dirName)+1, sizeof(nameext)); CUtlVector< const char * > directoryList; directoryList.AddToTail( strdup(dirName) ); int current = 0; int count = 0; do { if ( g_bRecursive ) { MakeFilename( currentFile, sizeof(currentFile), directoryList[current], "*.*" ); const char *pFilename = g_pFullFileSystem->FindFirst( currentFile, &handle ); while ( pFilename ) { if ( pFilename[0] != '.' && g_pFullFileSystem->FindIsDirectory( handle ) ) { MakeDirname( currentFile, sizeof(currentFile), directoryList[current], pFilename ); directoryList.AddToTail(strdup(currentFile)); } pFilename = g_pFullFileSystem->FindNext( handle ); } g_pFullFileSystem->FindClose( handle ); } MakeFilename(currentFile, sizeof(currentFile), directoryList[current], nameext); const char *pFilename = g_pFullFileSystem->FindFirst( currentFile, &handle ); while ( pFilename ) { phyfile_t phy; MakeFilename(currentFile, sizeof(currentFile), directoryList[current], pFilename); LoadPHYFile( &phy, currentFile ); if ( phy.collide.isPacked || phy.collide.solidCount < 1 ) { Msg("%s is not a valid PHY file\n", currentFile ); } else { WritePHXFile( currentFile, phy ); count++; } UnloadPHYFile( &phy ); pFilename = g_pFullFileSystem->FindNext( handle ); } g_pFullFileSystem->FindClose( handle ); current++; } while( current < directoryList.Count() ); if ( count ) { if (!g_bQuiet) { Msg("\n------\nTotal %s, %s\nSaved %s\n", Q_pretifymem( g_TotalOut ), Q_pretifymem( g_TotalCompress ), Q_pretifymem( g_TotalOut - g_TotalCompress ) ); Msg("%.2f%% savings\n", ((float)(g_TotalOut-g_TotalCompress) / (float)g_TotalOut) * 100.0f ); } } else { Msg("No files found in %s!\n", directoryList[current] ); } return 0; }
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; }
int main(int argc, char* argv[]) { char dllName[512]; Pause(); CommandLine()->CreateCmdLine( argc, argv ); char fullPath[512], redirectFilename[512]; MakeFullPath( argv[0], fullPath, sizeof( fullPath ) ); Q_StripFilename( fullPath ); Q_snprintf( redirectFilename, sizeof( redirectFilename ), "%s\\%s", fullPath, "vrad.redirect" ); Pause(); // First, look for vrad.redirect and load the dll specified in there if possible. CSysModule *pModule = NULL; FILE *fp = fopen( redirectFilename, "rt" ); if ( fp ) { if ( fgets( dllName, sizeof( dllName ), fp ) ) { char *pEnd = strstr( dllName, "\n" ); if ( pEnd ) *pEnd = 0; pModule = Sys_LoadModule( dllName ); if ( pModule ) printf( "Loaded alternate VRAD DLL (%s) specified in vrad.redirect.\n", dllName ); else printf( "Can't find '%s' specified in vrad.redirect.\n", dllName ); } fclose( fp ); } Pause(); // If it didn't load the module above, then use the if ( !pModule ) { strcpy( dllName, "shadercompile_dll.dll" ); pModule = Sys_LoadModule( dllName ); } Pause(); if( !pModule ) { printf( "vrad_launcher error: can't load %s\n%s", dllName, GetLastErrorString() ); Pause(); return 1; } Pause(); CreateInterfaceFn fn = Sys_GetFactory( pModule ); if( !fn ) { printf( "vrad_launcher error: can't get factory from vrad_dll.dll\n" ); Sys_UnloadModule( pModule ); return 2; } int retCode = 0; IShaderCompileDLL *pDLL = (IShaderCompileDLL*)fn( SHADER_COMPILE_INTERFACE_VERSION, &retCode ); if( !pDLL ) { printf( "vrad_launcher error: can't get IVRadDLL interface from vrad_dll.dll\n" ); Sys_UnloadModule( pModule ); return 3; } int returnValue = pDLL->main( argc, argv ); Sys_UnloadModule( pModule ); return returnValue; }
bool FileSystem_Init_Normal( const char *pFilename, FSInitType_t initType, bool bOnlyUseDirectoryName ) { if ( initType == FS_INIT_FULL ) { // First, get the name of the module char fileSystemDLLName[MAX_PATH]; bool bSteam; if ( FileSystem_GetFileSystemDLLName( fileSystemDLLName, MAX_PATH, bSteam ) != FS_OK ) return false; // If we're under Steam we need extra setup to let us find the proper modules FileSystem_SetupSteamInstallPath(); // Next, load the module, call Connect/Init. CFSLoadModuleInfo loadModuleInfo; loadModuleInfo.m_pFileSystemDLLName = fileSystemDLLName; loadModuleInfo.m_pDirectoryName = pFilename; loadModuleInfo.m_bOnlyUseDirectoryName = bOnlyUseDirectoryName; loadModuleInfo.m_ConnectFactory = Sys_GetFactoryThis(); loadModuleInfo.m_bSteam = bSteam; loadModuleInfo.m_bToolsMode = true; if ( FileSystem_LoadFileSystemModule( loadModuleInfo ) != FS_OK ) return false; // Next, mount the content CFSMountContentInfo mountContentInfo; mountContentInfo.m_pDirectoryName= loadModuleInfo.m_GameInfoPath; mountContentInfo.m_pFileSystem = loadModuleInfo.m_pFileSystem; mountContentInfo.m_bToolsMode = true; if ( FileSystem_MountContent( mountContentInfo ) != FS_OK ) return false; // Finally, load the search paths. CFSSearchPathsInit searchPathsInit; searchPathsInit.m_pDirectoryName = loadModuleInfo.m_GameInfoPath; searchPathsInit.m_pFileSystem = loadModuleInfo.m_pFileSystem; if ( FileSystem_LoadSearchPaths( searchPathsInit ) != FS_OK ) return false; // Store the data we got from filesystem_init. g_pFileSystem = g_pFullFileSystem = loadModuleInfo.m_pFileSystem; g_pFullFileSystemModule = loadModuleInfo.m_pModule; FileSystem_AddSearchPath_Platform( g_pFullFileSystem, loadModuleInfo.m_GameInfoPath ); // Set qdir. if ( !pFilename ) pFilename = "."; Q_MakeAbsolutePath( qdir, sizeof( qdir ), pFilename, NULL ); Q_StripFilename( qdir ); strlwr( qdir ); if ( qdir[0] != 0 ) Q_AppendSlash( qdir, sizeof( qdir ) ); // Set gamedir. Q_MakeAbsolutePath( gamedir, sizeof( gamedir ), loadModuleInfo.m_GameInfoPath ); Q_AppendSlash( gamedir, sizeof( gamedir ) ); } else { if ( !Sys_LoadInterface( "filesystem_stdio", FILESYSTEM_INTERFACE_VERSION, &g_pFullFileSystemModule, (void**)&g_pFullFileSystem ) ) { return false; } if ( g_pFullFileSystem->Init() != INIT_OK ) return false; g_pFullFileSystem->RemoveAllSearchPaths(); g_pFullFileSystem->AddSearchPath( "../platform", "PLATFORM" ); g_pFullFileSystem->AddSearchPath( ".", "GAME" ); g_pFileSystem = g_pFullFileSystem; } 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 RunCommands(CCommandArray& Commands, LPCTSTR pszOrigDocName) { s_bRunsCommands = true; char szCurDir[MAX_PATH]; _getcwd(szCurDir, MAX_PATH); procWnd.GetReady(); // cut up document name into file and extension components. // create two sets of buffers - one set with the long filename // and one set with the 8.3 format. char szDocLongPath[MAX_PATH] = {0}, szDocLongName[MAX_PATH] = {0}, szDocLongExt[MAX_PATH] = {0}; char szDocShortPath[MAX_PATH] = {0}, szDocShortName[MAX_PATH] = {0}, szDocShortExt[MAX_PATH] = {0}; GetFullPathName(pszOrigDocName, MAX_PATH, szDocLongPath, NULL); GetShortPathName(pszOrigDocName, szDocShortPath, MAX_PATH); // split them up char *p = strrchr(szDocLongPath, '.'); if(p && strrchr(szDocLongPath, '\\') < p && strrchr(szDocLongPath, '/') < p) { // got the extension strcpy(szDocLongExt, p+1); p[0] = 0; } p = strrchr(szDocLongPath, '\\'); if(!p) p = strrchr(szDocLongPath, '/'); if(p) { // got the filepart strcpy(szDocLongName, p+1); p[0] = 0; } // split the short part up p = strrchr(szDocShortPath, '.'); if(p && strrchr(szDocShortPath, '\\') < p && strrchr(szDocShortPath, '/') < p) { // got the extension strcpy(szDocShortExt, p+1); p[0] = 0; } p = strrchr(szDocShortPath, '\\'); if(!p) p = strrchr(szDocShortPath, '/'); if(p) { // got the filepart strcpy(szDocShortName, p+1); p[0] = 0; } int iSize = Commands.GetSize(), i = 0; char *ppParms[32]; while(iSize--) { CCOMMAND &cmd = Commands[i++]; // anything there? if((!cmd.szRun[0] && !cmd.iSpecialCmd) || !cmd.bEnable) continue; // set name pointers for long filenames pszDocExt = szDocLongExt; pszDocName = szDocLongName; pszDocPath = szDocLongPath; char szNewParms[MAX_PATH*5], szNewRun[MAX_PATH*5]; // HACK: force the spawnv call for launching the game if (!Q_stricmp(cmd.szRun, "$game_exe")) { cmd.bUseProcessWnd = FALSE; } FixGameVars(cmd.szRun, szNewRun, TRUE); FixGameVars(cmd.szParms, szNewParms, TRUE); CString strTmp; strTmp.Format("\r\n" "** Executing...\r\n" "** Command: %s\r\n" "** Parameters: %s\r\n\r\n", szNewRun, szNewParms); procWnd.Append(strTmp); // create a parameter list (not always required) if(!cmd.bUseProcessWnd || cmd.iSpecialCmd) { char *p = szNewParms; ppParms[0] = szNewRun; int iArg = 1; BOOL bDone = FALSE; while(p[0]) { ppParms[iArg++] = p; while(p[0]) { if(p[0] == ' ') { // found a space-separator p[0] = 0; p++; // skip remaining white space while (*p == ' ') p++; break; } // found the beginning of a quoted parameters if(p[0] == '\"') { while(1) { p++; if(p[0] == '\"') { // found the end if(p[1] == 0) bDone = TRUE; p[1] = 0; // kick its ass p += 2; // skip remaining white space while (*p == ' ') p++; break; } } break; } // else advance p ++p; } if(!p[0] || bDone) break; // done. } ppParms[iArg] = NULL; if(cmd.iSpecialCmd) { BOOL bError = FALSE; LPCTSTR pszError = ""; if(cmd.iSpecialCmd == CCCopyFile && iArg == 3) { RemoveQuotes(ppParms[1]); RemoveQuotes(ppParms[2]); // don't copy if we're already there if (stricmp(ppParms[1], ppParms[2]) && (!CopyFile(ppParms[1], ppParms[2], FALSE))) { bError = TRUE; pszError = GetErrorString(); } } else if(cmd.iSpecialCmd == CCDelFile && iArg == 2) { RemoveQuotes(ppParms[1]); if(!DeleteFile(ppParms[1])) { bError = TRUE; pszError = GetErrorString(); } } else if(cmd.iSpecialCmd == CCRenameFile && iArg == 3) { RemoveQuotes(ppParms[1]); RemoveQuotes(ppParms[2]); if(rename(ppParms[1], ppParms[2])) { bError = TRUE; pszError = strerror(errno); } } else if(cmd.iSpecialCmd == CCChangeDir && iArg == 2) { RemoveQuotes(ppParms[1]); if(mychdir(ppParms[1]) == -1) { bError = TRUE; pszError = strerror(errno); } } if(bError) { CString str; str.Format("The command failed. Windows reported the error:\r\n" " \"%s\"\r\n", pszError); procWnd.Append(str); procWnd.SetForegroundWindow(); str += "\r\nDo you want to continue?"; if(AfxMessageBox(str, MB_YESNO) == IDNO) break; } } else { // Change to the game exe folder before spawning the engine. // This is necessary for Steam to find the correct Steam DLL (it // uses the current working directory to search). char szDir[MAX_PATH]; Q_strncpy(szDir, szNewRun, sizeof(szDir)); Q_StripFilename(szDir); mychdir(szDir); // YWB Force asynchronous operation so that engine doesn't hang on // exit??? Seems to work. // spawnv doesn't like quotes RemoveQuotes(szNewRun); _spawnv(/*cmd.bNoWait ?*/ _P_NOWAIT /*: P_WAIT*/, szNewRun, (const char *const *)ppParms); } } else { procWnd.Execute(szNewRun, szNewParms); } // check for existence? if(cmd.bEnsureCheck) { char szFile[MAX_PATH]; FixGameVars(cmd.szEnsureFn, szFile, FALSE); if(GetFileAttributes(szFile) == 0xFFFFFFFF) { // not there! CString str; str.Format("The file '%s' was not built.\n" "Do you want to continue?", szFile); procWnd.SetForegroundWindow(); if(AfxMessageBox(str, MB_YESNO) == IDNO) break; // outta here } } } mychdir(szCurDir); s_bRunsCommands = false; return TRUE; }