1035 lines
29 KiB
C++
1035 lines
29 KiB
C++
//===========================================================================
|
|
// Copyright (C) 2000 Radical Entertainment Ltd. All rights reserved.
|
|
//
|
|
// Component: CGuiScreenLoadGame
|
|
//
|
|
// Description: Implementation of the CGuiScreenLoadGame class.
|
|
//
|
|
// Authors: Tony Chu
|
|
//
|
|
// Revisions Date Author Revision
|
|
// 2002/07/04 TChu Created for SRR2
|
|
//
|
|
//===========================================================================
|
|
|
|
//===========================================================================
|
|
// Includes
|
|
//===========================================================================
|
|
#include <presentation/gui/frontend/guiscreenloadgame.h>
|
|
#include <presentation/gui/frontend/guiscreenmainmenu.h>
|
|
#include <presentation/gui/guimanager.h>
|
|
#include <presentation/gui/guimenu.h>
|
|
#include <presentation/gui/guitextbible.h>
|
|
#include <presentation/gui/guiscreenmessage.h>
|
|
#include <presentation/gui/guiscreenprompt.h>
|
|
|
|
#include <data/gamedatamanager.h>
|
|
#include <data/savegameinfo.h>
|
|
#include <data/memcard/memorycardmanager.h>
|
|
#include <memory/srrmemory.h>
|
|
|
|
#include <raddebug.hpp> // Foundation
|
|
#include <page.h>
|
|
#include <screen.h>
|
|
#include <text.h>
|
|
|
|
//===========================================================================
|
|
// Global Data, Local Data, Local Classes
|
|
//===========================================================================
|
|
#ifdef RAD_XBOX
|
|
char gGameFileName[NUM_GAME_SLOTS][radFileFilenameMax+1];
|
|
#endif
|
|
|
|
#ifdef RAD_PS2
|
|
const unsigned int AUTO_LOAD_MINIMUM_DISPLAY_TIME = 5000; // in msec
|
|
#endif
|
|
|
|
//===========================================================================
|
|
// Public Member Functions
|
|
//===========================================================================
|
|
|
|
//===========================================================================
|
|
// CGuiScreenLoadGame::CGuiScreenLoadGame
|
|
//===========================================================================
|
|
// Description: Constructor.
|
|
//
|
|
// Constraints: None.
|
|
//
|
|
// Parameters: None.
|
|
//
|
|
// Return: N/A.
|
|
//
|
|
//===========================================================================
|
|
CGuiScreenLoadGame::CGuiScreenLoadGame
|
|
(
|
|
Scrooby::Screen* pScreen,
|
|
CGuiEntity* pParent,
|
|
eGuiWindowID windowID
|
|
)
|
|
: CGuiScreen( pScreen, pParent, windowID ),
|
|
CGuiScreenLoadSave( pScreen ),
|
|
m_pMenu( NULL ),
|
|
m_pFullText( NULL ),
|
|
m_StatusPromptShown(false)
|
|
|
|
{
|
|
MEMTRACK_PUSH_GROUP( "CGUIScreenLoadGame" );
|
|
if( windowID == GUI_SCREEN_ID_LOAD_GAME )
|
|
{
|
|
// Retrieve the Scrooby drawing elements.
|
|
//
|
|
Scrooby::Page* pPage = m_pScroobyScreen->GetPage( "GameSlots" );
|
|
rAssert( pPage );
|
|
|
|
// hide full text field
|
|
m_pFullText = pPage->GetText( "FullMessage" );
|
|
rAssert( m_pFullText != NULL );
|
|
m_pFullText->SetVisible(false);
|
|
m_pFullText->SetTextMode( Scrooby::TEXT_WRAP );
|
|
|
|
// Create a menu.
|
|
//
|
|
m_pMenu = new(GMA_LEVEL_FE) CGuiMenu( this, NUM_GAME_SLOTS );
|
|
rAssert( m_pMenu != NULL );
|
|
|
|
// Add menu items
|
|
//
|
|
for( unsigned int i = 0; i < NUM_GAME_SLOTS; i++ )
|
|
{
|
|
char objectName[ 32 ];
|
|
sprintf( objectName, "Slot%d", i );
|
|
|
|
m_pMenu->AddMenuItem( pPage->GetText( objectName ) );
|
|
}
|
|
}
|
|
MEMTRACK_POP_GROUP( "CGUIScreenLoadGame" );
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
// CGuiScreenLoadGame::~CGuiScreenLoadGame
|
|
//===========================================================================
|
|
// Description: Destructor.
|
|
//
|
|
// Constraints: None.
|
|
//
|
|
// Parameters: None.
|
|
//
|
|
// Return: N/A.
|
|
//
|
|
//===========================================================================
|
|
CGuiScreenLoadGame::~CGuiScreenLoadGame()
|
|
{
|
|
if( m_pMenu != NULL )
|
|
{
|
|
delete m_pMenu;
|
|
m_pMenu = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
// CGuiScreenLoadGame::HandleMessage
|
|
//===========================================================================
|
|
// Description:
|
|
//
|
|
// Constraints: None.
|
|
//
|
|
// Parameters: None.
|
|
//
|
|
// Return: N/A.
|
|
//
|
|
//===========================================================================
|
|
void CGuiScreenLoadGame::HandleMessage
|
|
(
|
|
eGuiMessage message,
|
|
unsigned int param1,
|
|
unsigned int param2
|
|
)
|
|
{
|
|
if (message == GUI_MSG_MESSAGE_UPDATE)
|
|
{
|
|
if (m_formatState)
|
|
{
|
|
m_elapsedFormatTime += param1;
|
|
|
|
if (m_elapsedFormatTime > m_minimumFormatTime && m_formatDone)
|
|
{
|
|
m_StatusPromptShown = true;
|
|
if( m_formatResult == Success )
|
|
{
|
|
m_guiManager->DisplayPrompt(PROMPT_FORMAT_SUCCESS_GC + PLATFORM_TEXT_INDEX, this, PROMPT_TYPE_CONTINUE); // format success
|
|
m_formatState = false;
|
|
}
|
|
else
|
|
{
|
|
m_guiManager->DisplayPrompt(PROMPT_FORMAT_FAIL_GC + PLATFORM_TEXT_INDEX, this, PROMPT_TYPE_CONTINUE); // format fail
|
|
m_formatState = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (message == GUI_MSG_PROMPT_UPDATE)
|
|
{
|
|
// update so status up to date
|
|
GetMemoryCardManager()->Update( param1 );
|
|
if (m_StatusPromptShown==false) { // check for user unplugging memcard if not showing status
|
|
int currentDrive = GetMemoryCardManager()->GetCurrentDriveIndex();
|
|
if( !GetMemoryCardManager()->IsCurrentDrivePresent(currentDrive) )
|
|
ReloadScreen();
|
|
}
|
|
}
|
|
else if( message == GUI_MSG_ON_DISPLAY_MESSAGE )
|
|
{
|
|
if (m_operation==LOAD)
|
|
{
|
|
// start the load game process
|
|
//
|
|
rAssert( m_currentSlot != -1 );
|
|
#ifdef RAD_XBOX
|
|
GetGameDataManager()->LoadGame( m_currentSlot, this, gGameFileName[m_currentSlot] );
|
|
#else
|
|
GetGameDataManager()->LoadGame( m_currentSlot, this );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
FormatCurrentDrive();
|
|
}
|
|
}
|
|
else if ( message == GUI_MSG_ERROR_PROMPT_RESPONSE )
|
|
{
|
|
this->HandleErrorResponse( static_cast<CGuiMenuPrompt::ePromptResponse>( param2 ) );
|
|
}
|
|
else if( message == GUI_MSG_MENU_PROMPT_RESPONSE )
|
|
{
|
|
switch( param1 )
|
|
{
|
|
case PROMPT_LOAD_CARD_EMPTY_GC:
|
|
case PROMPT_LOAD_CARD_EMPTY_PS2:
|
|
case PROMPT_LOAD_CARD_EMPTY_XBOX:
|
|
case PROMPT_LOAD_CARD_EMPTY_XBOX_HD:
|
|
this->GotoMemoryCardScreen( true );
|
|
break;
|
|
|
|
case PROMPT_LOAD_DELETE_CORRUPT_GC:
|
|
case PROMPT_LOAD_DELETE_CORRUPT_PS2:
|
|
case PROMPT_LOAD_DELETE_CORRUPT_XBOX:
|
|
case PROMPT_LOAD_DELETE_CORRUPT_XBOX_HD:
|
|
{
|
|
if (param2==CGuiMenuPrompt::RESPONSE_NO)
|
|
{
|
|
this->ReloadScreen();
|
|
}
|
|
else if (param2==CGuiMenuPrompt::RESPONSE_YES)
|
|
{
|
|
// get the filename
|
|
char filename[ radFileFilenameMax + 1 ];
|
|
#ifdef RAD_XBOX
|
|
strcpy(filename, gGameFileName[m_currentSlot]);
|
|
#else
|
|
GetGameDataManager()->FormatSavedGameFilename( filename,
|
|
sizeof( filename ),
|
|
m_currentSlot );
|
|
#endif
|
|
radFileError err = GetGameDataManager()->DeleteGame(filename);
|
|
if (err==Success)
|
|
m_guiManager->DisplayPrompt(PROMPT_DELETE_CORRUPT_SUCCESS_GC + PLATFORM_TEXT_INDEX, this,
|
|
PROMPT_TYPE_CONTINUE);
|
|
else
|
|
m_guiManager->DisplayPrompt(PROMPT_DELETE_CORRUPT_FAIL_GC + PLATFORM_TEXT_INDEX, this,
|
|
PROMPT_TYPE_CONTINUE);
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
case PROMPT_DELETE_CORRUPT_SUCCESS_GC:
|
|
case PROMPT_DELETE_CORRUPT_SUCCESS_PS2:
|
|
case PROMPT_DELETE_CORRUPT_SUCCESS_XBOX:
|
|
|
|
case PROMPT_DELETE_CORRUPT_FAIL_GC:
|
|
case PROMPT_DELETE_CORRUPT_FAIL_PS2:
|
|
case PROMPT_DELETE_CORRUPT_FAIL_XBOX:
|
|
this->ReloadScreen();
|
|
break;
|
|
|
|
case PROMPT_FORMAT_CONFIRM2_GC:
|
|
case PROMPT_FORMAT_CONFIRM2_PS2:
|
|
case PROMPT_FORMAT_CONFIRM2_XBOX: // really format
|
|
{
|
|
if (param2==CGuiMenuPrompt::RESPONSE_YES)
|
|
{
|
|
m_operation = FORMAT;
|
|
m_guiManager->DisplayMessage(CGuiScreenMessage::MSG_ID_FORMATTING_GC + PLATFORM_TEXT_INDEX, this);
|
|
}
|
|
else
|
|
{
|
|
this->GotoMemoryCardScreen( true );
|
|
}
|
|
|
|
break;
|
|
}
|
|
case PROMPT_FORMAT_SUCCESS_GC:
|
|
case PROMPT_FORMAT_SUCCESS_PS2:
|
|
case PROMPT_FORMAT_SUCCESS_XBOX: // format ok
|
|
{
|
|
this->GotoMemoryCardScreen( true );
|
|
|
|
break;
|
|
}
|
|
case PROMPT_FORMAT_FAIL_GC:
|
|
case PROMPT_FORMAT_FAIL_PS2:
|
|
case PROMPT_FORMAT_FAIL_XBOX: // format fail
|
|
{
|
|
GetMemoryCardManager()->ClearCurrentDrive();
|
|
this->GotoMemoryCardScreen( true );
|
|
|
|
break;
|
|
}
|
|
case PROMPT_LOAD_CONFIRM_GC:
|
|
case PROMPT_LOAD_CONFIRM_PS2:
|
|
case PROMPT_LOAD_CONFIRM_XBOX:
|
|
{
|
|
if( param2 == CGuiMenuPrompt::RESPONSE_YES )
|
|
{
|
|
this->LoadGame();
|
|
}
|
|
else
|
|
{
|
|
rAssert( param2 == CGuiMenuPrompt::RESPONSE_NO );
|
|
|
|
this->ReloadScreen();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case PROMPT_LOAD_SUCCESSFUL:
|
|
{
|
|
CGuiScreen* promptScreen = (CGuiScreen*)m_guiManager->FindWindowByID( GUI_SCREEN_ID_GENERIC_PROMPT );
|
|
rAssert( promptScreen );
|
|
promptScreen->StartTransitionAnimation( 230, 260 );
|
|
|
|
// re-init main menu and default to "resume game" selection
|
|
//
|
|
CGuiScreenMainMenu* pScreen =
|
|
static_cast<CGuiScreenMainMenu*>( m_guiManager->FindWindowByID( GUI_SCREEN_ID_MAIN_MENU ) );
|
|
rAssert( pScreen != NULL );
|
|
pScreen->InitMenu();
|
|
|
|
m_pParent->HandleMessage( GUI_MSG_BACK_SCREEN );
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
// handle normal menu condition, "continue", "retry"
|
|
this->HandleErrorResponse( static_cast<CGuiMenuPrompt::ePromptResponse>( param2 ) );
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_state == GUI_WINDOW_STATE_RUNNING )
|
|
{
|
|
switch( message )
|
|
{
|
|
case GUI_MSG_MENU_SELECTION_MADE:
|
|
{
|
|
m_currentSlot = param1; // // param1 = slot
|
|
|
|
SaveGameInfo saveGameInfo;
|
|
bool corrupt;
|
|
IRadDrive* currentDrive = GetMemoryCardManager()->GetCurrentDrive();
|
|
bool saveGameExists = GetGameDataManager()->GetSaveGameInfo( currentDrive, m_currentSlot, &saveGameInfo, &corrupt );
|
|
|
|
if (corrupt)
|
|
{
|
|
#ifdef RAD_GAMECUBE
|
|
int errorMessage = GetErrorMessageIndex( DataCorrupt, ERROR_DURING_LOADING );
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE | ERROR_RESPONSE_RETRY | ERROR_RESPONSE_DELETE );
|
|
m_operation = LOAD;
|
|
#endif
|
|
#ifdef RAD_PS2
|
|
rAssertMsg( false, "Corrupted save games should not have been selectable!" );
|
|
#endif
|
|
#ifdef RAD_XBOX
|
|
// for xbox don't ask to delete just put up a message
|
|
int errorMessage = GetErrorMessageIndex( DataCorrupt, ERROR_DURING_LOADING );
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this, ERROR_RESPONSE_CONTINUE );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef RAD_GAMECUBE
|
|
m_guiManager->DisplayPrompt( PROMPT_LOAD_CONFIRM_GC, this );
|
|
#endif
|
|
|
|
#ifdef RAD_PS2
|
|
m_guiManager->DisplayPrompt( PROMPT_LOAD_CONFIRM_PS2, this );
|
|
#endif
|
|
|
|
#ifdef RAD_XBOX
|
|
m_guiManager->DisplayPrompt( PROMPT_LOAD_CONFIRM_XBOX, this );
|
|
#endif
|
|
|
|
#ifdef RAD_WIN32
|
|
m_guiManager->DisplayPrompt( PROMPT_LOAD_CONFIRM_XBOX, this ); // parallel xbox for now.
|
|
#endif
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case GUI_MSG_CONTROLLER_BACK:
|
|
{
|
|
#ifdef RAD_XBOX
|
|
s_forceGotoMemoryCardScreen = true;
|
|
this->GotoMemoryCardScreen();
|
|
#else
|
|
this->StartTransitionAnimation( 230, 260 );
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// relay message to menu
|
|
if( m_pMenu != NULL )
|
|
{
|
|
m_pMenu->HandleMessage( message, param1, param2 );
|
|
}
|
|
|
|
if( m_ID == GUI_SCREEN_ID_LOAD_GAME )
|
|
{
|
|
CGuiScreenLoadSave::HandleMessage( message, param1, param2 );
|
|
}
|
|
}
|
|
|
|
// Propogate the message up the hierarchy.
|
|
//
|
|
CGuiScreen::HandleMessage( message, param1, param2 );
|
|
}
|
|
|
|
|
|
void
|
|
CGuiScreenLoadGame::OnLoadGameComplete( radFileError errorCode )
|
|
{
|
|
m_lastError = errorCode;
|
|
m_StatusPromptShown = true;
|
|
|
|
if( errorCode == Success )
|
|
{
|
|
m_guiManager->DisplayPrompt( PROMPT_LOAD_SUCCESSFUL, this, PROMPT_TYPE_CONTINUE );
|
|
}
|
|
else
|
|
{
|
|
int errorMessage = GetErrorMessageIndex( errorCode, ERROR_DURING_LOADING );
|
|
|
|
#ifdef RAD_GAMECUBE
|
|
switch( errorCode )
|
|
{
|
|
case Success:
|
|
{
|
|
rAssert( false );
|
|
break;
|
|
}
|
|
case MediaEncodingErr:
|
|
case MediaNotFormatted:
|
|
{
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE | ERROR_RESPONSE_RETRY | ERROR_RESPONSE_FORMAT );
|
|
|
|
}
|
|
case DataCorrupt:
|
|
{
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE | ERROR_RESPONSE_RETRY | ERROR_RESPONSE_DELETE );
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE | ERROR_RESPONSE_RETRY );
|
|
|
|
break;
|
|
}
|
|
}
|
|
#endif // RAD_GAMECUBE
|
|
|
|
#ifdef RAD_PS2
|
|
switch( errorCode )
|
|
{
|
|
case Success:
|
|
{
|
|
rAssert( false );
|
|
break;
|
|
}
|
|
/*
|
|
case DataCorrupt:
|
|
{
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_YES | ERROR_RESPONSE_NO );
|
|
|
|
break;
|
|
}
|
|
*/
|
|
default:
|
|
{
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this, ERROR_RESPONSE_CONTINUE );
|
|
|
|
break;
|
|
}
|
|
}
|
|
#endif // RAD_PS2
|
|
|
|
#ifdef RAD_XBOX
|
|
switch( errorCode )
|
|
{
|
|
case Success:
|
|
{
|
|
rAssert( false );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
if (errorCode==DataCorrupt) // no delete corrupt for xbox loading
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE );
|
|
else
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE );
|
|
|
|
break;
|
|
}
|
|
}
|
|
#endif // RAD_XBOX
|
|
|
|
#ifdef RAD_WIN32
|
|
switch( errorCode )
|
|
{
|
|
case Success:
|
|
{
|
|
rAssert( false );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
m_guiManager->DisplayErrorPrompt( errorMessage, this,
|
|
ERROR_RESPONSE_CONTINUE );
|
|
break;
|
|
}
|
|
}
|
|
#endif // RAD_WIN32
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
CGuiScreenLoadGame::HandleErrorResponse( CGuiMenuPrompt::ePromptResponse response )
|
|
{
|
|
switch( response )
|
|
{
|
|
case (CGuiMenuPrompt::RESPONSE_CONTINUE):
|
|
{
|
|
if( m_operation == LOAD )
|
|
{
|
|
this->ReloadScreen();
|
|
}
|
|
else if( m_operation == FORMAT )
|
|
{
|
|
this->ReloadScreen();
|
|
}
|
|
else
|
|
{
|
|
this->GotoMemoryCardScreen( true );
|
|
}
|
|
|
|
break;
|
|
}
|
|
case (CGuiMenuPrompt::RESPONSE_RETRY):
|
|
{
|
|
if( m_operation == LOAD )
|
|
{
|
|
this->LoadGame();
|
|
}
|
|
else if( m_operation == FORMAT )
|
|
{
|
|
m_guiManager->DisplayMessage(CGuiScreenMessage::MSG_ID_FORMATTING_GC + PLATFORM_TEXT_INDEX, this);
|
|
}
|
|
else
|
|
{
|
|
this->ReloadScreen();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
#ifdef RAD_GAMECUBE
|
|
case (CGuiMenuPrompt::RESPONSE_DELETE):
|
|
{
|
|
m_guiManager->DisplayPrompt( PROMPT_LOAD_DELETE_CORRUPT_GC, this );
|
|
|
|
break;
|
|
}
|
|
#endif // RAD_GAMECUBE
|
|
|
|
#if defined( RAD_GAMECUBE ) || defined( RAD_PS2 )
|
|
case (CGuiMenuPrompt::RESPONSE_YES):
|
|
{
|
|
// YES to delete corrupted file
|
|
//
|
|
char filename[ radFileFilenameMax + 1 ];
|
|
#ifdef RAD_XBOX
|
|
strcpy( filename, gGameFileName[ m_currentSlot ] );
|
|
#else
|
|
GetGameDataManager()->FormatSavedGameFilename( filename,
|
|
sizeof( filename ),
|
|
m_currentSlot );
|
|
#endif
|
|
radFileError err = GetGameDataManager()->DeleteGame( filename );
|
|
if( err == Success )
|
|
{
|
|
m_guiManager->DisplayPrompt( PROMPT_DELETE_CORRUPT_SUCCESS_GC + PLATFORM_TEXT_INDEX,
|
|
this, PROMPT_TYPE_CONTINUE );
|
|
}
|
|
else
|
|
{
|
|
m_guiManager->DisplayPrompt( PROMPT_DELETE_CORRUPT_FAIL_GC + PLATFORM_TEXT_INDEX,
|
|
this, PROMPT_TYPE_CONTINUE );
|
|
}
|
|
|
|
break;
|
|
}
|
|
case (CGuiMenuPrompt::RESPONSE_NO):
|
|
{
|
|
// NO to delete corrupted file
|
|
//
|
|
this->ReloadScreen();
|
|
|
|
break;
|
|
}
|
|
#endif // RAD_GAMECUBE || RAD_PS2
|
|
|
|
case (CGuiMenuPrompt::RESPONSE_FORMAT_GC):
|
|
case (CGuiMenuPrompt::RESPONSE_FORMAT_XBOX):
|
|
case (CGuiMenuPrompt::RESPONSE_FORMAT_PS2):
|
|
{
|
|
m_guiManager->DisplayPrompt(PROMPT_FORMAT_CONFIRM2_GC + PLATFORM_TEXT_INDEX,this);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
rTunePrintf( "*** WARNING: Unhandled response for error [%d]!\n", m_lastError );
|
|
rAssert( false );
|
|
|
|
this->ReloadScreen();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
CGuiScreenLoadSave::HandleErrorResponse( response );
|
|
}
|
|
|
|
//===========================================================================
|
|
// CGuiScreenLoadGame::InitIntro
|
|
//===========================================================================
|
|
// Description:
|
|
//
|
|
// Constraints: None.
|
|
//
|
|
// Parameters: None.
|
|
//
|
|
// Return: N/A.
|
|
//
|
|
//===========================================================================
|
|
void CGuiScreenLoadGame::InitIntro()
|
|
{
|
|
bool unformatted = false;
|
|
bool file_corrupt = false;
|
|
SaveGameInfo saveGameInfo;
|
|
m_StatusPromptShown = false;
|
|
m_operation = SCREEN_OP_IDLE;
|
|
|
|
m_pFullText->SetVisible(false);
|
|
|
|
IRadDrive::MediaInfo::MediaState mediaState;
|
|
if( s_forceGotoMemoryCardScreen || !GetMemoryCardManager()->IsCurrentDriveReady( true, &unformatted, &mediaState ) )
|
|
{
|
|
if (unformatted && !s_forceGotoMemoryCardScreen)
|
|
{
|
|
#ifdef RAD_GAMECUBE
|
|
int errorMessage = GetErrorMessageIndex( mediaState );
|
|
m_guiManager->DisplayErrorPrompt( errorMessage,
|
|
this,
|
|
ERROR_RESPONSE_CONTINUE | ERROR_RESPONSE_RETRY | ERROR_RESPONSE_FORMAT );
|
|
|
|
m_numTransitionsPending = -1; // disable all transitions
|
|
|
|
return;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
this->GotoMemoryCardScreen();
|
|
m_numTransitionsPending = -1; // disable all transitions
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
this->UpdateCurrentMemoryDevice();
|
|
|
|
rAssert( m_pMenu );
|
|
m_pMenu->Reset();
|
|
|
|
IRadDrive* currentDrive = GetMemoryCardManager()->GetCurrentDrive();
|
|
|
|
radDate mostRecentTimestamp;
|
|
mostRecentTimestamp.m_Year = 0;
|
|
bool has_savegame = false;
|
|
bool has_4_saves = false;
|
|
|
|
// update all save game slots display info
|
|
//
|
|
for( unsigned int i = 0; i < NUM_GAME_SLOTS; i++ )
|
|
{
|
|
bool saveGameExists = GetGameDataManager()->GetSaveGameInfo( currentDrive, i, &saveGameInfo, &file_corrupt );
|
|
// saveGameExists = saveGameExists && saveGameInfo.CheckData();
|
|
|
|
Scrooby::Text* slotText = dynamic_cast<Scrooby::Text*>( m_pMenu->GetMenuItem( i )->GetItem() );
|
|
rAssert( slotText != NULL );
|
|
|
|
HeapMgr()->PushHeap( GMA_LEVEL_FE );
|
|
|
|
if( saveGameExists )
|
|
{
|
|
if (i == NUM_GAME_SLOTS-1)
|
|
{
|
|
has_4_saves = true;
|
|
}
|
|
has_savegame = true;
|
|
if (file_corrupt)
|
|
{
|
|
UnicodeString corruptSlot;
|
|
#ifdef RAD_XBOX
|
|
corruptSlot.ReadUnicode( GetTextBibleString( "CORRUPT_SLOT_(XBOX)" ) );
|
|
#endif
|
|
#ifdef RAD_WIN32
|
|
corruptSlot.ReadUnicode( GetTextBibleString( "CORRUPT_SLOT_(XBOX)" ) );
|
|
#endif
|
|
#ifdef RAD_PS2
|
|
corruptSlot.ReadUnicode( GetTextBibleString( "CORRUPT_SLOT_(PS2)" ) );
|
|
#endif
|
|
#ifdef RAD_GAMECUBE
|
|
corruptSlot.ReadUnicode( GetTextBibleString( "CORRUPT_SLOT_(GC)" ) );
|
|
#endif
|
|
slotText->SetString(0,corruptSlot);
|
|
}
|
|
else
|
|
{
|
|
#ifdef RAD_XBOX
|
|
strcpy(gGameFileName[i], saveGameInfo.m_displayFilename); // cache the slot filename
|
|
#endif
|
|
slotText->SetString( 0, saveGameInfo.m_displayFilename );
|
|
}
|
|
|
|
// default to slot with most recent saved game file
|
|
//
|
|
const SaveGameInfoData* pData = saveGameInfo.GetData();
|
|
rAssert( pData != NULL );
|
|
if( SaveGameInfo::CompareTimeStamps( pData->m_timeStamp, mostRecentTimestamp ) > 0 )
|
|
{
|
|
memcpy( &mostRecentTimestamp, &pData->m_timeStamp, sizeof( radDate ) );
|
|
|
|
m_pMenu->Reset( i );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UnicodeString emptySlot;
|
|
emptySlot.ReadUnicode( GetTextBibleString( "EMPTY_SLOT" ) );
|
|
slotText->SetString( 0, emptySlot );
|
|
}
|
|
HeapMgr()->PopHeap(GMA_LEVEL_FE);
|
|
|
|
// enable slot selection only if save game exists
|
|
//
|
|
#ifdef RAD_PS2
|
|
m_pMenu->SetMenuItemEnabled( i, saveGameExists && !file_corrupt );
|
|
#else
|
|
m_pMenu->SetMenuItemEnabled( i, saveGameExists );
|
|
#endif // RAD_PS2
|
|
}
|
|
|
|
if (has_savegame==false) // no file in card
|
|
{
|
|
int prompt_id = PROMPT_LOAD_CARD_EMPTY_GC+PLATFORM_TEXT_INDEX;
|
|
#ifdef RAD_XBOX
|
|
if (GetMemoryCardManager()->GetCurrentDriveIndex()==0)
|
|
prompt_id = PROMPT_LOAD_CARD_EMPTY_XBOX_HD;
|
|
#endif
|
|
m_guiManager->DisplayPrompt(prompt_id,this,PROMPT_TYPE_CONTINUE);
|
|
m_numTransitionsPending = -1; // disable all transitions
|
|
}
|
|
else
|
|
{
|
|
#ifdef RAD_XBOX
|
|
// check if there are more than 4 files on hd
|
|
if ( has_4_saves
|
|
&& GetGameDataManager()->GetSaveGameInfo( currentDrive, NUM_GAME_SLOTS, &saveGameInfo, &file_corrupt )
|
|
)
|
|
{
|
|
m_pFullText->SetIndex( 8 );
|
|
m_pFullText->SetVisible(true);
|
|
|
|
}
|
|
#endif
|
|
this->SetButtonVisible( BUTTON_ICON_ACCEPT, true );
|
|
}
|
|
}
|
|
|
|
//===========================================================================
|
|
// CGuiScreenLoadGame::InitRunning
|
|
//===========================================================================
|
|
// Description:
|
|
//
|
|
// Constraints: None.
|
|
//
|
|
// Parameters: None.
|
|
//
|
|
// Return: N/A.
|
|
//
|
|
//===========================================================================
|
|
void CGuiScreenLoadGame::InitRunning()
|
|
{
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
// CGuiScreenLoadGame::InitOutro
|
|
//===========================================================================
|
|
// Description:
|
|
//
|
|
// Constraints: None.
|
|
//
|
|
// Parameters: None.
|
|
//
|
|
// Return: N/A.
|
|
//
|
|
//===========================================================================
|
|
void CGuiScreenLoadGame::InitOutro()
|
|
{
|
|
}
|
|
|
|
void
|
|
CGuiScreenLoadGame::GotoMemoryCardScreen( bool isFromPrompt )
|
|
{
|
|
#ifdef RAD_WIN32
|
|
if( isFromPrompt )
|
|
{
|
|
CGuiScreen* pScreen = static_cast<CGuiScreen*>( m_guiManager->FindWindowByID( GUI_SCREEN_ID_GENERIC_PROMPT ) );
|
|
rAssert( pScreen != NULL );
|
|
pScreen->StartTransitionAnimation( 230, 260 );
|
|
}
|
|
else
|
|
{
|
|
this->StartTransitionAnimation( 230, 260 );
|
|
}
|
|
|
|
m_pParent->HandleMessage( GUI_MSG_BACK_SCREEN );
|
|
#else
|
|
if( isFromPrompt )
|
|
{
|
|
s_forceGotoMemoryCardScreen = true;
|
|
this->ReloadScreen();
|
|
}
|
|
else
|
|
{
|
|
m_pParent->HandleMessage( GUI_MSG_GOTO_SCREEN, GUI_SCREEN_ID_MEMORY_CARD );
|
|
}
|
|
#endif // RAD_WIN32
|
|
}
|
|
|
|
void CGuiScreenLoadGame::LoadGame()
|
|
{
|
|
m_operation = LOAD;
|
|
|
|
#ifdef RAD_GAMECUBE
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_LOADING_GAME_GC, this );
|
|
#endif
|
|
|
|
#ifdef RAD_PS2
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_LOADING_GAME_PS2, this );
|
|
#endif
|
|
|
|
#ifdef RAD_XBOX
|
|
if( m_currentDriveIndex == 0 ) // xbox hard disk
|
|
{
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_LOADING_GAME_XBOX_HD, this );
|
|
}
|
|
else // xbox memory unit
|
|
{
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_LOADING_GAME_XBOX, this );
|
|
}
|
|
#endif
|
|
|
|
#ifdef RAD_WIN32
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_LOADING_GAME_PC, this );
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Private Functions
|
|
//---------------------------------------------------------------------
|
|
|
|
|
|
//===========================================================================
|
|
// Public Member Functions (for CGuiScreenAutoLoad)
|
|
//===========================================================================
|
|
|
|
int CGuiScreenAutoLoad::s_autoLoadGameSlot = -1;
|
|
|
|
CGuiScreenAutoLoad::CGuiScreenAutoLoad( Scrooby::Screen* pScreen, CGuiEntity* pParent )
|
|
: CGuiScreenLoadGame( pScreen, pParent, GUI_SCREEN_ID_AUTO_LOAD )
|
|
{
|
|
}
|
|
|
|
CGuiScreenAutoLoad::~CGuiScreenAutoLoad()
|
|
{
|
|
}
|
|
|
|
void
|
|
CGuiScreenAutoLoad::OnLoadGameComplete( radFileError errorCode )
|
|
{
|
|
GetGameDataManager()->RestoreDefaultMinimumLoadSaveTime();
|
|
|
|
if( errorCode == Success )
|
|
{
|
|
m_pParent->HandleMessage( GUI_MSG_MEMCARD_CHECK_COMPLETED );
|
|
}
|
|
else
|
|
{
|
|
CGuiScreenLoadGame::OnLoadGameComplete( errorCode );
|
|
}
|
|
}
|
|
|
|
void
|
|
CGuiScreenAutoLoad::InitIntro()
|
|
{
|
|
}
|
|
|
|
void
|
|
CGuiScreenAutoLoad::InitRunning()
|
|
{
|
|
m_currentDriveIndex = GetMemoryCardManager()->GetCurrentDriveIndex();
|
|
rAssert( m_currentDriveIndex != -1 );
|
|
|
|
IRadDrive* currentDrive = GetMemoryCardManager()->GetCurrentDrive();
|
|
if( currentDrive != NULL )
|
|
{
|
|
rReleasePrintf( "Auto-loading most recent saved game from drive %s\n",
|
|
currentDrive->GetDriveName() );
|
|
}
|
|
|
|
rAssert( s_autoLoadGameSlot != -1 );
|
|
m_currentSlot = s_autoLoadGameSlot;
|
|
#ifdef RAD_XBOX
|
|
// for xbox we need to get the filename from slot information first before loading
|
|
SaveGameInfo saveGameInfo;
|
|
gGameFileName[m_currentSlot][0] = 0; // initialize to empty string
|
|
rAssert(m_currentSlot < NUM_GAME_SLOTS);
|
|
bool saveGameExists = GetGameDataManager()->GetSaveGameInfo( currentDrive, m_currentSlot, &saveGameInfo );
|
|
if( saveGameExists ) // game filename is cached in gGameFileName global
|
|
{
|
|
strcpy( gGameFileName[m_currentSlot], saveGameInfo.m_displayFilename);
|
|
}
|
|
|
|
#endif
|
|
|
|
this->LoadGame();
|
|
}
|
|
|
|
void
|
|
CGuiScreenAutoLoad::InitOutro()
|
|
{
|
|
}
|
|
|
|
void
|
|
CGuiScreenAutoLoad::HandleErrorResponse( CGuiMenuPrompt::ePromptResponse response )
|
|
{
|
|
switch( response )
|
|
{
|
|
case (CGuiMenuPrompt::RESPONSE_CONTINUE):
|
|
{
|
|
m_pParent->HandleMessage( GUI_MSG_MEMCARD_CHECK_COMPLETED );
|
|
|
|
break;
|
|
}
|
|
case (CGuiMenuPrompt::RESPONSE_RETRY):
|
|
{
|
|
this->LoadGame();
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
rTunePrintf( "*** WARNING: Unhandled response for error [%d]!\n", m_lastError );
|
|
rAssert( false );
|
|
|
|
m_pParent->HandleMessage( GUI_MSG_MEMCARD_CHECK_COMPLETED );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
CGuiScreenLoadSave::HandleErrorResponse( response );
|
|
}
|
|
|
|
void
|
|
CGuiScreenAutoLoad::LoadGame()
|
|
{
|
|
m_operation = LOAD;
|
|
|
|
#ifdef RAD_GAMECUBE
|
|
// TC: GC does not require an auto-loading screen
|
|
//
|
|
// m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_AUTO_LOADING_GAME_GC, this );
|
|
GetGameDataManager()->LoadGame( m_currentSlot, this );
|
|
GetGameDataManager()->SetMinimumLoadSaveTime( 0 );
|
|
#endif
|
|
|
|
#ifdef RAD_PS2
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_AUTO_LOADING_GAME_PS2, this );
|
|
GetGameDataManager()->SetMinimumLoadSaveTime( AUTO_LOAD_MINIMUM_DISPLAY_TIME );
|
|
#endif
|
|
|
|
#ifdef RAD_XBOX
|
|
if( m_currentDriveIndex == 0 ) // xbox hard disk
|
|
{
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_AUTO_LOADING_GAME_XBOX_HD, this );
|
|
}
|
|
else // xbox memory unit
|
|
{
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_AUTO_LOADING_GAME_XBOX, this );
|
|
}
|
|
#endif
|
|
|
|
#ifdef RAD_WIN32
|
|
rAssert( m_currentDriveIndex == 0 );
|
|
m_guiManager->DisplayMessage( CGuiScreenMessage::MSG_ID_AUTO_LOADING_GAME_PC, this );
|
|
#endif
|
|
}
|
|
|