#pragma warning(disable:4115)
#pragma warning(disable:4100)
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <windows.h>
#include <io.h>
#include "Steam.h"
#include "SteamLib.h"
#include <sys/stat.h>
#include <assert.h>
static TSteamError g_tLastError;
static TSteamError g_tLastErrorNoFile;
static FILE *g_pLastErrorFile = NULL;
int STEAMprogressCounter;
int STEAMtrackingProgress;
void (*AppProgressCallback)(void);
int AppProgressCallbackFreq;
void (*AppKeepAliveTicCallback)(char* scr_msg);
#define FORCE_KEEPALIVE_TIC_READ_SIZE 131072
// TODO: remove the following function, it's NOT Steam generic.
void FixSlashes( char *pszName )
{
while ( *pszName ) {
if ( *pszName == '/' )
*pszName = '\\';
pszName++;
}
}
/*
**------------------------------------------------------------------------ -
** DoEventTic()
**
** If the app has told us to provide keep-alive type tics, do so here.
**
**------------------------------------------------------------------------ -
*/
static void DoEventTic(BOOL bForce)
{
#define EVENTS_TO_TIC 25
static long numEvents = 0;
static char *msg = NULL;
static BOOL bDoingTicEvent = FALSE;
// Have we seen enough events to update the app with tics?
// Also need to prevent recursion here as the game may read, etc while
// servicing the tic...
numEvents++;
if ( AppKeepAliveTicCallback && !bDoingTicEvent && (bForce || (numEvents % EVENTS_TO_TIC == 0)) )
{
// Prevent recursion...
bDoingTicEvent = TRUE;
// Send it back to the app.
AppKeepAliveTicCallback(msg);
bDoingTicEvent = FALSE;
}
}
void CheckError(FILE *fp, TSteamError *steamError)
{
if (fp)
{
if (steamError->eSteamError != eSteamErrorNone || g_tLastError.eSteamError != eSteamErrorNone)
{
g_pLastErrorFile = fp;
g_tLastError = *steamError;
}
}
else
{
// write to the NULL error checker
if (steamError->eSteamError != eSteamErrorNone || g_tLastErrorNoFile.eSteamError != eSteamErrorNone)
{
g_tLastErrorNoFile = *steamError;
}
}
}
/*****************************************************************/
/*****************************************************************/
// CLIB wrappers for system functions such as fopen, fread, etc.
/*****************************************************************/
/*****************************************************************/
/**************/
//STEAM_Startup
//Initializes the Steam VFS
/**************/
int STEAM_Startup(void)
{
TSteamError steamError;
int result;
SteamClearError(&steamError);
result = SteamStartup( (STEAM_USING_FILESYSTEM | STEAM_USING_LOGGING ), &steamError );
// result = SteamStartup( (STEAM_USING_FILESYSTEM | STEAM_USING_LOGGING | STEAM_USING_USERID | STEAM_USING_ACCOUNT), &steamError );
CheckError(NULL, &steamError);
return result;
}
/**************/
//STEAM_Mount
//Mounts the Steam VFS for a specific mount point
/**************/
int STEAM_Mount(const char *szMountPath)
{
TSteamError steamError;
int result;
steamError.eSteamError = eSteamErrorNone;
SteamClearError(&steamError);
// result = SteamMountAppFilesystem( szMountPath , &steamError );
result = SteamMountAppFilesystem( &steamError );
CheckError(NULL, &steamError);
return result;
}
/**************/
//STEAM_Unmount
//Unmounts the Steam VFS
/**************/
int STEAM_Unmount(void)
{
TSteamError steamError;
int result;
steamError.eSteamError = eSteamErrorNone;
SteamClearError(&steamError);
// result = SteamUnmountFilesystem(&steamError);
result = SteamUnmountAppFilesystem( &steamError );
CheckError(NULL, &steamError);
return result;
}
/**************/
//STEAM_Shutdown
//Terminates the Steam VFS
/**************/
void STEAM_Shutdown(void)
{
TSteamError steamError;
steamError.eSteamError = eSteamErrorNone;
SteamClearError(&steamError);
SteamCleanup(&steamError);
CheckError(NULL, &steamError);
}
/**************/
//STEAM_fopen
/**************/
FILE *STEAM_fopen(const char *filename, const char *options)
{
TSteamError steamError;
char wadName[_MAX_PATH];
SteamHandle_t hndl;
strcpy(wadName,filename);
FixSlashes(wadName);
#if 0
strlwr(wadName);
if ( strstr(wadName, "client.dll")
)
hndl = STEAM_INVALID_HANDLE; // convenient breakpoint spot...
#endif
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
hndl = SteamOpenFile(wadName, options, &steamError);
CheckError((FILE *)hndl, &steamError);
return (FILE *)hndl;
}
/**************/
//STEAM_tmpfile
/**************/
FILE *STEAM_tmpfile(void)
{
SteamHandle_t hndl;
TSteamError steamError;
hndl = SteamOpenTmpFile(&steamError);
CheckError((FILE *)hndl, &steamError);
return (FILE *)hndl;
}
/**************/
//STEAM_fread
/**************/
unsigned int STEAM_fread(void *buffer, unsigned int rdsize, unsigned int count,FILE *file)
{
SteamHandle_t hndl = (SteamHandle_t)file;
char* p = buffer;
unsigned int totalSizeRead = 0;
unsigned int bytesRead = 0;
unsigned int amtLeftToRead = rdsize * count;
unsigned int readBlockSize = 524288;
TSteamError steamError;
#if 0
if ( rdsize == 12 || count == 12 )
hndl = STEAM_INVALID_HANDLE; // convenient breakpoint spot...
#endif
while ( amtLeftToRead )
{
unsigned int numBytesToRead;
// Show progress...
if ( STEAMtrackingProgress && (amtLeftToRead > FORCE_KEEPALIVE_TIC_READ_SIZE) )
{
DoEventTic(TRUE);
}
// Read the next block
numBytesToRead = ( amtLeftToRead > readBlockSize ? readBlockSize : amtLeftToRead );
bytesRead = SteamReadFile(p, 1, numBytesToRead, hndl, &steamError);
// If we didn't read what we thought we should, we're done...
if ( bytesRead == 0 || (bytesRead != numBytesToRead && steamError.eSteamError != eSteamErrorEOF) )
break;
// If we had an error (not EOF) we're done...
if ( steamError.eSteamError != eSteamErrorNone && steamError.eSteamError != eSteamErrorEOF )
break;
// Update for next loop...
amtLeftToRead -= bytesRead; // what's left to read...
p += bytesRead; // where to put the next block of data...
totalSizeRead += bytesRead; // how much we've read so far.
}
CheckError((FILE *)hndl, &steamError);
return totalSizeRead / rdsize;
}
/**************/
//STEAM_fgetc
/**************/
int STEAM_fgetc(FILE *file)
{
unsigned char c;
if ( STEAM_fread(&c, 1, 1, file) != 1 )
c = (unsigned char)EOF;
return (int)c;
}
/**************/
//STEAM_fgets
/**************/
char *STEAM_fgets(char *string, int numCharToRead, FILE *stream)
{
unsigned char c;
int numCharRead = 0;
// Read at most n chars from the file or until a newline
*string = c = '\0';
while ( (numCharRead < numCharToRead-1) && (c != '\n') )
{
// Read in the next char...
if ( STEAM_fread(&c, 1, 1, stream) != 1 )
{
if ( g_tLastError.eSteamError != eSteamErrorEOF || numCharRead == 0 )
{
return NULL; // If we hit an error, return NULL.
}
numCharRead = numCharToRead; // Hit EOF, no more to read, all done...
}
else
{
*string++ = c; // add the char to the string and point to the next pos
*string = '\0'; // append NULL
numCharRead++; // count the char read
}
}
return string; // Has a NULL termination...
}
/**************/
//STEAM_fputc
/**************/
int STEAM_fputc(int c, FILE *stream)
{
unsigned char chr = (unsigned char)c;
SteamHandle_t hndl = (SteamHandle_t)stream;
int n;
TSteamError steamError;
n = SteamWriteFile(&chr, sizeof(chr), 1, hndl, &steamError);
if ( n != 1 || steamError.eSteamError != eSteamErrorNone )
{
CheckError((FILE *)hndl, &steamError);
return EOF;
}
return c;
}
/**************/
//STEAM_fputs
/**************/
int STEAM_fputs(const char *string, FILE *stream)
{
SteamHandle_t hndl = (SteamHandle_t)stream;
int len = strlen(string);
int n;
TSteamError steamError;
n = SteamWriteFile((void*)string, sizeof(char), len, hndl, &steamError);
if ( n != len || steamError.eSteamError != eSteamErrorNone )
{
CheckError((FILE *)hndl, &steamError);
return EOF;
}
return 1;
}
/**************/
//STEAM_fwrite
/**************/
unsigned int STEAM_fwrite(void *buffer, unsigned int wrsize, unsigned int count,FILE *file)
{
SteamHandle_t hndl = (SteamHandle_t)file;
TSteamError steamError;
int result;
result = SteamWriteFile(buffer, wrsize, count, hndl, &steamError);
CheckError((FILE *)hndl, &steamError);
return result;
}
/**************/
//STEAM_fprintf
/**************/
int STEAM_fprintf( FILE *fp, const char *format, ... )
{
int retval;
va_list argptr;
// Make sure world is sane...
if ( !fp || !format )
return -1;
// Init variable argument list.
va_start(argptr, format);
// Pass it all on...
retval = STEAM_vfprintf(fp, format, argptr);
// Clean up...
va_end(argptr);
return retval;
}
/**************/
//STEAM_vfprintf
//
// Yes...this sucks...but would rather malloc than try to guess what the
// largest formatted string will be and reserve that on the stack each
// time...so we're first vfprintf'ing to the NULL device to determine
// the length of the formatted string, and then mallocing a buffer to
// hold it for vsprintf.
//
/**************/
int STEAM_vfprintf( FILE *fp, const char *format, va_list argptr )
{
int blen, plen;
char *buf;
FILE *nullDeviceFP;
// Make sure world is sane...
if ( !fp || !format )
return -1;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
// Open the null device...used by vfprintf to determine the length of
// the formatted string.
nullDeviceFP = fopen("nul:", "w");
if ( !nullDeviceFP )
return -1;
// Figure out how long the formatted string will be...dump formatted
// string to the bit bucket.
blen = vfprintf(nullDeviceFP, format, argptr);
fclose(nullDeviceFP);
if ( !blen )
{
return -1;
}
// Get buffer in which to build the formatted string.
buf = (char *)malloc(blen+1);
if ( !buf )
{
return -1;
}
// Build the formatted string.
plen = vsprintf(buf, format, argptr);
va_end(argptr);
if ( plen != blen )
{
free(buf);
return -1;
}
// Write out the formatted string.
if ( plen != (int)STEAM_fwrite(buf, 1, plen, fp) )
{
free(buf);
return -1;
}
free(buf);
return plen;
}
/**************/
//STEAM_fclose
/**************/
int STEAM_fclose(FILE *file)
{
SteamHandle_t hndl = (SteamHandle_t)file;
TSteamError steamError;
int result;
result = SteamCloseFile(hndl, &steamError);
CheckError((FILE *)hndl, &steamError);
return result;
}
/**************/
//STEAM_fseek
/**************/
int STEAM_fseek(FILE *file, long offset, int method)
{
SteamHandle_t hndl = (SteamHandle_t)file;
ESteamSeekMethod seekMethod = (ESteamSeekMethod)method;
TSteamError steamError;
int result;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
result = SteamSeekFile(hndl, offset, seekMethod, &steamError);
CheckError((FILE *)hndl, &steamError);
return result;
}
/**************/
//STEAM_ftell
/**************/
long STEAM_ftell(FILE *file)
{
SteamHandle_t hndl = (SteamHandle_t)file;
long steam_offset;
TSteamError steamError;
// Determine the real file offset (as opposed to the logical offset represented by
// the fread buffer...)
steam_offset = SteamTellFile(hndl, &steamError);
if ( steamError.eSteamError != eSteamErrorNone )
{
CheckError((FILE *)hndl, &steamError);
return -1L;
}
return steam_offset;
}
/**************/
//STEAM_feof
/**************/
int STEAM_feof( FILE *stream )
{
// SteamHandle_t hndl = (SteamHandle_t)stream;
long orig_pos;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
// Figure out where in the file we currently are...
orig_pos = STEAM_ftell(stream);
if ( stream == g_pLastErrorFile && g_tLastError.eSteamError == eSteamErrorEOF )
return 1;
if ( g_tLastError.eSteamError != eSteamErrorNone )
return 0;
// Jump to the end...
if ( STEAM_fseek(stream, 0L, SEEK_END) != 0 )
return 0;
// If we were already at the end, return true
if ( orig_pos == STEAM_ftell(stream) )
return 1;
// Otherwise, go back to the original spot and return false.
STEAM_fseek(stream, orig_pos, SEEK_SET);
return 0;
}
/**************/
//STEAM_ferror
/**************/
int STEAM_ferror( FILE *stream )
{
if (stream)
{
if (stream != g_pLastErrorFile)
{
// it's asking for an error for a previous file, return no error
return 0;
}
return ( g_tLastError.eSteamError != eSteamErrorNone );
}
return g_tLastErrorNoFile.eSteamError != eSteamErrorNone;
}
/**************/
//STEAM_clearerr
/**************/
void STEAM_clearerr( FILE *stream )
{
SteamClearError(&g_tLastError);
return;
}
/**************/
//STEAM_ferror
/**************/
void STEAM_strerror( FILE *stream, char *p, int maxlen )
{
if ( p && maxlen > 0 )
{
if ( stream == NULL )
strncpy(p, g_tLastErrorNoFile.szDesc, maxlen);
else
strncpy(p, g_tLastError.szDesc, maxlen);
}
return;
}
/**************/
//STEAM_stat
/**************/
int STEAM_stat(const char *path, struct _stat *buf)
{
TSteamElemInfo Info;
int returnVal;
struct _stat tmpBuf;
TSteamError steamError;
char tmpPath[_MAX_PATH];
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
strcpy(tmpPath, path);
FixSlashes(tmpPath);
memset(buf, 0, sizeof(struct _stat));
returnVal= SteamStat(tmpPath, &Info, &steamError);
if ( returnVal == 0 )
{
if (Info.bIsDir )
{
buf->st_mode |= _S_IFDIR;
buf->st_size = 0;
}
else
{
buf->st_mode |= _S_IFREG;
buf->st_size = Info.uSizeOrCount;
}
buf->st_atime = Info.lLastAccessTime;
buf->st_mtime = Info.lLastModificationTime;
buf->st_ctime = Info.lCreationTime;
_stat(path, &tmpBuf);
}
CheckError(NULL, &steamError);
return returnVal;
}
/**************/
//STEAM_rewind
/**************/
void STEAM_rewind( FILE *stream )
{
STEAM_fseek(stream, 0L, SEEK_SET);
STEAM_clearerr(stream);
return;
}
/**************/
//STEAM_fflush
/**************/
int STEAM_fflush( FILE *stream )
{
TSteamError steamError;
SteamHandle_t hndl = (SteamHandle_t)stream;
int result = SteamFlushFile(hndl, &steamError);
CheckError((FILE *)hndl, &steamError);
return result;
}
/**************/
//STEAM_flushall
/**************/
int STEAM_flushall( void )
{
return 0; // hum...what to do here...we're not dealing with _fcloseall()...
}
/**************/
//STEAM_setbuf
/**************/
void STEAM_setbuf( FILE *stream, char *buffer)
{
TSteamError steamError;
SteamHandle_t hndl = (SteamHandle_t)stream;
if ( buffer == NULL )
SteamSetvBuf(hndl, NULL, eSteamBufferMethodNBF, 0, &steamError);
else
SteamSetvBuf(hndl, buffer, eSteamBufferMethodFBF, BUFSIZ, &steamError);
CheckError((FILE *)hndl, &steamError);
return;
}
/**************/
//STEAM_setvbuf
/**************/
int STEAM_setvbuf( FILE *stream, char *buffer, int mode, size_t size)
{
int retval = -1;
SteamHandle_t hndl = (SteamHandle_t)stream;
ESteamBufferMethod steamMode = eSteamBufferMethodFBF;
TSteamError steamError;
// Convert mode to Steam version...already set for _IOFBF.
if ( mode == _IONBF )
steamMode = eSteamBufferMethodNBF;
// We don't support _IOLBF.
if ( mode != _IOLBF )
{
retval = SteamSetvBuf(hndl, (void*)buffer, steamMode, size, &steamError);
CheckError((FILE *)hndl, &steamError);
}
return retval;
}
/**************/
//STEAM_FindFirstFile
/**************/
HANDLE STEAM_FindFirstFile(char *pszMatchName, STEAMFindFilter filter, WIN32_FIND_DATA *findInfo)
{
TSteamElemInfo steamFindInfo;
HANDLE hResult = INVALID_HANDLE_VALUE;
SteamHandle_t steamResult;
char tmpMatchName[_MAX_PATH];
TSteamError steamError;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
strcpy(tmpMatchName, pszMatchName);
FixSlashes(tmpMatchName);
steamResult = SteamFindFirst(tmpMatchName, (ESteamFindFilter)filter, &steamFindInfo, &steamError);
CheckError(NULL, &steamError);
if ( steamResult == STEAM_INVALID_HANDLE )
{
hResult = INVALID_HANDLE_VALUE;
}
else
{
hResult = (HANDLE)steamResult;
strcpy(findInfo->cFileName, steamFindInfo.cszName);
// NEED TO DEAL WITH THIS STUFF!!! FORTUNATELY HALF-LIFE DOESN'T USE ANY OF IT
// AND ARCANUM USES _findfirst() etc.
//
// findInfo->ftLastWriteTime = steamFindInfo.lLastModificationTime;
// findInfo->ftCreationTime = steamFindInfo.lCreationTime;
// findInfo->ftLastAccessTime = steamFindInfo.lLastAccessTime;
// findInfo->nFileSizeHigh = ;
// findInfo->nFileSizeLow = ;
// Determine if the found object is a directory...
if ( steamFindInfo.bIsDir )
findInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
else
findInfo->dwFileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY;
// Determine if the found object was local or remote.
// ***NOTE*** we are hijacking the FILE_ATTRIBUTE_OFFLINE bit and using it in a different
// (but similar) manner than the WIN32 documentation indicates ***NOTE***
if ( steamFindInfo.bIsLocal )
findInfo->dwFileAttributes &= ~FILE_ATTRIBUTE_OFFLINE;
else
findInfo->dwFileAttributes |= FILE_ATTRIBUTE_OFFLINE;
}
return hResult;
}
/**************/
//STEAM_FindNextFile
/**************/
int STEAM_FindNextFile(HANDLE dir, WIN32_FIND_DATA *findInfo)
{
TSteamElemInfo steamFindInfo;
SteamHandle_t hDir = (SteamHandle_t)dir;
int result;
TSteamError steamError;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
// STEAM return success per _findnext()...flip for FindNextFile()
result = (SteamFindNext(hDir, &steamFindInfo, &steamError) == 0);
CheckError(NULL, &steamError);
if ( result )
{
dir = (HANDLE)hDir;
strcpy(findInfo->cFileName, steamFindInfo.cszName);
if ( steamFindInfo.bIsDir )
findInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
else
findInfo->dwFileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY;
}
return result;
}
/**************/
//STEAM_FindClose
/**************/
int STEAM_FindClose(HANDLE dir)
{
SteamHandle_t hDir = (SteamHandle_t)dir;
int result;
TSteamError steamError;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
// STEAM return success per _findclose()...flip for FindClose()
result = (SteamFindClose(hDir, &steamError) == 0);
CheckError(NULL, &steamError);
return result;
}
/**************/
//STEAM_findfirst
/**************/
long STEAM_findfirst(char *pszMatchName, STEAMFindFilter filter, struct _finddata_t *fileinfo )
{
TSteamElemInfo steamFindInfo;
long hResult = -1;
SteamHandle_t steamResult;
char tmpMatchName[_MAX_PATH];
TSteamError steamError;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
strcpy(tmpMatchName, pszMatchName);
FixSlashes(tmpMatchName);
steamResult = SteamFindFirst(tmpMatchName, (ESteamFindFilter)filter, &steamFindInfo, &steamError);
CheckError(NULL, &steamError);
if ( steamResult == STEAM_INVALID_HANDLE )
{
hResult = -1;
}
else
{
hResult = (long)steamResult;
strcpy(fileinfo->name, steamFindInfo.cszName);
fileinfo->size = steamFindInfo.uSizeOrCount;
fileinfo->time_access = steamFindInfo.lLastAccessTime;
fileinfo->time_create = steamFindInfo.lCreationTime;
fileinfo->time_write = steamFindInfo.lLastModificationTime;
// Determine if the found object is a directory...
if ( steamFindInfo.bIsDir )
fileinfo->attrib = _A_SUBDIR;
else
fileinfo->attrib = _A_NORMAL;
// ??? Is there anything we can do with bIsLocal?
}
return hResult;
}
/**************/
//STEAM_findnext
/**************/
int STEAM_findnext(long dir, struct _finddata_t *fileinfo )
{
TSteamElemInfo steamFindInfo;
SteamHandle_t hDir = (SteamHandle_t)dir;
int result;
TSteamError steamError;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
result = SteamFindNext(hDir, &steamFindInfo, &steamError);
CheckError(NULL, &steamError);
if ( result == 0 )
{
dir = (long)hDir;
strcpy(fileinfo->name, steamFindInfo.cszName);
fileinfo->size = steamFindInfo.uSizeOrCount;
fileinfo->time_access = steamFindInfo.lLastAccessTime;
fileinfo->time_create = steamFindInfo.lCreationTime;
fileinfo->time_write = steamFindInfo.lLastModificationTime;
// Determine if the found object is a directory...
if ( steamFindInfo.bIsDir )
fileinfo->attrib = _A_SUBDIR;
else
fileinfo->attrib = _A_NORMAL;
// ??? Is there anything we can do with bIsLocal?
}
return result;
}
/**************/
//STEAM_findclose
/**************/
int STEAM_findclose(long dir)
{
SteamHandle_t hDir = (SteamHandle_t)dir;
TSteamError steamError;
int result;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
result = SteamFindClose(hDir, &steamError);
CheckError(NULL, &steamError);
return result;
}
/**************/
//STEAM_FileSize
/**************/
unsigned int STEAM_FileSize( FILE *file )
{
SteamHandle_t hFile = (SteamHandle_t)file;
TSteamError steamError;
unsigned int result;
if ( STEAMtrackingProgress )
{
DoEventTic(FALSE);
}
result = SteamSizeFile(hFile, &steamError);
CheckError(file, &steamError);
return result;
}
#include "string.h"
/*
===================================
STEAM_LoadLibrary
Wrapper around LoadLibrary() to get
a local copy of the DLL before the
load is done.
===================================
*/
HINSTANCE STEAM_LoadLibrary( const char *dllName )
{
if ( dllName == NULL )
return NULL;
STEAM_GetLocalCopy(dllName);
return LoadLibrary(dllName);
}
/*
===================================
STEAM_GetLocalCopy
Get a local copy of a remote file so that future accesses to this file do not
go out to the server.
===================================
*/
void STEAM_GetLocalCopy( const char *fileName )
{
char tmpFileName[_MAX_PATH];
TSteamError steamError;
if ( STEAMtrackingProgress )
{
DoEventTic(TRUE);
}
strcpy(tmpFileName, fileName);
FixSlashes(tmpFileName);
SteamGetLocalFileCopy(tmpFileName, &steamError);
CheckError(NULL, &steamError);
}
/*
===================================
STEAM_FileIsAvailLocal
Determine if the file is available locally.
===================================
*/
int STEAM_FileIsAvailLocal( const char *file )
{
char tmpFileName[_MAX_PATH];
TSteamError steamError;
int result;
if ( STEAMtrackingProgress )
{
DoEventTic(TRUE);
}
strcpy(tmpFileName, file);
FixSlashes(tmpFileName);
result = SteamIsFileImmediatelyAvailable(tmpFileName, &steamError);
CheckError(NULL, &steamError);
return result;
}
//======================================================================== ==============
// R E S O U R C E H I N T / P R E L O A D E R A P I
//======================================================================== ==============
/*
===================================
STEAM_HintResourceNeed
VFS resource preload hint system.
Input:
-hintlist is a text list with the base names of the resource lists to preload.
A resource list is a text file with a .lst extension found in the 'reslist' subdir
of the HL root directory (peer of 'valve' subdir). It contains a list of file name,
offset, length for every resource to be preloaded.
-forgetEverything is TRUE if the hint system should completely stop working on any queued
resource lists. FALSE will cause the hint system to return to the suspended list(s).
Returns:
-TRUE if successful, FALSE otherwise.
===================================
*/
int STEAM_HintResourceNeed( const char *hintlist, int forgetEverything )
{
TSteamError steamError;
// int result = SteamHintResourceNeed(hintlist, forgetEverything, &steamError);
int result = SteamHintResourceNeed( "", hintlist, forgetEverything, &steamError );
CheckError(NULL, &steamError);
return result;
}
/*
===================================
STEAM_PauseResourcePreloading
Suspend STEAM resource preloading
===================================
*/
int STEAM_PauseResourcePreloading(void)
{
int val = TRUE;
#if STEAM_SYNCHRONIZED_PRELOADING
{
val = SteamPauseCachePreloading(&steamError);
CheckError(NULL, &steamError);
}
#endif
return val;
}
/*
===================================
STEAM_ResumeResourcePreloading
Resume STEAM resource preloading
===================================
*/
int STEAM_ResumeResourcePreloading(void)
{
int val = TRUE;
#if STEAM_SYNCHRONIZED_PRELOADING
{
val = SteamResumeCachePreloading(&steamError);
CheckError(NULL, &steamError);
}
#endif
return val;
}
/*
===================================
STEAM_ForgetAllResourceHints
Instruct the STEAM resource preload system to stop
working on any queued resource lists.
===================================
*/
int STEAM_ForgetAllResourceHints(void)
{
int val = TRUE;
#if STEAM_SYNCHRONIZED_PRELOADING
{
val = SteamForgetAllHints(&steamError);
CheckError(NULL, &steamError);
}
#endif
return val;
}
/*
===================================
STEAM_BlockForResources
Instruct the STEAM resource preload system to get
the indicated resources and block until all are
obtained.
***NOTE*** THIS BLOCKS (DUH) SO DON'T USE WANTONLY
===================================
*/
int STEAM_BlockForResources( const char *hintlist )
{
int val = TRUE;
#if STEAM_SYNCHRONIZED_PRELOADING
{
// val = SteamHintResourceNeed(hintlist, TRUE, &steamError); // Temporary implementation.
val = SteamWaitForResources(hintlist, &steamError);
CheckError(NULL, &steamError);
}
#endif
return val;
}
//======================================================================== ==============
// P R O G R E S S T R A C K I N G A P I
//======================================================================== ==============
/*
===================================
STEAM_TrackProgress
Turn on/off progress tracking,
i.e. for use with a progress bar.
===================================
*/
void STEAM_TrackProgress(int enable)
{
STEAMtrackingProgress = enable;
STEAMprogressCounter = -1;
return;
}
/*
===================================
STEAM_RegisterAppProgressCallback
Allow the app to register its callback
function for progress indication.
===================================
*/
STEAM_RegisterAppProgressCallback( void(*fpProgCallBack)(void), int freq )
{
AppProgressCallback = fpProgCallBack;
AppProgressCallbackFreq = freq;
}
/*
===================================
STEAM_RegisterAppKeepAliveTicCallback
Allow the app to register its callback
function for keep alive indication.
===================================
*/
STEAM_RegisterAppKeepAliveTicCallback( void(*fpKeepAliveTicCallBack)(char *scr_msg) )
{
AppKeepAliveTicCallback = fpKeepAliveTicCallBack;
}
/*
==============================
STEAM_UpdateProgress
Advance progress...
==============================
*/
void STEAM_UpdateProgress( void )
{
if ( !STEAMtrackingProgress )
return;
STEAMprogressCounter++;
if ( AppProgressCallback && (STEAMprogressCounter % AppProgressCallbackFreq) == 0 )
{
AppProgressCallback();
}
}
/*
===================================
STEAM_ProgressCounter
Return the progress counter.
===================================
*/
int STEAM_ProgressCounter(void)
{
return STEAMprogressCounter;
}
//======================================================================== ==============
// L O G G I N G A P I
//======================================================================== ==============
/*
===========
STEAM_LogLevelLoadStarted
VFS logging...started loading a level.
*/
void STEAM_LogLevelLoadStarted( const char *name )
{
#if 0
char wadName[256];
int i;
strcpy(wadName, name);
strlwr(wadName);
if ( strstr(wadName, "c0a0b") )
i = 0; // convenient breakpoint spot...
#endif
SteamLogResourceLoadStarted(name);
}
/*
===========
STEAM_LogLevelLoadFinished
VFS logging...finished loading a level.
*/
void STEAM_LogLevelLoadFinished( const char *name )
{
SteamLogResourceLoadFinished(name);
STEAM_TrackProgress(FALSE);
}
//======================================================================== ==============
// V E R S I O N I N G A P I
//======================================================================== ==============
/*
===========
STEAM_GetInterfaceVersion
VFS version information
*/
void STEAM_GetInterfaceVersion( char *p, int maxlen )
{
if ( p && maxlen > 0)
SteamGetVersion(p, maxlen);
return;
}