mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-14 14:31:19 +00:00
975 lines
No EOL
27 KiB
C++
975 lines
No EOL
27 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 "precompiled.h"
|
|
#include "sys_savegame.h"
|
|
#include "sys_session_local.h"
|
|
#include "sys_session_savegames.h"
|
|
|
|
|
|
extern idCVar saveGame_verbose;
|
|
|
|
idCVar savegame_error( "savegame_error", "0", CVAR_INTEGER, "Combination of bits that will simulate and error, see 'savegamePrintErrors'. 0 = no error" );
|
|
|
|
void OutputDetailList( const saveGameDetailsList_t& savegameList );
|
|
|
|
#pragma region PROCESSORS
|
|
|
|
/*
|
|
================================================================================================
|
|
|
|
idSaveGameProcessorLoadFiles
|
|
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorLoadFiles::InitLoadFiles
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorLoadFiles::InitLoadFiles( const char* folder_, const saveFileEntryList_t& files, idSaveGameManager::packageType_t type )
|
|
{
|
|
if( !idSaveGameProcessor::Init() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
parms.directory = AddSaveFolderPrefix( folder_, type );
|
|
parms.description.slotName = folder_;
|
|
parms.mode = SAVEGAME_MBF_LOAD;
|
|
|
|
for( int i = 0; i < files.Num(); ++i )
|
|
{
|
|
parms.files.Append( files[i] );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorLoadFiles::Process
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorLoadFiles::Process()
|
|
{
|
|
// Platform-specific impl
|
|
// This will populate an idFile_Memory with the contents of the save game
|
|
// This will not initialize the game, only load the file from the file-system
|
|
Sys_ExecuteSavegameCommandAsync( &parms );
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================================================================================================
|
|
|
|
idSaveGameProcessorDelete
|
|
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorDelete::Init
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorDelete::InitDelete( const char* folder_, idSaveGameManager::packageType_t type )
|
|
{
|
|
if( !idSaveGameProcessor::Init() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
parms.description.slotName = folder_;
|
|
parms.directory = AddSaveFolderPrefix( folder_, type );
|
|
parms.mode = SAVEGAME_MBF_DELETE_FOLDER;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorDelete::Process
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorDelete::Process()
|
|
{
|
|
// Platform-specific impl
|
|
// This will populate an idFile_Memory with the contents of the save game
|
|
// This will not initialize the game, only load the file from the file-system
|
|
Sys_ExecuteSavegameCommandAsync( &parms );
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================================================================================================
|
|
|
|
idSaveGameProcessorSaveFiles
|
|
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorSaveFiles::InitSave
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorSaveFiles::InitSave( const char* folder, const saveFileEntryList_t& files, const idSaveGameDetails& descriptionForPS3, idSaveGameManager::packageType_t type )
|
|
{
|
|
if( !idSaveGameProcessor::Init() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( files.Num() == 0 )
|
|
{
|
|
idLib::Warning( "No files to save." );
|
|
return false;
|
|
}
|
|
|
|
// Setup save system
|
|
parms.directory = AddSaveFolderPrefix( folder, type );
|
|
parms.mode = SAVEGAME_MBF_SAVE; // do NOT delete the existing files
|
|
for( int i = 0; i < files.Num(); ++i )
|
|
{
|
|
parms.files.Append( files[i] );
|
|
}
|
|
|
|
|
|
this->parms.description = descriptionForPS3;
|
|
parms.description.slotName = folder;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorSaveFiles::Process
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorSaveFiles::Process()
|
|
{
|
|
// Platform-specific implementation
|
|
// This will start a worker thread for async operation.
|
|
// It will always signal when it's completed.
|
|
Sys_ExecuteSavegameCommandAsync( &parms );
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================================================================================================
|
|
idSaveGameProcessorEnumerateGames
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idSaveGameProcessorEnumerateGames::Process
|
|
========================
|
|
*/
|
|
bool idSaveGameProcessorEnumerateGames::Process()
|
|
{
|
|
parms.mode = SAVEGAME_MBF_ENUMERATE | SAVEGAME_MBF_READ_DETAILS;
|
|
|
|
// Platform-specific implementation
|
|
// This will start a worker thread for async operation.
|
|
// It will always signal when it's completed.
|
|
Sys_ExecuteSavegameCommandAsync( &parms );
|
|
|
|
return false;
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::SaveGameSync
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::SaveGameSync( const char* name, const saveFileEntryList_t& files, const idSaveGameDetails& description )
|
|
{
|
|
saveGameHandle_t handle = 0;
|
|
|
|
// serialize the description file behind their back...
|
|
saveFileEntryList_t filesWithDetails( files );
|
|
idFile_SaveGame* gameDetailsFile = new( TAG_SAVEGAMES ) idFile_SaveGame( SAVEGAME_DETAILS_FILENAME, SAVEGAMEFILE_TEXT | SAVEGAMEFILE_AUTO_DELETE );
|
|
gameDetailsFile->MakeWritable();
|
|
description.descriptors.WriteToIniFile( gameDetailsFile );
|
|
filesWithDetails.Append( gameDetailsFile );
|
|
|
|
if( processorSaveFiles->InitSave( name, filesWithDetails, description ) )
|
|
{
|
|
processorSaveFiles->AddCompletedCallback( MakeCallback( this, &idSessionLocal::OnSaveCompleted, &processorSaveFiles->GetParmsNonConst() ) );
|
|
handle = GetSaveGameManager().ExecuteProcessorAndWait( processorSaveFiles );
|
|
}
|
|
|
|
// Errors within the process of saving are handled in OnSaveCompleted()
|
|
// so that asynchronous save errors are handled the same was as synchronous.
|
|
if( handle == 0 )
|
|
{
|
|
idSaveLoadParms& parms = processorSaveFiles->GetParmsNonConst();
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
|
|
// Uniform error handling
|
|
OnSaveCompleted( &parms );
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::SaveGameAsync
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::SaveGameAsync( const char* name, const saveFileEntryList_t& files, const idSaveGameDetails& description )
|
|
{
|
|
saveGameHandle_t handle = 0;
|
|
|
|
// Done this way so we know it will be shutdown properly on early exit or exception
|
|
struct local_t
|
|
{
|
|
local_t( idSaveLoadParms* localparms ) : parms( localparms )
|
|
{
|
|
// Prepare background renderer
|
|
}
|
|
~local_t()
|
|
{
|
|
// Shutdown background renderer
|
|
}
|
|
idSaveLoadParms* parms;
|
|
} local( &processorSaveFiles->GetParmsNonConst() );
|
|
|
|
// serialize the description file behind their back...
|
|
saveFileEntryList_t filesWithDetails( files );
|
|
idFile_SaveGame* gameDetailsFile = new( TAG_SAVEGAMES ) idFile_SaveGame( SAVEGAME_DETAILS_FILENAME, SAVEGAMEFILE_TEXT | SAVEGAMEFILE_AUTO_DELETE );
|
|
gameDetailsFile->MakeWritable();
|
|
description.descriptors.WriteToIniFile( gameDetailsFile );
|
|
filesWithDetails.Append( gameDetailsFile );
|
|
|
|
if( processorSaveFiles->InitSave( name, filesWithDetails, description ) )
|
|
{
|
|
processorSaveFiles->AddCompletedCallback( MakeCallback( this, &idSessionLocal::OnSaveCompleted, &processorSaveFiles->GetParmsNonConst() ) );
|
|
handle = GetSaveGameManager().ExecuteProcessor( processorSaveFiles );
|
|
}
|
|
|
|
// Errors within the process of saving are handled in OnSaveCompleted()
|
|
// so that asynchronous save errors are handled the same was as synchronous.
|
|
if( handle == 0 )
|
|
{
|
|
idSaveLoadParms& parms = processorSaveFiles->GetParmsNonConst();
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
|
|
common->Dialog().ShowSaveIndicator( false );
|
|
// Uniform error handling
|
|
OnSaveCompleted( &parms );
|
|
}
|
|
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::OnSaveCompleted
|
|
========================
|
|
*/
|
|
void idSessionLocal::OnSaveCompleted( idSaveLoadParms* parms )
|
|
{
|
|
idLocalUser* master = session->GetSignInManager().GetMasterLocalUser();
|
|
|
|
if( parms->GetError() != SAVEGAME_E_INSUFFICIENT_ROOM )
|
|
{
|
|
// if savegame completeed we can clear retry info
|
|
GetSaveGameManager().ClearRetryInfo();
|
|
}
|
|
|
|
// Only turn off the indicator if we're not also going to save the profile settings
|
|
if( master != NULL && master->GetProfile() != NULL && !master->GetProfile()->IsDirty() )
|
|
{
|
|
common->Dialog().ShowSaveIndicator( false );
|
|
}
|
|
|
|
if( parms->GetError() == SAVEGAME_E_NONE )
|
|
{
|
|
// Save the profile any time we save the game
|
|
if( master != NULL && master->GetProfile() != NULL )
|
|
{
|
|
master->GetProfile()->SaveSettings( false );
|
|
}
|
|
|
|
// Update the enumerated savegames
|
|
saveGameDetailsList_t& detailList = session->GetSaveGameManager().GetEnumeratedSavegamesNonConst();
|
|
idSaveGameDetails* details = detailList.Find( parms->description );
|
|
if( details == NULL )
|
|
{
|
|
// add it
|
|
detailList.Append( parms->description );
|
|
}
|
|
else
|
|
{
|
|
// replace it
|
|
*details = parms->description;
|
|
}
|
|
}
|
|
|
|
// Error handling and additional processing
|
|
common->OnSaveCompleted( *parms );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::LoadGameSync
|
|
|
|
We still want to use the savegame manager because we could have file system operations in flight and need to
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::LoadGameSync( const char* name, saveFileEntryList_t& files )
|
|
{
|
|
idSaveLoadParms& parms = processorLoadFiles->GetParmsNonConst();
|
|
saveGameHandle_t handle = 0;
|
|
|
|
{
|
|
// Put in a local block so everything will go in the global heap before the map change, but the heap is
|
|
// automatically popped out on early return or exception
|
|
// You cannot be in the global heap during a map change...
|
|
//idScopedGlobalHeap everythingGoesInTheGlobalHeap;
|
|
|
|
// Done this way so we know it will be shutdown properly on early exit or exception
|
|
struct local_t
|
|
{
|
|
local_t( idSaveLoadParms* parms_ ) : parms( parms_ )
|
|
{
|
|
// Prepare background renderer or loadscreen with what you want to show
|
|
{
|
|
// with mode: SAVE_GAME_MODE_LOAD
|
|
}
|
|
}
|
|
~local_t()
|
|
{
|
|
// Shutdown background renderer or loadscreen
|
|
{
|
|
}
|
|
|
|
common->OnLoadCompleted( *parms );
|
|
}
|
|
idSaveLoadParms* parms;
|
|
} local( &parms );
|
|
|
|
// Read the details file when loading games
|
|
saveFileEntryList_t filesWithDetails( files );
|
|
std::auto_ptr< idFile_SaveGame > gameDetailsFile( new( TAG_SAVEGAMES ) idFile_SaveGame( SAVEGAME_DETAILS_FILENAME, SAVEGAMEFILE_TEXT ) );
|
|
filesWithDetails.Append( gameDetailsFile.get() );
|
|
|
|
// Check the cached save details from the enumeration and make sure we don't load a save from a newer version of the game!
|
|
const saveGameDetailsList_t details = GetSaveGameManager().GetEnumeratedSavegames();
|
|
for( int i = 0; i < details.Num(); ++i )
|
|
{
|
|
if( idStr::Cmp( name, details[i].slotName ) == 0 )
|
|
{
|
|
if( details[i].GetSaveVersion() > BUILD_NUMBER )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_INCOMPATIBLE_NEWER_VERSION;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Synchronous load
|
|
if( processorLoadFiles->InitLoadFiles( name, filesWithDetails ) )
|
|
{
|
|
handle = GetSaveGameManager().ExecuteProcessorAndWait( processorLoadFiles );
|
|
}
|
|
|
|
if( handle == 0 )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
}
|
|
|
|
if( parms.GetError() != SAVEGAME_E_NONE )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Checks the description file to see if corrupted or if it's from a newer savegame
|
|
if( !LoadGameCheckDescriptionFile( parms ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Checks to see if loaded map is from a DLC map and if that DLC is active
|
|
if( !IsDLCAvailable( parms.description.GetMapName() ) )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_DLC_NOT_FOUND;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
common->OnLoadFilesCompleted( parms );
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::OnLoadCompleted
|
|
========================
|
|
*/
|
|
void idSessionLocal::OnLoadCompleted( idSaveLoadParms* parms )
|
|
{
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::EnumerateSaveGamesSync
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::EnumerateSaveGamesSync()
|
|
{
|
|
saveGameHandle_t handle = 0;
|
|
|
|
// Done this way so we know it will be shutdown properly on early exit or exception
|
|
struct local_t
|
|
{
|
|
local_t()
|
|
{
|
|
// Prepare background renderer or loadscreen with what you want to show
|
|
{
|
|
// with mode: SAVE_GAME_MODE_ENUMERATE
|
|
}
|
|
}
|
|
~local_t()
|
|
{
|
|
// Shutdown background renderer or loadscreen
|
|
{
|
|
}
|
|
}
|
|
} local;
|
|
|
|
// flush the old enumerated list
|
|
GetSaveGameManager().GetEnumeratedSavegamesNonConst().Clear();
|
|
|
|
if( processorEnumerate->Init() )
|
|
{
|
|
processorEnumerate->AddCompletedCallback( MakeCallback( this, &idSessionLocal::OnEnumerationCompleted, &processorEnumerate->GetParmsNonConst() ) );
|
|
handle = GetSaveGameManager().ExecuteProcessorAndWait( processorEnumerate );
|
|
}
|
|
|
|
// Errors within the process of saving are handled in OnEnumerationCompleted()
|
|
// so that asynchronous save errors are handled the same was as synchronous.
|
|
if( handle == 0 )
|
|
{
|
|
idSaveLoadParms& parms = processorEnumerate->GetParmsNonConst();
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
|
|
// Uniform error handling
|
|
OnEnumerationCompleted( &parms );
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::EnumerateSaveGamesAsync
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::EnumerateSaveGamesAsync()
|
|
{
|
|
saveGameHandle_t handle = 0;
|
|
|
|
// flush the old enumerated list
|
|
GetSaveGameManager().GetEnumeratedSavegamesNonConst().Clear();
|
|
|
|
if( processorEnumerate->Init() )
|
|
{
|
|
processorEnumerate->AddCompletedCallback( MakeCallback( this, &idSessionLocal::OnEnumerationCompleted, &processorEnumerate->GetParmsNonConst() ) );
|
|
handle = GetSaveGameManager().ExecuteProcessor( processorEnumerate );
|
|
}
|
|
|
|
// Errors within the process of saving are handled in OnEnumerationCompleted()
|
|
// so that asynchronous save errors are handled the same was as synchronous.
|
|
if( handle == 0 )
|
|
{
|
|
idSaveLoadParms& parms = processorEnumerate->GetParmsNonConst();
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
|
|
// Uniform error handling
|
|
OnEnumerationCompleted( &parms );
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
int idSort_EnumeratedSavegames( const idSaveGameDetails* a, const idSaveGameDetails* b )
|
|
{
|
|
return b->date - a->date;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::OnEnumerationCompleted
|
|
========================
|
|
*/
|
|
void idSessionLocal::OnEnumerationCompleted( idSaveLoadParms* parms )
|
|
{
|
|
// idTech4 idList::sort is just a qsort wrapper, which doesn't deal with
|
|
// idStrStatic properly!
|
|
// parms->detailList.Sort( idSort_EnumeratedSavegames );
|
|
std::sort( parms->detailList.Ptr(), parms->detailList.Ptr() + parms->detailList.Num() );
|
|
|
|
if( parms->GetError() == SAVEGAME_E_NONE )
|
|
{
|
|
// Copy into the maintained list
|
|
saveGameDetailsList_t& detailsList = session->GetSaveGameManager().GetEnumeratedSavegamesNonConst();
|
|
//mem.PushHeap();
|
|
detailsList = parms->detailList; // copies new list into the savegame manager's reference
|
|
//mem.PopHeap();
|
|
|
|
// The platform-specific implementations don't know about the prefixes
|
|
// If we don't do this here, we will end up with slots like: GAME-GAME-GAME-GAME-AUTOSAVE...
|
|
for( int i = 0; i < detailsList.Num(); i++ )
|
|
{
|
|
idSaveGameDetails& details = detailsList[i];
|
|
|
|
const idStr original = details.slotName;
|
|
const idStr stripped = RemoveSaveFolderPrefix( original, idSaveGameManager::PACKAGE_GAME );
|
|
details.slotName = stripped;
|
|
}
|
|
|
|
if( saveGame_verbose.GetBool() )
|
|
{
|
|
OutputDetailList( detailsList );
|
|
}
|
|
}
|
|
|
|
common->OnEnumerationCompleted( *parms );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::DeleteSaveGameSync
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::DeleteSaveGameSync( const char* name )
|
|
{
|
|
saveGameHandle_t handle = 0;
|
|
|
|
// Done this way so we know it will be shutdown properly on early exit or exception
|
|
struct local_t
|
|
{
|
|
local_t()
|
|
{
|
|
// Prepare background renderer or loadscreen with what you want to show
|
|
{
|
|
// with mode: SAVE_GAME_MODE_DELETE
|
|
}
|
|
}
|
|
~local_t()
|
|
{
|
|
// Shutdown background renderer or loadscreen
|
|
{
|
|
}
|
|
}
|
|
} local;
|
|
|
|
if( processorDelete->InitDelete( name ) )
|
|
{
|
|
processorDelete->AddCompletedCallback( MakeCallback( this, &idSessionLocal::OnDeleteCompleted, &processorDelete->GetParmsNonConst() ) );
|
|
handle = GetSaveGameManager().ExecuteProcessorAndWait( processorDelete );
|
|
}
|
|
|
|
// Errors within the process of saving are handled in OnDeleteCompleted()
|
|
// so that asynchronous save errors are handled the same was as synchronous.
|
|
if( handle == 0 )
|
|
{
|
|
idSaveLoadParms& parms = processorDelete->GetParmsNonConst();
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
|
|
// Uniform error handling
|
|
OnDeleteCompleted( &parms );
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::DeleteSaveGameAsync
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::DeleteSaveGameAsync( const char* name )
|
|
{
|
|
saveGameHandle_t handle = 0;
|
|
if( processorDelete->InitDelete( name ) )
|
|
{
|
|
processorDelete->AddCompletedCallback( MakeCallback( this, &idSessionLocal::OnDeleteCompleted, &processorDelete->GetParmsNonConst() ) );
|
|
common->Dialog().ShowSaveIndicator( true );
|
|
handle = GetSaveGameManager().ExecuteProcessor( processorDelete );
|
|
}
|
|
|
|
// Errors within the process of saving are handled in OnDeleteCompleted()
|
|
// so that asynchronous save errors are handled the same was as synchronous.
|
|
if( handle == 0 )
|
|
{
|
|
idSaveLoadParms& parms = processorDelete->GetParmsNonConst();
|
|
parms.errorCode = SAVEGAME_E_UNKNOWN;
|
|
|
|
// Uniform error handling
|
|
OnDeleteCompleted( &parms );
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::OnDeleteCompleted
|
|
========================
|
|
*/
|
|
void idSessionLocal::OnDeleteCompleted( idSaveLoadParms* parms )
|
|
{
|
|
common->Dialog().ShowSaveIndicator( false );
|
|
|
|
if( parms->GetError() == SAVEGAME_E_NONE )
|
|
{
|
|
// Update the enumerated list
|
|
saveGameDetailsList_t& details = session->GetSaveGameManager().GetEnumeratedSavegamesNonConst();
|
|
details.Remove( parms->description );
|
|
}
|
|
|
|
common->OnDeleteCompleted( *parms );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::IsEnumerating
|
|
========================
|
|
*/
|
|
bool idSessionLocal::IsEnumerating() const
|
|
{
|
|
return !session->IsSaveGameCompletedFromHandle( processorEnumerate->GetHandle() );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::GetEnumerationHandle
|
|
========================
|
|
*/
|
|
saveGameHandle_t idSessionLocal::GetEnumerationHandle() const
|
|
{
|
|
return processorEnumerate->GetHandle();
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::IsDLCAvailable
|
|
========================
|
|
*/
|
|
bool idSessionLocal::IsDLCAvailable( const char* mapName )
|
|
{
|
|
bool hasContentPackage = true;
|
|
return hasContentPackage;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::LoadGameCheckDiscNumber
|
|
========================
|
|
*/
|
|
bool idSessionLocal::LoadGameCheckDiscNumber( idSaveLoadParms& parms )
|
|
{
|
|
#if 0
|
|
idStr mapName = parms.description.GetMapName();
|
|
|
|
assert( !discSwapStateMgr->IsWorking() );
|
|
discSwapStateMgr->Init( &parms.callbackSignal, idDiscSwapStateManager::DISC_SWAP_COMMAND_LOAD );
|
|
//// TODO_KC this is probably broken now...
|
|
//discSwapStateMgr->folder = folder;
|
|
//discSwapStateMgr->spawnInfo = newSpawnInfo;
|
|
//discSwapStateMgr->spawnSpot = newSpawnPoint;
|
|
//discSwapStateMgr->instanceFileName = instanceFileName;
|
|
discSwapStateMgr->user = session->GetSignInManager().GetMasterLocalUser();
|
|
discSwapStateMgr->map = mapName;
|
|
|
|
discSwapStateMgr->Pump();
|
|
while( discSwapStateMgr->IsWorking() )
|
|
{
|
|
Sys_Sleep( 15 );
|
|
// process input and render
|
|
|
|
discSwapStateMgr->Pump();
|
|
}
|
|
|
|
idDiscSwapStateManager::discSwapStateError_t discSwapError = discSwapStateMgr->GetError();
|
|
|
|
if( discSwapError == idDiscSwapStateManager::DSSE_CANCEL )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_CANCELLED;
|
|
}
|
|
else if( discSwapError == idDiscSwapStateManager::DSSE_INSUFFICIENT_ROOM )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_INSUFFICIENT_ROOM;
|
|
parms.requiredSpaceInBytes = discSwapStateMgr->GetRequiredStorageBytes();
|
|
}
|
|
else if( discSwapError == idDiscSwapStateManager::DSSE_CORRECT_DISC_ALREADY )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_NONE;
|
|
}
|
|
else if( discSwapError != idDiscSwapStateManager::DSSE_OK )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_DISC_SWAP;
|
|
}
|
|
|
|
if( parms.errorCode == SAVEGAME_E_UNKNOWN )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_DISC_SWAP;
|
|
}
|
|
#endif
|
|
|
|
return ( parms.GetError() == SAVEGAME_E_NONE );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocal::LoadGameCheckDescriptionFile
|
|
========================
|
|
*/
|
|
bool idSessionLocal::LoadGameCheckDescriptionFile( idSaveLoadParms& parms )
|
|
{
|
|
idFile_SaveGame** detailsFile = FindFromGenericPtr( parms.files, SAVEGAME_DETAILS_FILENAME );
|
|
if( detailsFile == NULL )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_FILE_NOT_FOUND;
|
|
return false;
|
|
}
|
|
|
|
assert( *detailsFile != NULL );
|
|
( *detailsFile )->MakeReadOnly();
|
|
|
|
if( !SavegameReadDetailsFromFile( *detailsFile, parms.description ) )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_CORRUPTED;
|
|
}
|
|
else
|
|
{
|
|
if( parms.description.GetSaveVersion() > BUILD_NUMBER )
|
|
{
|
|
parms.errorCode = SAVEGAME_E_INCOMPATIBLE_NEWER_VERSION;
|
|
}
|
|
}
|
|
|
|
return ( parms.GetError() == SAVEGAME_E_NONE );
|
|
}
|
|
|
|
#pragma region COMMANDS
|
|
/*
|
|
================================================================================================
|
|
|
|
COMMANDS
|
|
|
|
================================================================================================
|
|
*/
|
|
CONSOLE_COMMAND( testSavegameDeleteAll, "delete all savegames without confirmation", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
idSaveLoadParms parms;
|
|
|
|
parms.SetDefaults();
|
|
parms.mode = SAVEGAME_MBF_DELETE_ALL_FOLDERS | SAVEGAME_MBF_NO_COMPRESS;
|
|
|
|
Sys_ExecuteSavegameCommandAsync( &parms );
|
|
|
|
parms.callbackSignal.Wait();
|
|
idLib::Printf( "Completed process.\n" );
|
|
idLib::Printf( "Error = 0x%08X, %s\n", parms.GetError(), GetSaveGameErrorString( parms.GetError() ).c_str() );
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSavegameDelete, "deletes a savegames without confirmation", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
if( args.Argc() != 2 )
|
|
{
|
|
idLib::Printf( "Usage: testSavegameDelete <folder (without 'GAMES-')>\n" );
|
|
return;
|
|
}
|
|
|
|
idStr folder = args.Argv( 1 );
|
|
idSaveGameProcessorDelete testDeleteSaveGamesProc;
|
|
if( testDeleteSaveGamesProc.InitDelete( folder ) )
|
|
{
|
|
session->GetSaveGameManager().ExecuteProcessorAndWait( &testDeleteSaveGamesProc );
|
|
}
|
|
|
|
idLib::Printf( "Completed process.\n" );
|
|
idLib::Printf( "Error = 0x%08X, %s\n", testDeleteSaveGamesProc.GetParms().GetError(), GetSaveGameErrorString( testDeleteSaveGamesProc.GetParms().GetError() ).c_str() );
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSavegameEnumerateFiles, "enumerates all the files in a folder (blank for 'current slot' folder, use 'autosave' for the autosave slot)", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
idStr folder = session->GetCurrentSaveSlot();
|
|
if( args.Argc() > 1 )
|
|
{
|
|
folder = args.Argv( 1 );
|
|
}
|
|
|
|
idLib::Printf( "Testing folder: %s\n\n", folder.c_str() );
|
|
|
|
idSaveLoadParms parms;
|
|
parms.SetDefaults();
|
|
parms.mode = SAVEGAME_MBF_ENUMERATE_FILES;
|
|
|
|
// Platform-specific implementation
|
|
// This will start a worker thread for async operation.
|
|
// It will always signal when it's completed.
|
|
Sys_ExecuteSavegameCommandAsync( &parms );
|
|
parms.callbackSignal.Wait();
|
|
|
|
for( int i = 0; i < parms.files.Num(); i++ )
|
|
{
|
|
idLib::Printf( S_COLOR_YELLOW "\t%d: %s\n" S_COLOR_DEFAULT, i, parms.files[i]->GetName() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
OutputDetailList
|
|
========================
|
|
*/
|
|
void OutputDetailList( const saveGameDetailsList_t& savegameList )
|
|
{
|
|
for( int i = 0; i < savegameList.Num(); ++i )
|
|
{
|
|
idLib::Printf( S_COLOR_YELLOW "\t%s - %s\n" S_COLOR_DEFAULT
|
|
"\t\tMap: %s\n"
|
|
"\t\tTime: %s\n",
|
|
savegameList[i].slotName.c_str(),
|
|
savegameList[i].damaged ? S_COLOR_RED "CORRUPT" : S_COLOR_GREEN "OK",
|
|
savegameList[i].damaged ? "?" : savegameList[i].descriptors.GetString( SAVEGAME_DETAIL_FIELD_MAP, "" ),
|
|
Sys_TimeStampToStr( savegameList[i].date )
|
|
);
|
|
}
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSavegameEnumerate, "enumerates the savegames available", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
saveGameHandle_t handle = session->EnumerateSaveGamesSync();
|
|
if( handle == 0 )
|
|
{
|
|
idLib::Printf( "Error enumerating.\n" );
|
|
return;
|
|
}
|
|
|
|
const saveGameDetailsList_t gameList = session->GetSaveGameManager().GetEnumeratedSavegames();
|
|
idLib::Printf( "Savegames found: %d\n\n", gameList.Num() );
|
|
OutputDetailList( gameList );
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSaveGameCheck, "tests existence of savegame", 0 )
|
|
{
|
|
bool exists;
|
|
bool autosaveExists;
|
|
Sys_SaveGameCheck( exists, autosaveExists );
|
|
idLib::Printf( "Savegame check: exists = %d, autosaveExists = %d\n", exists, autosaveExists );
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSaveGameOutputEnumeratedSavegames, "outputs the list of savegames already enumerated, this does not re-enumerate", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
const saveGameDetailsList_t& savegames = session->GetSaveGameManager().GetEnumeratedSavegames();
|
|
OutputDetailList( savegames );
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSavegameGetCurrentSlot, "returns the current slot in use", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
idLib::Printf( "Current slot: %s\n", session->GetCurrentSaveSlot() );
|
|
}
|
|
|
|
CONSOLE_COMMAND( testSavegameSetCurrentSlot, "returns the current slot in use", 0 )
|
|
{
|
|
if( session == NULL )
|
|
{
|
|
idLib::Printf( "Invalid session.\n" );
|
|
return;
|
|
}
|
|
|
|
if( args.Argc() != 2 )
|
|
{
|
|
idLib::Printf( "Usage: testSavegameSetCurrentSlot name\n" );
|
|
return;
|
|
}
|
|
|
|
const char* slot = args.Argv( 1 );
|
|
|
|
session->SetCurrentSaveSlot( slot );
|
|
idLib::Printf( "Current slot: %s\n", session->GetCurrentSaveSlot() );
|
|
}
|
|
|
|
CONSOLE_COMMAND( savegameSetErrorBit, "Allows you to set savegame_error by bit instead of integer value", 0 )
|
|
{
|
|
int bit = atoi( args.Argv( 1 ) );
|
|
savegame_error.SetInteger( savegame_error.GetInteger() | ( 1 << bit ) );
|
|
}
|
|
|
|
#pragma endregion |