static FSReturnCode_t TryLocateGameInfoFile( char *pOutDir, int outDirLen, bool bBubbleDir )
{
// Retain a copy of suggested path for further attempts
CArrayAutoPtr < char > spchCopyNameBuffer( new char [ outDirLen ] );
Q_strncpy( spchCopyNameBuffer.Get(), pOutDir, outDirLen );
spchCopyNameBuffer[ outDirLen - 1 ] = 0;
// Make appropriate slashes ('/' - Linux style)
for ( char *pchFix = spchCopyNameBuffer.Get(),
*pchEnd = pchFix + outDirLen;
pchFix < pchEnd; ++ pchFix )
{
if ( '\\' == *pchFix )
{
*pchFix = '/';
}
}
// Have a look in supplied path
do
{
if ( DoesFileExistIn( pOutDir, GAMEINFO_FILENAME ) )
{
return FS_OK;
}
if ( IsX360() && DoesFileExistIn( pOutDir, GAMEINFO_FILENAME_ALTERNATE ) )
{
return FS_OK;
}
}
while ( bBubbleDir && Q_StripLastDir( pOutDir, outDirLen ) );
// Make an attempt to resolve from "content -> game" directory
Q_strncpy( pOutDir, spchCopyNameBuffer.Get(), outDirLen );
pOutDir[ outDirLen - 1 ] = 0;
if ( char *pchContentFix = Q_stristr( pOutDir, "/content/" ) )
{
sprintf( pchContentFix, "/game/" );
memmove( pchContentFix + 6, pchContentFix + 9, pOutDir + outDirLen - (pchContentFix + 9) );
// Try in the mapped "game" directory
do
{
if ( DoesFileExistIn( pOutDir, GAMEINFO_FILENAME ) )
{
return FS_OK;
}
if ( IsX360() && DoesFileExistIn( pOutDir, GAMEINFO_FILENAME_ALTERNATE ) )
{
return FS_OK;
}
}
while ( bBubbleDir && Q_StripLastDir( pOutDir, outDirLen ) );
}
// Could not find it here
return FS_MISSING_GAMEINFO_FILE;
}
FSReturnCode_t GetSteamCfgPath( char *steamCfgPath, int steamCfgPathLen )
{
steamCfgPath[0] = 0;
char executablePath[MAX_PATH];
if ( !FileSystem_GetExecutableDir( executablePath, sizeof( executablePath ) ) )
{
return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetExecutableDir failed." );
}
Q_strncpy( steamCfgPath, executablePath, steamCfgPathLen );
while ( 1 )
{
if ( DoesFileExistIn( steamCfgPath, "steam.cfg" ) )
break;
if ( !Q_StripLastDir( steamCfgPath, steamCfgPathLen) )
{
// the file isnt found, thats ok, its not mandatory
return FS_OK;
}
}
Q_AppendSlash( steamCfgPath, steamCfgPathLen );
Q_strncat( steamCfgPath, "steam.cfg", steamCfgPathLen, COPY_ALL_CHARACTERS );
return FS_OK;
}
FSReturnCode_t SetSteamInstallPath( char *steamInstallPath, int steamInstallPathLen, CSteamEnvVars &steamEnvVars, bool bErrorsAsWarnings )
{
if ( IsConsole() )
{
// consoles don't use steam
return FS_MISSING_STEAM_DLL;
}
// Start at our bin directory and move up until we find a directory with steam.dll in it.
char executablePath[MAX_PATH];
if ( !FileSystem_GetExecutableDir( executablePath, sizeof( executablePath ) ) )
{
if ( bErrorsAsWarnings )
{
Warning( "SetSteamInstallPath: FileSystem_GetExecutableDir failed.\n" );
return FS_INVALID_PARAMETERS;
}
else
{
return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetExecutableDir failed." );
}
}
Q_strncpy( steamInstallPath, executablePath, steamInstallPathLen );
while ( 1 )
{
// Ignore steamapp.cfg here in case they're debugging. We still need to know the real steam path so we can find their username.
// find
if ( DoesFileExistIn( steamInstallPath, "steam.dll" ) && !DoesFileExistIn( steamInstallPath, "steamapp.cfg" ) )
break;
if ( !Q_StripLastDir( steamInstallPath, steamInstallPathLen ) )
{
if ( bErrorsAsWarnings )
{
Warning( "Can't find steam.dll relative to executable path: %s.\n", executablePath );
return FS_MISSING_STEAM_DLL;
}
else
{
return SetupFileSystemError( false, FS_MISSING_STEAM_DLL, "Can't find steam.dll relative to executable path: %s.", executablePath );
}
}
}
// Also, add the install path to their PATH environment variable, so filesystem_steam.dll can get to steam.dll.
char szPath[ 8192 ];
steamEnvVars.m_Path.GetValue( szPath, sizeof( szPath ) );
if ( !DoesPathExistAlready( szPath, steamInstallPath ) )
{
steamEnvVars.m_Path.SetValue( "%s;%s", szPath, steamInstallPath );
}
return FS_OK;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : const char
//-----------------------------------------------------------------------------
const char *GetBaseDirectory( void )
{
static char path[MAX_PATH] = {0};
if ( path[0] == 0 )
{
GetModuleFileName( (HMODULE)GetAppInstance(), path, sizeof( path ) );
Q_StripLastDir( path, sizeof( path ) ); // Get rid of the filename.
Q_StripTrailingSlash( path );
}
return path;
}
void CopyDev()
{
FileFindHandle_t handle;
char steamappsPath[MAX_PATH*4];
const char *pszGameDir = engine->GetGameDirectory();
Q_strcpy( steamappsPath, pszGameDir );
Q_StripLastDir( steamappsPath, sizeof(steamappsPath) );
Q_StripLastDir( steamappsPath, sizeof(steamappsPath) );
char searchPath[MAX_PATH*4];
Q_snprintf( searchPath, sizeof(searchPath), "%s\\shaders\\fxc\\*", pszGameDir );
Q_FixSlashes( searchPath );
Msg( "searching for shaders in: %s\n", searchPath );
const char *pszName = g_pFullFileSystem->FindFirst( searchPath, &handle );
while ( pszName != NULL )
{
if ( Q_strlen( pszName ) > 4 )
{
char filename[MAX_PATH];
Q_FileBase( pszName, filename, sizeof( filename ) );
char filepath_src[MAX_PATH];
char filepath_dst[MAX_PATH];
Q_snprintf( filepath_src, sizeof( filepath_src ), "%s\\shaders\\fxc\\%s.vcs\0", pszGameDir, filename );
Q_snprintf( filepath_dst, sizeof( filepath_dst ), "%s\\common\\alien swarm\\platform\\shaders\\fxc\\%s.vcs\0", steamappsPath, filename );
Q_FixSlashes( filepath_src );
Q_FixSlashes( filepath_dst );
Msg( "%s --> %s\n", filepath_src, filepath_dst );
engine->CopyFile( filepath_src, filepath_dst );
}
pszName = g_pFullFileSystem->FindNext( handle );
}
g_pFullFileSystem->FindClose( handle );
}
//-----------------------------------------------------------------------------
// Purpose: Add a new configuration with proper defaults to a keyvalue block
//-----------------------------------------------------------------------------
bool AddConfig( int configID )
{
// Find the games block of the keyvalues
KeyValues *gameBlock = g_ConfigManager.GetGameBlock();
if ( gameBlock == NULL )
{
Assert( 0 );
return false;
}
// Set to defaults
defaultConfigInfo_t newInfo;
memset( &newInfo, 0, sizeof( newInfo ) );
// Data for building the new configuration
const char *pModName = g_Configs[configID]->m_Name.Base();
const char *pModDirectory = g_Configs[configID]->m_ModDir.Base();
// Mod name
Q_strncpy( newInfo.gameName, pModName, sizeof( newInfo.gameName ) );
// FGD
Q_strncpy( newInfo.FGD, "base.fgd", sizeof( newInfo.FGD ) );
// Get the base directory
Q_FileBase( pModDirectory, newInfo.gameDir, sizeof( newInfo.gameDir ) );
// Default executable
Q_strncpy( newInfo.exeName, "hl2.exe", sizeof( newInfo.exeName ) );
char szPath[MAX_PATH];
Q_strncpy( szPath, pModDirectory, sizeof( szPath ) );
Q_StripLastDir( szPath, sizeof( szPath ) );
Q_StripTrailingSlash( szPath );
char fullDir[MAX_PATH];
g_ConfigManager.GetRootGameDirectory( fullDir, sizeof( fullDir ), g_ConfigManager.GetRootDirectory(), "half-life 2" );
return g_ConfigManager.AddDefaultConfig( newInfo, gameBlock, szPath, fullDir );
}
//-----------------------------------------------------------------------------
// 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" );
}
FSReturnCode_t SetSteamInstallPath( char *steamInstallPath, int steamInstallPathLen, CSteamEnvVars &steamEnvVars, bool bErrorsAsWarnings )
{
if ( IsConsole() )
{
// consoles don't use steam
return FS_MISSING_STEAM_DLL;
}
if ( IsPosix() )
return FS_OK; // under posix the content does not live with steam.dll up the path, rely on the environment already being set by steam
// Start at our bin directory and move up until we find a directory with steam.dll in it.
char executablePath[MAX_PATH];
if ( !FileSystem_GetExecutableDir( executablePath, sizeof( executablePath ) ) )
{
if ( bErrorsAsWarnings )
{
Warning( "SetSteamInstallPath: FileSystem_GetExecutableDir failed.\n" );
return FS_INVALID_PARAMETERS;
}
else
{
return SetupFileSystemError( false, FS_INVALID_PARAMETERS, "FileSystem_GetExecutableDir failed." );
}
}
Q_strncpy( steamInstallPath, executablePath, steamInstallPathLen );
#ifdef WIN32
const char *pchSteamDLL = "steam.dll";
#elif defined(OSX)
// under osx the bin lives in the bin/ folder, so step back one
Q_StripLastDir( steamInstallPath, steamInstallPathLen );
const char *pchSteamDLL = "libsteam.dylib";
#elif defined(LINUX)
// under linux the bin lives in the bin/ folder, so step back one
Q_StripLastDir( steamInstallPath, steamInstallPathLen );
const char *pchSteamDLL = "libsteam.so";
#else
#error
#endif
while ( 1 )
{
// Ignore steamapp.cfg here in case they're debugging. We still need to know the real steam path so we can find their username.
// find
if ( DoesFileExistIn( steamInstallPath, pchSteamDLL ) && !DoesFileExistIn( steamInstallPath, "steamapp.cfg" ) )
break;
if ( !Q_StripLastDir( steamInstallPath, steamInstallPathLen ) )
{
if ( bErrorsAsWarnings )
{
Warning( "Can't find %s relative to executable path: %s.\n", pchSteamDLL, executablePath );
return FS_MISSING_STEAM_DLL;
}
else
{
return SetupFileSystemError( false, FS_MISSING_STEAM_DLL, "Can't find %s relative to executable path: %s.", pchSteamDLL, executablePath );
}
}
}
// Also, add the install path to their PATH environment variable, so filesystem_steam.dll can get to steam.dll.
char szPath[ 8192 ];
steamEnvVars.m_Path.GetValue( szPath, sizeof( szPath ) );
if ( !DoesPathExistAlready( szPath, steamInstallPath ) )
{
#ifdef WIN32
#define PATH_SEP ";"
#else
#define PATH_SEP ":"
#endif
steamEnvVars.m_Path.SetValue( "%s%s%s", szPath, PATH_SEP, steamInstallPath );
}
return FS_OK;
}
void ParseFilesFromResList( UnusedContent::CUtlSymbol & resfilesymbol, CUtlRBTree< ReferencedFile, int >& files, char const *resfile )
{
int addedStrings = 0;
int resourcesConsidered = 0;
int offset = Q_strlen( gamedir );
char basedir[MAX_PATH];
Q_strncpy( basedir, gamedir, sizeof( basedir ) );
if ( !Q_StripLastDir( basedir, sizeof( basedir ) ) )
Error( "Can't get basedir from %s.", gamedir );
FileHandle_t resfilehandle;
resfilehandle = g_pFileSystem->Open( resfile, "rb" );
if ( FILESYSTEM_INVALID_HANDLE != resfilehandle )
{
// Read in the entire file
int length = g_pFileSystem->Size(resfilehandle);
if ( length > 0 )
{
char *pStart = (char *)new char[ length + 1 ];
if ( pStart && ( length == g_pFileSystem->Read(pStart, length, resfilehandle) ) )
{
pStart[ length ] = 0;
char *pFileList = pStart;
char token[512];
while ( 1 )
{
pFileList = ParseFile( pFileList, token, NULL );
if ( !pFileList )
break;
if ( strlen( token ) > 0 )
{
char szFileName[ 256 ];
Q_snprintf( szFileName, sizeof( szFileName ), "%s%s", basedir, token );
_strlwr( szFileName );
Q_FixSlashes( szFileName );
while ( szFileName[ strlen( szFileName ) - 1 ] == '\n' ||
szFileName[ strlen( szFileName ) - 1 ] == '\r' )
{
szFileName[ strlen( szFileName ) - 1 ] = 0;
}
if ( Q_strnicmp( szFileName, gamedir, offset ) )
continue;
char *pFile = szFileName + offset;
++resourcesConsidered;
ReferencedFile rf;
rf.sym = g_Analysis.symbols.AddString( pFile );
int idx = files.Find( rf );
if ( idx == files.InvalidIndex() )
{
++addedStrings;
rf.maplist.AddToTail( resfilesymbol );
files.Insert( rf );
}
else
{
//
ReferencedFile & slot = files[ idx ];
if ( slot.maplist.Find( resfilesymbol ) == slot.maplist.InvalidIndex() )
{
slot.maplist.AddToTail( resfilesymbol );
}
}
}
}
}
delete[] pStart;
}
g_pFileSystem->Close(resfilehandle);
}
int filesFound = addedStrings;
vprint( 1, "Found %i new resources (%i total) in %s\n", filesFound, resourcesConsidered, resfile );
}