mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-11-25 13:31:12 +00:00
698 lines
22 KiB
C++
698 lines
22 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "../../idlib/precompiled.h"
|
|
#include "../sys_session_local.h"
|
|
#include "../sys_savegame.h"
|
|
|
|
idCVar savegame_winInduceDelay( "savegame_winInduceDelay", "0", CVAR_INTEGER, "on windows, this is a delay induced before any file operation occurs" );
|
|
extern idCVar fs_savepath;
|
|
extern idCVar saveGame_checksum;
|
|
extern idCVar savegame_error;
|
|
|
|
#define SAVEGAME_SENTINAL 0x12358932
|
|
|
|
/*
|
|
========================
|
|
void Sys_ExecuteSavegameCommandAsync
|
|
========================
|
|
*/
|
|
void Sys_ExecuteSavegameCommandAsyncImpl( idSaveLoadParms * savegameParms ) {
|
|
assert( savegameParms != NULL );
|
|
|
|
session->GetSaveGameManager().GetSaveGameThread().data.saveLoadParms = savegameParms;
|
|
|
|
if ( session->GetSaveGameManager().GetSaveGameThread().GetThreadHandle() == 0 ) {
|
|
session->GetSaveGameManager().GetSaveGameThread().StartWorkerThread( "Savegame", CORE_ANY );
|
|
}
|
|
|
|
session->GetSaveGameManager().GetSaveGameThread().SignalWork();
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idLocalUser * GetLocalUserFromUserId
|
|
========================
|
|
*/
|
|
idLocalUserWin * GetLocalUserFromSaveParms( const saveGameThreadArgs_t & data ) {
|
|
if ( ( data.saveLoadParms != NULL) && ( data.saveLoadParms->inputDeviceId >= 0 ) ) {
|
|
idLocalUser * user = session->GetSignInManager().GetLocalUserByInputDevice( data.saveLoadParms->inputDeviceId );
|
|
if ( user != NULL ) {
|
|
idLocalUserWin * userWin = static_cast< idLocalUserWin * >( user );
|
|
if ( userWin != NULL && data.saveLoadParms->userId == idStr::Hash( userWin->GetGamerTag() ) ) {
|
|
return userWin;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::SaveGame
|
|
========================
|
|
*/
|
|
int idSaveGameThread::Save() {
|
|
idLocalUserWin * user = GetLocalUserFromSaveParms( data );
|
|
if ( user == NULL ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_INVALID_USER;
|
|
return -1;
|
|
}
|
|
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr saveFolder = "savegame";
|
|
|
|
saveFolder.AppendPath( callback->directory );
|
|
|
|
// Check for the required storage space.
|
|
int64 requiredSizeBytes = 0;
|
|
{
|
|
for ( int i = 0; i < callback->files.Num(); i++ ) {
|
|
idFile_SaveGame * file = callback->files[i];
|
|
requiredSizeBytes += ( file->Length() + sizeof( unsigned int ) ); // uint for checksum
|
|
if ( file->type == SAVEGAMEFILE_PIPELINED ) {
|
|
requiredSizeBytes += MIN_SAVEGAME_SIZE_BYTES;
|
|
}
|
|
}
|
|
}
|
|
|
|
int ret = ERROR_SUCCESS;
|
|
|
|
// Check size of previous files if needed
|
|
// ALL THE FILES RIGHT NOW---- could use pattern later...
|
|
idStrList filesToDelete;
|
|
if ( ( callback->mode & SAVEGAME_MBF_DELETE_FILES ) && !callback->cancelled ) {
|
|
if ( fileSystem->IsFolder( saveFolder.c_str(), "fs_savePath" ) == FOLDER_YES ) {
|
|
idFileList * files = fileSystem->ListFilesTree( saveFolder.c_str(), "*.*" );
|
|
for ( int i = 0; i < files->GetNumFiles(); i++ ) {
|
|
requiredSizeBytes -= fileSystem->GetFileLength( files->GetFile( i ) );
|
|
filesToDelete.Append( files->GetFile( i ) );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
}
|
|
}
|
|
|
|
// Inform user about size required if necessary
|
|
if ( requiredSizeBytes > 0 && !callback->cancelled ) {
|
|
user->StorageSizeAvailable( requiredSizeBytes, callback->requiredSpaceInBytes );
|
|
if ( callback->requiredSpaceInBytes > 0 ) {
|
|
// check to make sure savepath actually exists before erroring
|
|
idStr directory = fs_savepath.GetString();
|
|
directory += "\\"; // so it doesn't think the last part is a file and ignores in the directory creation
|
|
fileSystem->CreateOSPath( directory ); // we can't actually check FileExists in production builds, so just try to create it
|
|
user->StorageSizeAvailable( requiredSizeBytes, callback->requiredSpaceInBytes );
|
|
|
|
if ( callback->requiredSpaceInBytes > 0 ) {
|
|
callback->errorCode = SAVEGAME_E_INSUFFICIENT_ROOM;
|
|
// safe to return, haven't written any files yet
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Delete all previous files if needed
|
|
// ALL THE FILES RIGHT NOW---- could use pattern later...
|
|
for ( int i = 0; i < filesToDelete.Num() && !callback->cancelled; i++ ) {
|
|
fileSystem->RemoveFile( filesToDelete[i].c_str() );
|
|
}
|
|
|
|
// Save the raw files.
|
|
for ( int i = 0; i < callback->files.Num() && ret == ERROR_SUCCESS && !callback->cancelled; i++ ) {
|
|
idFile_SaveGame * file = callback->files[i];
|
|
|
|
idStr fileName = saveFolder;
|
|
fileName.AppendPath( file->GetName() );
|
|
idStr tempFileName = va( "%s.temp", fileName.c_str() );
|
|
|
|
idFile * outputFile = fileSystem->OpenFileWrite( tempFileName, "fs_savePath" );
|
|
if ( outputFile == NULL ) {
|
|
idLib::Warning( "[%s]: Couldn't open file for writing, %s. Error = %08x", __FUNCTION__, tempFileName.c_str(), GetLastError() );
|
|
file->error = true;
|
|
callback->errorCode = SAVEGAME_E_UNKNOWN;
|
|
ret = -1;
|
|
continue;
|
|
}
|
|
|
|
if ( ( file->type & SAVEGAMEFILE_PIPELINED ) != 0 ) {
|
|
|
|
idFile_SaveGamePipelined * inputFile = dynamic_cast< idFile_SaveGamePipelined * >( file );
|
|
assert( inputFile != NULL );
|
|
|
|
blockForIO_t block;
|
|
while ( inputFile->NextWriteBlock( & block ) ) {
|
|
if ( (size_t)outputFile->Write( block.data, block.bytes ) != block.bytes ) {
|
|
idLib::Warning( "[%s]: Write failed. Error = %08x", __FUNCTION__, GetLastError() );
|
|
file->error = true;
|
|
callback->errorCode = SAVEGAME_E_INSUFFICIENT_ROOM;
|
|
ret = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
if ( ( file->type & SAVEGAMEFILE_BINARY ) || ( file->type & SAVEGAMEFILE_COMPRESSED ) ) {
|
|
if ( saveGame_checksum.GetBool() ) {
|
|
unsigned int checksum = MD5_BlockChecksum( file->GetDataPtr(), file->Length() );
|
|
size_t size = outputFile->WriteBig( checksum );
|
|
if ( size != sizeof( checksum ) ) {
|
|
idLib::Warning( "[%s]: Write failed. Error = %08x", __FUNCTION__, GetLastError() );
|
|
file->error = true;
|
|
callback->errorCode = SAVEGAME_E_INSUFFICIENT_ROOM;
|
|
ret = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t size = outputFile->Write( file->GetDataPtr(), file->Length() );
|
|
if ( size != (size_t)file->Length() ) {
|
|
idLib::Warning( "[%s]: Write failed. Error = %08x", __FUNCTION__, GetLastError() );
|
|
file->error = true;
|
|
callback->errorCode = SAVEGAME_E_INSUFFICIENT_ROOM;
|
|
ret = -1;
|
|
} else {
|
|
idLib::PrintfIf( saveGame_verbose.GetBool(), "Saved %s (%s)\n", fileName.c_str(), outputFile->GetFullPath() );
|
|
}
|
|
}
|
|
|
|
delete outputFile;
|
|
|
|
if ( ret == ERROR_SUCCESS ) {
|
|
// Remove the old file
|
|
if ( !fileSystem->RenameFile( tempFileName, fileName, "fs_savePath" ) ) {
|
|
idLib::Warning( "Could not start to rename temporary file %s to %s.", tempFileName.c_str(), fileName.c_str() );
|
|
}
|
|
} else {
|
|
fileSystem->RemoveFile( tempFileName );
|
|
idLib::Warning( "Invalid write to temporary file %s.", tempFileName.c_str() );
|
|
}
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
// Removed because it seemed a bit drastic
|
|
#if 0
|
|
// If there is an error, delete the partially saved folder
|
|
if ( callback->errorCode != SAVEGAME_E_NONE ) {
|
|
if ( fileSystem->IsFolder( saveFolder, "fs_savePath" ) == FOLDER_YES ) {
|
|
idFileList * files = fileSystem->ListFilesTree( saveFolder, "/|*" );
|
|
for ( int i = 0; i < files->GetNumFiles(); i++ ) {
|
|
fileSystem->RemoveFile( files->GetFile( i ) );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
fileSystem->RemoveDir( saveFolder );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::LoadGame
|
|
========================
|
|
*/
|
|
int idSaveGameThread::Load() {
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr saveFolder = "savegame";
|
|
|
|
saveFolder.AppendPath( callback->directory );
|
|
|
|
if ( fileSystem->IsFolder( saveFolder, "fs_savePath" ) != FOLDER_YES ) {
|
|
callback->errorCode = SAVEGAME_E_FOLDER_NOT_FOUND;
|
|
return -1;
|
|
}
|
|
|
|
int ret = ERROR_SUCCESS;
|
|
for ( int i = 0; i < callback->files.Num() && ret == ERROR_SUCCESS && !callback->cancelled; i++ ) {
|
|
idFile_SaveGame * file = callback->files[i];
|
|
|
|
idStr filename = saveFolder;
|
|
filename.AppendPath( file->GetName() );
|
|
|
|
idFile * inputFile = fileSystem->OpenFileRead( filename.c_str() );
|
|
if ( inputFile == NULL ) {
|
|
file->error = true;
|
|
if ( !( file->type & SAVEGAMEFILE_OPTIONAL ) ) {
|
|
callback->errorCode = SAVEGAME_E_CORRUPTED;
|
|
ret = -1;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( ( file->type & SAVEGAMEFILE_PIPELINED ) != 0 ) {
|
|
|
|
idFile_SaveGamePipelined * outputFile = dynamic_cast< idFile_SaveGamePipelined * >( file );
|
|
assert( outputFile != NULL );
|
|
|
|
size_t lastReadBytes = 0;
|
|
blockForIO_t block;
|
|
while ( outputFile->NextReadBlock( &block, lastReadBytes ) && !callback->cancelled ) {
|
|
lastReadBytes = inputFile->Read( block.data, block.bytes );
|
|
if ( lastReadBytes != block.bytes ) {
|
|
// Notify end-of-file to the save game file which will cause all reads on the
|
|
// other end of the pipeline to return zero bytes after the pipeline is drained.
|
|
outputFile->NextReadBlock( NULL, lastReadBytes );
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
size_t size = inputFile->Length();
|
|
|
|
unsigned int originalChecksum = 0;
|
|
if ( ( file->type & SAVEGAMEFILE_BINARY ) != 0 || ( file->type & SAVEGAMEFILE_COMPRESSED ) != 0 ) {
|
|
if ( saveGame_checksum.GetBool() ) {
|
|
if ( size >= sizeof( originalChecksum ) ) {
|
|
inputFile->ReadBig( originalChecksum );
|
|
size -= sizeof( originalChecksum );
|
|
}
|
|
}
|
|
}
|
|
|
|
file->SetLength( size );
|
|
|
|
size_t sizeRead = inputFile->Read( (void *)file->GetDataPtr(), size );
|
|
if ( sizeRead != size ) {
|
|
file->error = true;
|
|
callback->errorCode = SAVEGAME_E_CORRUPTED;
|
|
ret = -1;
|
|
}
|
|
|
|
if ( ( file->type & SAVEGAMEFILE_BINARY ) != 0 || ( file->type & SAVEGAMEFILE_COMPRESSED ) != 0 ) {
|
|
if ( saveGame_checksum.GetBool() ) {
|
|
unsigned int checksum = MD5_BlockChecksum( file->GetDataPtr(), file->Length() );
|
|
if ( checksum != originalChecksum ) {
|
|
file->error = true;
|
|
callback->errorCode = SAVEGAME_E_CORRUPTED;
|
|
ret = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete inputFile;
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::Delete
|
|
|
|
This deletes a complete savegame directory
|
|
========================
|
|
*/
|
|
int idSaveGameThread::Delete() {
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr saveFolder = "savegame";
|
|
|
|
saveFolder.AppendPath( callback->directory );
|
|
|
|
int ret = ERROR_SUCCESS;
|
|
if ( fileSystem->IsFolder( saveFolder, "fs_savePath" ) == FOLDER_YES ) {
|
|
idFileList * files = fileSystem->ListFilesTree( saveFolder, "/|*" );
|
|
for ( int i = 0; i < files->GetNumFiles() && !callback->cancelled; i++ ) {
|
|
fileSystem->RemoveFile( files->GetFile( i ) );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
|
|
fileSystem->RemoveDir( saveFolder );
|
|
} else {
|
|
callback->errorCode = SAVEGAME_E_FOLDER_NOT_FOUND;
|
|
ret = -1;
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::Enumerate
|
|
========================
|
|
*/
|
|
int idSaveGameThread::Enumerate() {
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr saveFolder = "savegame";
|
|
|
|
callback->detailList.Clear();
|
|
|
|
int ret = ERROR_SUCCESS;
|
|
if ( fileSystem->IsFolder( saveFolder, "fs_savePath" ) == FOLDER_YES ) {
|
|
idFileList * files = fileSystem->ListFilesTree( saveFolder, SAVEGAME_DETAILS_FILENAME );
|
|
const idStrList & fileList = files->GetList();
|
|
|
|
for ( int i = 0; i < fileList.Num() && !callback->cancelled; i++ ) {
|
|
idSaveGameDetails * details = callback->detailList.Alloc();
|
|
// We have more folders on disk than we have room in our save detail list, stop trying to read them in and continue with what we have
|
|
if ( details == NULL ) {
|
|
break;
|
|
}
|
|
idStr directory = fileList[i];
|
|
|
|
idFile * file = fileSystem->OpenFileRead( directory.c_str() );
|
|
|
|
if ( file != NULL ) {
|
|
// Read the DETAIL file for the enumerated data
|
|
if ( callback->mode & SAVEGAME_MBF_READ_DETAILS ) {
|
|
if ( !SavegameReadDetailsFromFile( file, *details ) ) {
|
|
details->damaged = true;
|
|
ret = -1;
|
|
}
|
|
}
|
|
|
|
// Use the date from the directory
|
|
WIN32_FILE_ATTRIBUTE_DATA attrData;
|
|
BOOL attrRet = GetFileAttributesEx( file->GetFullPath(), GetFileExInfoStandard, &attrData );
|
|
delete file;
|
|
if ( attrRet == TRUE ) {
|
|
FILETIME lastWriteTime = attrData.ftLastWriteTime;
|
|
const ULONGLONG second = 10000000L; // One second = 10,000,000 * 100 nsec
|
|
SYSTEMTIME base_st = { 1970, 1, 0, 1, 0, 0, 0, 0 };
|
|
ULARGE_INTEGER itime;
|
|
FILETIME base_ft;
|
|
BOOL success = SystemTimeToFileTime( &base_st, &base_ft );
|
|
|
|
itime.QuadPart = ((ULARGE_INTEGER *)&lastWriteTime)->QuadPart;
|
|
if ( success ) {
|
|
itime.QuadPart -= ((ULARGE_INTEGER *)&base_ft)->QuadPart;
|
|
} else {
|
|
// Hard coded number of 100-nanosecond units from 1/1/1601 to 1/1/1970
|
|
itime.QuadPart -= 116444736000000000LL;
|
|
}
|
|
itime.QuadPart /= second;
|
|
details->date = itime.QuadPart;
|
|
}
|
|
} else {
|
|
details->damaged = true;
|
|
}
|
|
|
|
// populate the game details struct
|
|
directory = directory.StripFilename();
|
|
details->slotName = directory.c_str() + saveFolder.Length() + 1; // Strip off the prefix too
|
|
// JDC: I hit this all the time assert( fileSystem->IsFolder( directory.c_str(), "fs_savePath" ) == FOLDER_YES );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
} else {
|
|
callback->errorCode = SAVEGAME_E_FOLDER_NOT_FOUND;
|
|
ret = -3;
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::EnumerateFiles
|
|
========================
|
|
*/
|
|
int idSaveGameThread::EnumerateFiles() {
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr folder = "savegame";
|
|
|
|
folder.AppendPath( callback->directory );
|
|
|
|
callback->files.Clear();
|
|
|
|
int ret = ERROR_SUCCESS;
|
|
if ( fileSystem->IsFolder( folder, "fs_savePath" ) == FOLDER_YES ) {
|
|
// get listing of all the files, but filter out below
|
|
idFileList * files = fileSystem->ListFilesTree( folder, "*.*" );
|
|
|
|
// look for the instance pattern
|
|
for ( int i = 0; i < files->GetNumFiles() && ret == 0 && !callback->cancelled; i++ ) {
|
|
idStr fullFilename = files->GetFile( i );
|
|
idStr filename = fullFilename;
|
|
filename.StripPath();
|
|
|
|
if ( filename.IcmpPrefix( callback->pattern ) != 0 ) {
|
|
continue;
|
|
}
|
|
if ( !callback->postPattern.IsEmpty() && filename.Right( callback->postPattern.Length() ).IcmpPrefix( callback->postPattern ) != 0 ) {
|
|
continue;
|
|
}
|
|
|
|
// Read the DETAIL file for the enumerated data
|
|
if ( callback->mode & SAVEGAME_MBF_READ_DETAILS ) {
|
|
idSaveGameDetails & details = callback->description;
|
|
idFile * uncompressed = fileSystem->OpenFileRead( fullFilename.c_str() );
|
|
|
|
if ( uncompressed == NULL ) {
|
|
details.damaged = true;
|
|
} else {
|
|
if ( !SavegameReadDetailsFromFile( uncompressed, details ) ) {
|
|
ret = -1;
|
|
}
|
|
|
|
delete uncompressed;
|
|
}
|
|
|
|
// populate the game details struct
|
|
details.slotName = callback->directory;
|
|
assert( fileSystem->IsFolder( details.slotName, "fs_savePath" ) == FOLDER_YES );
|
|
}
|
|
|
|
idFile_SaveGame * file = new (TAG_SAVEGAMES) idFile_SaveGame( filename, SAVEGAMEFILE_AUTO_DELETE );
|
|
callback->files.Append( file );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
} else {
|
|
callback->errorCode = SAVEGAME_E_FOLDER_NOT_FOUND;
|
|
ret = -3;
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::DeleteFiles
|
|
========================
|
|
*/
|
|
int idSaveGameThread::DeleteFiles() {
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr folder = "savegame";
|
|
|
|
folder.AppendPath( callback->directory );
|
|
|
|
// delete the explicitly requested files first
|
|
for ( int j = 0; j < callback->files.Num() && !callback->cancelled; ++j ) {
|
|
idFile_SaveGame * file = callback->files[j];
|
|
idStr fullpath = folder;
|
|
fullpath.AppendPath( file->GetName() );
|
|
fileSystem->RemoveFile( fullpath );
|
|
}
|
|
|
|
int ret = ERROR_SUCCESS;
|
|
if ( fileSystem->IsFolder( folder, "fs_savePath" ) == FOLDER_YES ) {
|
|
// get listing of all the files, but filter out below
|
|
idFileList * files = fileSystem->ListFilesTree( folder, "*.*" );
|
|
|
|
// look for the instance pattern
|
|
for ( int i = 0; i < files->GetNumFiles() && !callback->cancelled; i++ ) {
|
|
idStr filename = files->GetFile( i );
|
|
filename.StripPath();
|
|
|
|
// If there are post/pre patterns to match, make sure we adhere to the patterns
|
|
if ( callback->pattern.IsEmpty() || ( filename.IcmpPrefix( callback->pattern ) != 0 ) ) {
|
|
continue;
|
|
}
|
|
if ( callback->postPattern.IsEmpty() || ( filename.Right( callback->postPattern.Length() ).IcmpPrefix( callback->postPattern ) != 0 ) ) {
|
|
continue;
|
|
}
|
|
|
|
fileSystem->RemoveFile( files->GetFile( i ) );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
} else {
|
|
callback->errorCode = SAVEGAME_E_FOLDER_NOT_FOUND;
|
|
ret = -3;
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::DeleteAll
|
|
|
|
This deletes all savegame directories
|
|
========================
|
|
*/
|
|
int idSaveGameThread::DeleteAll() {
|
|
idSaveLoadParms * callback = data.saveLoadParms;
|
|
idStr saveFolder = "savegame";
|
|
int ret = ERROR_SUCCESS;
|
|
|
|
if ( fileSystem->IsFolder( saveFolder, "fs_savePath" ) == FOLDER_YES ) {
|
|
idFileList * files = fileSystem->ListFilesTree( saveFolder, "/|*" );
|
|
// remove directories after files
|
|
for ( int i = 0; i < files->GetNumFiles() && !callback->cancelled; i++ ) {
|
|
// contained files should always be first
|
|
if ( fileSystem->IsFolder( files->GetFile( i ), "fs_savePath" ) == FOLDER_YES ) {
|
|
fileSystem->RemoveDir( files->GetFile( i ) );
|
|
} else {
|
|
fileSystem->RemoveFile( files->GetFile( i ) );
|
|
}
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
} else {
|
|
callback->errorCode = SAVEGAME_E_FOLDER_NOT_FOUND;
|
|
ret = -3;
|
|
}
|
|
|
|
if ( data.saveLoadParms->cancelled ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameThread::Run
|
|
========================
|
|
*/
|
|
int idSaveGameThread::Run() {
|
|
int ret = ERROR_SUCCESS;
|
|
|
|
try {
|
|
idLocalUserWin * user = GetLocalUserFromSaveParms( data );
|
|
if ( user != NULL && !user->IsStorageDeviceAvailable() ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_UNABLE_TO_SELECT_STORAGE_DEVICE;
|
|
}
|
|
|
|
if ( savegame_winInduceDelay.GetInteger() > 0 ) {
|
|
Sys_Sleep( savegame_winInduceDelay.GetInteger() );
|
|
}
|
|
|
|
if ( data.saveLoadParms->mode & SAVEGAME_MBF_SAVE ) {
|
|
ret = Save();
|
|
} else if ( data.saveLoadParms->mode & SAVEGAME_MBF_LOAD ) {
|
|
ret = Load();
|
|
} else if ( data.saveLoadParms->mode & SAVEGAME_MBF_ENUMERATE ) {
|
|
ret = Enumerate();
|
|
} else if ( data.saveLoadParms->mode & SAVEGAME_MBF_DELETE_FOLDER ) {
|
|
ret = Delete();
|
|
} else if ( data.saveLoadParms->mode & SAVEGAME_MBF_DELETE_ALL_FOLDERS ) {
|
|
ret = DeleteAll();
|
|
} else if ( data.saveLoadParms->mode & SAVEGAME_MBF_DELETE_FILES ) {
|
|
ret = DeleteFiles();
|
|
} else if ( data.saveLoadParms->mode & SAVEGAME_MBF_ENUMERATE_FILES ) {
|
|
ret = EnumerateFiles();
|
|
}
|
|
|
|
// if something failed and no one set an error code, do it now.
|
|
if ( ret != 0 && data.saveLoadParms->errorCode == SAVEGAME_E_NONE ) {
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_UNKNOWN;
|
|
}
|
|
} catch ( ... ) {
|
|
// if anything horrible happens, leave it up to the savegame processors to handle in PostProcess().
|
|
data.saveLoadParms->errorCode = SAVEGAME_E_UNKNOWN;
|
|
}
|
|
|
|
// Make sure to cancel any save game file pipelines.
|
|
if ( data.saveLoadParms->errorCode != SAVEGAME_E_NONE ) {
|
|
data.saveLoadParms->CancelSaveGameFilePipelines();
|
|
}
|
|
|
|
// Override error if cvar set
|
|
if ( savegame_error.GetInteger() != 0 ) {
|
|
data.saveLoadParms->errorCode = (saveGameError_t)savegame_error.GetInteger();
|
|
}
|
|
|
|
// Tell the waiting caller that we are done
|
|
data.saveLoadParms->callbackSignal.Raise();
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
Sys_SaveGameCheck
|
|
========================
|
|
*/
|
|
void Sys_SaveGameCheck( bool & exists, bool & autosaveExists ) {
|
|
exists = false;
|
|
autosaveExists = false;
|
|
|
|
const idStr autosaveFolderStr = AddSaveFolderPrefix( SAVEGAME_AUTOSAVE_FOLDER, idSaveGameManager::PACKAGE_GAME );
|
|
const char * autosaveFolder = autosaveFolderStr.c_str();
|
|
const char * saveFolder = "savegame";
|
|
|
|
if ( fileSystem->IsFolder( saveFolder, "fs_savePath" ) == FOLDER_YES ) {
|
|
idFileList * files = fileSystem->ListFiles( saveFolder, "/" );
|
|
const idStrList & fileList = files->GetList();
|
|
|
|
idLib::PrintfIf( saveGame_verbose.GetBool(), "found %d savegames\n", fileList.Num() );
|
|
|
|
for ( int i = 0; i < fileList.Num(); i++ ) {
|
|
const char * directory = va( "%s/%s", saveFolder, fileList[i].c_str() );
|
|
|
|
if ( fileSystem->IsFolder( directory, "fs_savePath" ) == FOLDER_YES ) {
|
|
exists = true;
|
|
|
|
idLib::PrintfIf( saveGame_verbose.GetBool(), "found savegame: %s\n", fileList[i].c_str() );
|
|
|
|
if ( idStr::Icmp( fileList[i].c_str(), autosaveFolder ) == 0 ) {
|
|
autosaveExists = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
fileSystem->FreeFileList( files );
|
|
}
|
|
}
|