1424 lines
44 KiB
C++
1424 lines
44 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "BasePanel.h"
|
|
#include "SaveGameDialog.h"
|
|
|
|
#include "winlite.h" // FILETIME
|
|
#include "vgui/ILocalize.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "vgui/ISystem.h"
|
|
#include "vgui/IVGui.h"
|
|
|
|
#include "vgui_controls/AnimationController.h"
|
|
#include "vgui_controls/ImagePanel.h"
|
|
#include "filesystem.h"
|
|
#include "KeyValues.h"
|
|
#include "ModInfo.h"
|
|
#include "EngineInterface.h"
|
|
#include "GameUI_Interface.h"
|
|
#include "vstdlib/random.h"
|
|
|
|
#include "SaveGameBrowserDialog.h"
|
|
|
|
extern const char *COM_GetModDirectory( void );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CGameSavePanel::CGameSavePanel( CSaveGameBrowserDialog *parent, SaveGameDescription_t *pSaveDesc, bool bCommandPanel )
|
|
: BaseClass( parent, "SaveGamePanel" )
|
|
{
|
|
// Store our save description internally for reference later by our parent
|
|
m_SaveInfo = (*pSaveDesc);
|
|
m_bNewSavePanel = bCommandPanel;
|
|
|
|
// Setup our main graphical elements
|
|
m_pLevelPicBorder = SETUP_PANEL( new ImagePanel( this, "LevelPicBorder" ) );
|
|
m_pLevelPic = SETUP_PANEL( new ImagePanel( this, "LevelPic" ) );
|
|
|
|
// Setup our various labels
|
|
m_pChapterTitle = new Label( this, "ChapterLabel", m_SaveInfo.szComment );
|
|
m_pTime = new Label( this, "TimeLabel", m_SaveInfo.szFileTime );
|
|
m_pElapsedTime = new Label( this, "ElapsedLabel", m_SaveInfo.szElapsedTime );
|
|
m_pType = new Label( this, "TypeLabel", m_SaveInfo.szType );
|
|
|
|
// Make sure we have a chapter description
|
|
char *pchChapterName = Q_stristr( m_SaveInfo.szComment, "chapter" );
|
|
if ( pchChapterName )
|
|
{
|
|
char szChapterImage[ 256 ];
|
|
Q_snprintf( szChapterImage, sizeof(szChapterImage), "chapters/%s", Q_strlower( pchChapterName ) );
|
|
char *ext = Q_strrchr( szChapterImage, '_' );
|
|
if ( ext )
|
|
{
|
|
*ext = '\0';
|
|
}
|
|
m_pLevelPic->SetImage( szChapterImage );
|
|
}
|
|
else
|
|
{
|
|
m_pLevelPic->SetImage( "ui_logo" );
|
|
}
|
|
|
|
// Setup our basic settings
|
|
KeyValues *pKeys = NULL;
|
|
if ( GameUI().IsConsoleUI() )
|
|
{
|
|
pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "SaveGamePanel.res" );
|
|
}
|
|
LoadControlSettings( "Resource/SaveGamePanel.res", NULL, pKeys );
|
|
|
|
int px, py;
|
|
m_pLevelPicBorder->GetPos( px, py );
|
|
SetSize( m_pLevelPicBorder->GetWide(), py + m_pLevelPicBorder->GetTall() + ( m_pType->GetTall() + 16 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CGameSavePanel::~CGameSavePanel( void )
|
|
{
|
|
if ( m_pLevelPicBorder )
|
|
delete m_pLevelPicBorder;
|
|
|
|
if ( m_pLevelPic )
|
|
delete m_pLevelPic;
|
|
|
|
if ( m_pChapterTitle )
|
|
delete m_pChapterTitle;
|
|
|
|
if ( m_pTime )
|
|
delete m_pTime;
|
|
|
|
if ( m_pElapsedTime )
|
|
delete m_pElapsedTime;
|
|
|
|
if ( m_pType )
|
|
delete m_pType;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameSavePanel::ApplySchemeSettings( IScheme *pScheme )
|
|
{
|
|
m_TextColor = pScheme->GetColor( "NewGame.TextColor", Color(255, 255, 255, 255) );
|
|
m_FillColor = pScheme->GetColor( "NewGame.FillColor", Color(255, 255, 255, 255) );
|
|
m_DisabledColor = pScheme->GetColor( "NewGame.DisabledColor", Color(255, 255, 255, 4) );
|
|
m_SelectedColor = pScheme->GetColor( "NewGame.SelectionColor", Color(255, 255, 255, 255) );
|
|
|
|
// Turn various labels off if we're the "stubbed" panel
|
|
if ( m_bNewSavePanel )
|
|
{
|
|
m_pTime->SetVisible( false );
|
|
m_pElapsedTime->SetVisible( false );
|
|
m_pType->SetVisible( false );
|
|
}
|
|
|
|
// Setup our initial state
|
|
m_pChapterTitle->SetFgColor( m_TextColor );
|
|
m_pTime->SetFgColor( m_TextColor );
|
|
m_pElapsedTime->SetFgColor( m_TextColor );
|
|
|
|
m_pLevelPic->SetFillColor( Color( 0, 0, 0, 255 ) );
|
|
m_pLevelPicBorder->SetFillColor( Color( 0, 0, 0, 255 ) );
|
|
|
|
if ( m_bNewSavePanel )
|
|
{
|
|
float flScaleAmount = m_pLevelPic->GetScaleAmount();
|
|
if ( flScaleAmount <= 0.0f )
|
|
flScaleAmount = 1.0f;
|
|
|
|
// TBD: Draw the game logo here!
|
|
int picWide = 64.0f * flScaleAmount;
|
|
int picTall = 64.0f * flScaleAmount;
|
|
int borderWide = m_pLevelPicBorder->GetWide();
|
|
int borderTall = m_pLevelPicBorder->GetTall();
|
|
int borderX, borderY;
|
|
m_pLevelPicBorder->GetPos( borderX, borderY );
|
|
m_pLevelPic->SetPos( borderX + ( ( borderWide - picWide ) / 2 ), borderY + ( ( borderTall - picTall ) / 2 ) );
|
|
m_pLevelPic->SetFillColor( Color( 0, 0, 0, 0 ) );
|
|
}
|
|
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Overwrite the level description
|
|
// Input : *pDesc - Description to use
|
|
//-----------------------------------------------------------------------------
|
|
void CGameSavePanel::SetDescription( SaveGameDescription_t *pDesc )
|
|
{
|
|
// Store our save description internally for reference later by our parent
|
|
m_SaveInfo = (*pDesc);
|
|
|
|
// Setup our main graphical elements
|
|
m_pChapterTitle->SetText( m_SaveInfo.szComment );
|
|
m_pTime->SetText( m_SaveInfo.szFileTime );
|
|
m_pElapsedTime->SetText( m_SaveInfo.szElapsedTime );
|
|
m_pType->SetText( m_SaveInfo.szType );
|
|
|
|
// Make sure we have a chapter description
|
|
char *pchChapterName = Q_stristr( m_SaveInfo.szComment, "chapter" );
|
|
if ( pchChapterName )
|
|
{
|
|
char szChapterImage[ 256 ];
|
|
Q_snprintf( szChapterImage, sizeof(szChapterImage), "chapters/%s", Q_strlower( pchChapterName ) );
|
|
char *ext = Q_strrchr( szChapterImage, '_' );
|
|
if ( ext )
|
|
{
|
|
*ext = '\0';
|
|
}
|
|
m_pLevelPic->SetImage( szChapterImage );
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: new game chapter selection
|
|
//-----------------------------------------------------------------------------
|
|
CSaveGameBrowserDialog::CSaveGameBrowserDialog( vgui::Panel *parent )
|
|
: BaseClass( parent, "SaveGameDialog" ),
|
|
m_bFilterAutosaves( false ),
|
|
m_iSelectedSave( -1 ),
|
|
m_bScrolling( false ),
|
|
m_ScrollCt( 0 ),
|
|
m_ScrollSpeed( 0.0f ),
|
|
m_ButtonPressed( SCROLL_NONE ),
|
|
m_ScrollDirection( SCROLL_NONE ),
|
|
m_nDeletedPanel( INVALID_INDEX ),
|
|
m_nAddedPanel( INVALID_INDEX ),
|
|
m_nUsedStorageSpace( 0 ),
|
|
m_bControlDisabled( false )
|
|
{
|
|
// Setup basic attributes
|
|
SetDeleteSelfOnClose( true );
|
|
SetSizeable( false );
|
|
|
|
// Create the backer that highlights the currently selected save
|
|
m_pCenterBg = SETUP_PANEL( new Panel( this, "CenterBG" ) );
|
|
m_pCenterBg->SetPaintBackgroundType( 2 );
|
|
m_pCenterBg->SetVisible( true );
|
|
|
|
// Create our button footer
|
|
m_pFooter = new CFooterPanel( parent, "SaveGameFooter" );
|
|
|
|
// Load our res files from the keyvalue we're holding
|
|
KeyValues *pKeys = NULL;
|
|
if ( GameUI().IsConsoleUI() )
|
|
{
|
|
pKeys = BasePanel()->GetConsoleControlSettings()->FindKey( "SaveGameDialog.res" );
|
|
}
|
|
|
|
LoadControlSettings( "Resource/SaveGameDialog.res", NULL, pKeys );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CSaveGameBrowserDialog::~CSaveGameBrowserDialog( void )
|
|
{
|
|
// Release all elements
|
|
m_SavePanels.PurgeAndDeleteElements();
|
|
|
|
// Kill the footer
|
|
if ( m_pFooter )
|
|
{
|
|
delete m_pFooter;
|
|
m_pFooter = NULL;
|
|
}
|
|
|
|
if ( m_pCenterBg )
|
|
{
|
|
delete m_pCenterBg;
|
|
m_pCenterBg = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Show the "No save games to display" indication label and hide all browsing UI
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ShowNoSaveGameUI( void )
|
|
{
|
|
// Show the "no save games" text
|
|
vgui::Label *pNoSavesLabel = dynamic_cast<vgui::Label *>(FindChildByName( "NoSavesLabel" ));
|
|
if ( pNoSavesLabel )
|
|
{
|
|
if ( m_bSaveGameIsCorrupt )
|
|
{
|
|
pNoSavesLabel->SetText("#GameUI_SaveGame_CorruptFile");
|
|
}
|
|
else
|
|
{
|
|
pNoSavesLabel->SetText("#GameUI_NoSaveGamesToDisplay");
|
|
}
|
|
pNoSavesLabel->SetVisible( true );
|
|
}
|
|
|
|
if ( m_pCenterBg )
|
|
m_pCenterBg->SetVisible( false );
|
|
|
|
vgui::Panel *pLeftArrow = FindChildByName( "LeftArrow" );
|
|
if ( pLeftArrow )
|
|
pLeftArrow->SetVisible( false );
|
|
|
|
vgui::Panel *pRightArrow = FindChildByName( "RightArrow" );
|
|
if ( pRightArrow )
|
|
pRightArrow->SetVisible( false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Hide all "No save games" UI
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::HideNoSaveGameUI( void )
|
|
{
|
|
// Show the "no save games" text
|
|
vgui::Panel *pNoSavesLabel = FindChildByName( "NoSavesLabel" );
|
|
if ( pNoSavesLabel )
|
|
pNoSavesLabel->SetVisible( false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::LayoutPanels( void )
|
|
{
|
|
// Setup our panels depending on the mode we're in
|
|
if ( HasActivePanels() )
|
|
{
|
|
// Hide any indicators about no save games
|
|
HideNoSaveGameUI();
|
|
|
|
// Layout panel positions relative to the dialog center.
|
|
int panelWidth = m_SavePanels[0]->GetWide() + 16;
|
|
int dialogWidth = GetWide();
|
|
m_PanelXPos[2] = ( dialogWidth - panelWidth ) / 2 + 8;
|
|
m_PanelXPos[1] = m_PanelXPos[2] - panelWidth;
|
|
m_PanelXPos[0] = m_PanelXPos[1];
|
|
m_PanelXPos[3] = m_PanelXPos[2] + panelWidth;
|
|
m_PanelXPos[4] = m_PanelXPos[3];
|
|
|
|
m_PanelAlpha[0] = 0;
|
|
m_PanelAlpha[1] = 64;
|
|
m_PanelAlpha[2] = 255;
|
|
m_PanelAlpha[3] = 64;
|
|
m_PanelAlpha[4] = 0;
|
|
|
|
int panelHeight;
|
|
m_SavePanels[0]->GetSize( panelWidth, panelHeight );
|
|
m_pCenterBg->SetVisible( true );
|
|
m_pCenterBg->SetWide( panelWidth + 16 );
|
|
m_pCenterBg->SetPos( m_PanelXPos[2] - 8, m_PanelYPos[2] - (panelHeight - m_nCenterBgTallDefault) + 8 );
|
|
m_pCenterBg->SetBgColor( Color( 190, 115, 0, 255 ) );
|
|
}
|
|
else
|
|
{
|
|
// Hide anything to do with browsing the saves
|
|
ShowNoSaveGameUI();
|
|
|
|
}
|
|
|
|
// Do internal cleanup to make sure we present a correct state to the user
|
|
UpdateMenuComponents( SCROLL_NONE );
|
|
UpdateFooterOptions();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Do a fancy slide-out when we're first displayed
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::AnimateDialogStart( void )
|
|
{
|
|
const float flAnimInTime = 0.5f;
|
|
const float flOffset = 0.1f;
|
|
|
|
for ( int i = 0; i < NUM_SLOTS; i++ )
|
|
{
|
|
if ( m_PanelIndex[i] == INVALID_INDEX )
|
|
continue;
|
|
|
|
// Start us at the "opening" position
|
|
CGameSavePanel *panel = m_SavePanels[ m_PanelIndex[i] ];
|
|
if ( panel )
|
|
{
|
|
panel->SetPos( m_PanelXPos[0], m_PanelYPos[0] );
|
|
panel->SetAlpha( m_PanelAlpha[0] );
|
|
panel->SetVisible( true );
|
|
panel->SetEnabled( true );
|
|
panel->SetZPos( NUM_SLOTS - i );
|
|
}
|
|
|
|
// Now make them slide out where they're going
|
|
GetAnimationController()->RunAnimationCommand( panel, "xpos", m_PanelXPos[i], 0, flAnimInTime + (flOffset*i), vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
GetAnimationController()->RunAnimationCommand( panel, "ypos", m_PanelYPos[i], 0, flAnimInTime + (flOffset*i), vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
// Panel alpha
|
|
GetAnimationController()->RunAnimationCommand( panel, "alpha", m_PanelAlpha[i], 0, flAnimInTime + (flOffset*i), vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
}
|
|
|
|
// Move and fade the back label
|
|
m_pCenterBg->SetAlpha( 0 );
|
|
int nX, nY;
|
|
m_pCenterBg->GetPos( nX, nY );
|
|
m_pCenterBg->SetPos( nX-m_pCenterBg->GetWide(), nY );
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "xpos", nX, 0, flAnimInTime + (flOffset*2), vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "alpha", 255, 0, (flAnimInTime+ (flOffset*2))*2.0f, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
CGameSavePanel *selectedPanel = GetActivePanel();
|
|
if ( selectedPanel && selectedPanel->IsAutoSaveType() )
|
|
{
|
|
m_pCenterBg->SetTall( m_nCenterBgTallDefault + 20 );
|
|
}
|
|
else
|
|
{
|
|
m_pCenterBg->SetTall( m_nCenterBgTallDefault );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Do our initial layout
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::Activate( void )
|
|
{
|
|
// Start scanning for saved games
|
|
ScanSavedGames( m_bFilterAutosaves );
|
|
|
|
// Finish our layout depending on what the result of the scan was
|
|
LayoutPanels();
|
|
|
|
// Animate the opening animation
|
|
AnimateDialogStart();
|
|
|
|
BaseClass::Activate();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Apply special properties of the menu
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ApplySettings( KeyValues *inResourceData )
|
|
{
|
|
BaseClass::ApplySettings( inResourceData );
|
|
|
|
int ypos = inResourceData->GetInt( "chapterypos", 20 );
|
|
for ( int i = 0; i < NUM_SLOTS; ++i )
|
|
{
|
|
m_PanelYPos[i] = ypos;
|
|
}
|
|
|
|
m_nCenterBgTallDefault = inResourceData->GetInt( "centerbgtall", 0 );
|
|
m_pCenterBg->SetTall( m_nCenterBgTallDefault );
|
|
|
|
m_ScrollSpeedSlow = inResourceData->GetFloat( "scrollslow", 0.0f );
|
|
m_ScrollSpeedFast = inResourceData->GetFloat( "scrollfast", 0.0f );
|
|
SetFastScroll( false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Apply scheme settings
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
|
|
UpdateMenuComponents( SCROLL_NONE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets the correct properties for visible components
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::UpdateMenuComponents( EScrollDirection dir )
|
|
{
|
|
// This is called prior to any scrolling, so we need to look ahead to the post-scroll state
|
|
int centerIdx = SLOT_CENTER;
|
|
|
|
// Scroll given our direction of travel
|
|
if ( dir == SCROLL_LEFT )
|
|
{
|
|
++centerIdx;
|
|
}
|
|
else if ( dir == SCROLL_RIGHT )
|
|
{
|
|
--centerIdx;
|
|
}
|
|
|
|
int leftIdx = centerIdx - 1;
|
|
int rightIdx = centerIdx + 1;
|
|
|
|
// Update the state of the side arrows depending on whether or not we can scroll that direction
|
|
vgui::Panel *leftArrow = this->FindChildByName( "LeftArrow" );
|
|
vgui::Panel *rightArrow = this->FindChildByName( "RightArrow" );
|
|
if ( leftArrow )
|
|
{
|
|
leftArrow->SetVisible( true );
|
|
if ( m_PanelIndex[leftIdx] != INVALID_INDEX )
|
|
{
|
|
leftArrow->SetFgColor( Color( 255, 255, 255, 255 ) );
|
|
}
|
|
else
|
|
{
|
|
leftArrow->SetFgColor( Color( 128, 128, 128, 64 ) );
|
|
}
|
|
}
|
|
if ( rightArrow )
|
|
{
|
|
rightArrow->SetVisible( true );
|
|
if ( m_PanelIndex[rightIdx] != INVALID_INDEX )
|
|
{
|
|
rightArrow->SetFgColor( Color( 255, 255, 255, 255 ) );
|
|
}
|
|
else
|
|
{
|
|
rightArrow->SetFgColor( Color( 128, 128, 128, 64 ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets a chapter as selected
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::SetSelectedSaveIndex( int index )
|
|
{
|
|
m_iSelectedSave = index;
|
|
|
|
// If we have no panels, there's nothing to update
|
|
if ( HasActivePanels() == false )
|
|
return;
|
|
|
|
// Setup panels to the left of the selected panel
|
|
int currIdx = index;
|
|
for ( int i = SLOT_CENTER; i >= 0 && currIdx >= 0; --i )
|
|
{
|
|
m_PanelIndex[i] = currIdx;
|
|
--currIdx;
|
|
InitPanelIndexForDisplay( i );
|
|
}
|
|
|
|
// Setup panels to the right of the selected panel
|
|
currIdx = index + 1;
|
|
for ( int i = SLOT_CENTER + 1; i < NUM_SLOTS && currIdx < m_SavePanels.Count(); ++i )
|
|
{
|
|
m_PanelIndex[i] = currIdx;
|
|
++currIdx;
|
|
InitPanelIndexForDisplay( i );
|
|
}
|
|
|
|
UpdateMenuComponents( SCROLL_NONE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Remove the currently selected animation from the list with proper animations
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::RemoveActivePanel( void )
|
|
{
|
|
// Kill the current panel
|
|
m_nDeletedPanel = m_PanelIndex[SLOT_CENTER];
|
|
|
|
// Start our current panel fading
|
|
CGameSavePanel *pPanel = m_SavePanels[ m_nDeletedPanel ];
|
|
GetAnimationController()->RunAnimationCommand( pPanel, "alpha", 0, 0, m_ScrollSpeedFast, vgui::AnimationController::INTERPOLATOR_ACCEL );
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "alpha", 0, 0, m_ScrollSpeedFast, vgui::AnimationController::INTERPOLATOR_ACCEL );
|
|
PostMessage( this, new KeyValues( "FinishDelete" ), m_ScrollSpeed );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::CloseAfterSave( void )
|
|
{
|
|
OnCommand( "CloseAndSelectResume" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::FinishInsert( void )
|
|
{
|
|
CGameSavePanel *panel = m_SavePanels[ m_nAddedPanel ];
|
|
|
|
const float flScrollSpeed = 0.75f;
|
|
|
|
// Run the actual movement
|
|
GetAnimationController()->RunAnimationCommand( panel, "xpos", m_PanelXPos[SLOT_RIGHT], 0, flScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
GetAnimationController()->RunAnimationCommand( panel, "ypos", m_PanelYPos[SLOT_RIGHT], 0, flScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
// Panel alpha
|
|
GetAnimationController()->RunAnimationCommand( panel, "alpha", 255, 0, flScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
PostMessage( this, new KeyValues( "CloseAfterSave" ), flScrollSpeed*2.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Insert a new panel at the desired location
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::AnimateInsertNewPanel( const SaveGameDescription_t *pDesc )
|
|
{
|
|
// This is the panel that's going to move
|
|
CGameSavePanel *pNewPanel = SETUP_PANEL( new CGameSavePanel( this, (SaveGameDescription_t *) pDesc ) );
|
|
pNewPanel->SetVisible( false );
|
|
|
|
// Tack this onto the list
|
|
m_nAddedPanel = m_SavePanels.InsertAfter( 0, pNewPanel );
|
|
|
|
// Set it up but turn it off immediately
|
|
pNewPanel->SetPos( m_PanelXPos[SLOT_CENTER], m_PanelYPos[SLOT_CENTER] );
|
|
pNewPanel->SetVisible( true );
|
|
pNewPanel->SetEnabled( true );
|
|
pNewPanel->SetZPos( 0 );
|
|
pNewPanel->SetAlpha( 0.0f );
|
|
|
|
// Increment our indices to reflect the change
|
|
for ( int i = 0; i < NUM_SLOTS; i++ )
|
|
{
|
|
if ( m_PanelIndex[i] == INVALID_INDEX )
|
|
continue;
|
|
|
|
if ( m_PanelIndex[i] > 0 )
|
|
{
|
|
m_PanelIndex[i]++;
|
|
}
|
|
}
|
|
|
|
// Fade the right panel away
|
|
if ( IsValidPanel( m_PanelIndex[ SLOT_RIGHT ] ) )
|
|
{
|
|
CGameSavePanel *panel = m_SavePanels[ m_PanelIndex[ SLOT_RIGHT ] ];
|
|
|
|
// Run the actual movement
|
|
GetAnimationController()->RunAnimationCommand( panel, "xpos", m_PanelXPos[SLOT_OFFRIGHT], 0, m_ScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
GetAnimationController()->RunAnimationCommand( panel, "ypos", m_PanelYPos[SLOT_OFFRIGHT], 0, m_ScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
// Panel alpha
|
|
GetAnimationController()->RunAnimationCommand( panel, "alpha", m_PanelAlpha[SLOT_OFFRIGHT], 0, m_ScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
PostMessage( this, new KeyValues( "FinishInsert" ), m_ScrollSpeed );
|
|
}
|
|
else
|
|
{
|
|
PostMessage( this, new KeyValues( "FinishInsert" ), 0.1f );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Pop in the new description
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::FinishOverwriteFadeDown( void )
|
|
{
|
|
const float flFadeInTime = 0.25f;
|
|
|
|
// Fade the right panel away
|
|
CGameSavePanel *pActivePanel = GetActivePanel();
|
|
if ( pActivePanel )
|
|
{
|
|
pActivePanel->SetDescription( &m_NewSaveGameDesc );
|
|
|
|
// Panel alpha
|
|
GetAnimationController()->RunAnimationCommand( pActivePanel, "alpha", m_PanelAlpha[SLOT_CENTER], 0, flFadeInTime, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
}
|
|
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "alpha", 255, 0, flFadeInTime, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
PostMessage( this, new KeyValues( "CloseAfterSave" ), flFadeInTime + 0.1f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Animate an overwrite event by fading out the old panel and bringing it back with a new description
|
|
// Input : *pNewDesc - The new description to display
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::AnimateOverwriteActivePanel( const SaveGameDescription_t *pNewDesc )
|
|
{
|
|
// Save a copy of this description
|
|
m_NewSaveGameDesc = (*pNewDesc);
|
|
|
|
// Fade the right panel away
|
|
CGameSavePanel *pActivePanel = GetActivePanel();
|
|
if ( pActivePanel )
|
|
{
|
|
// Panel alpha
|
|
GetAnimationController()->RunAnimationCommand( pActivePanel, "alpha", 0, 0, 0.5f, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
}
|
|
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "alpha", 0, 0, 0.5f, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
PostMessage( this, new KeyValues( "FinishOverwriteFadeDown" ), 0.75f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called before a panel scroll starts.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::PreScroll( EScrollDirection dir )
|
|
{
|
|
int hideIdx = INVALID_INDEX;
|
|
if ( m_nDeletedPanel != INVALID_INDEX )
|
|
{
|
|
hideIdx = m_nDeletedPanel;
|
|
}
|
|
else if ( dir == SCROLL_LEFT )
|
|
{
|
|
hideIdx = m_PanelIndex[SLOT_LEFT];
|
|
}
|
|
else if ( dir == SCROLL_RIGHT )
|
|
{
|
|
hideIdx = m_PanelIndex[SLOT_RIGHT];
|
|
}
|
|
|
|
if ( hideIdx != INVALID_INDEX )
|
|
{
|
|
// Push back the panel that's about to be hidden
|
|
// so the next panel scrolls over the top of it.
|
|
m_SavePanels[hideIdx]->SetZPos( 0 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called after a panel scroll finishes.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::PostScroll( EScrollDirection dir )
|
|
{
|
|
// FIXME: Nothing to do here...
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initiates a panel scroll and starts the animation.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ScrollSelectionPanels( EScrollDirection dir )
|
|
{
|
|
// Only initiate a scroll if panels aren't currently scrolling
|
|
if ( !m_bScrolling )
|
|
{
|
|
// Handle any pre-scroll setup
|
|
PreScroll( dir );
|
|
|
|
if ( dir == SCROLL_LEFT)
|
|
{
|
|
m_ScrollCt += SCROLL_LEFT;
|
|
}
|
|
else if ( dir == SCROLL_RIGHT && m_PanelIndex[SLOT_CENTER] != 0 )
|
|
{
|
|
m_ScrollCt += SCROLL_RIGHT;
|
|
}
|
|
|
|
m_bScrolling = true;
|
|
AnimateSelectionPanels();
|
|
|
|
// Update the arrow colors, help text, and buttons. Doing it here looks better than having
|
|
// the components change after the entire scroll animation has finished.
|
|
UpdateMenuComponents( m_ScrollDirection );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Do all slide animation work here
|
|
// Input : nPanelIndex - Panel we're currently operating on
|
|
// nNextPanelIndex - Panel we're going to be moving over
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::PerformSlideAction( int nPanelIndex, int nNextPanelIndex )
|
|
{
|
|
CGameSavePanel *panel = m_SavePanels[ m_PanelIndex[ nPanelIndex ] ];
|
|
|
|
// Run the actual movement
|
|
GetAnimationController()->RunAnimationCommand( panel, "xpos", m_PanelXPos[nNextPanelIndex], 0, m_ScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
GetAnimationController()->RunAnimationCommand( panel, "ypos", m_PanelYPos[nNextPanelIndex], 0, m_ScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
// Panel alpha
|
|
GetAnimationController()->RunAnimationCommand( panel, "alpha", m_PanelAlpha[nNextPanelIndex], 0, m_ScrollSpeed, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initiates the scripted scroll and fade effects of all five slotted panels
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::AnimateSelectionPanels( void )
|
|
{
|
|
int idxOffset = 0;
|
|
int startIdx = SLOT_LEFT;
|
|
int endIdx = SLOT_RIGHT;
|
|
|
|
// Don't scroll outside the bounds of the panel list
|
|
if ( m_ScrollCt >= SCROLL_LEFT && m_PanelIndex[SLOT_CENTER] < m_SavePanels.Count() - 1 )
|
|
{
|
|
if ( m_nDeletedPanel != INVALID_INDEX )
|
|
{
|
|
startIdx = SLOT_RIGHT;
|
|
}
|
|
|
|
idxOffset = -1;
|
|
endIdx = SLOT_OFFRIGHT;
|
|
m_ScrollDirection = SCROLL_LEFT;
|
|
}
|
|
else if ( m_ScrollCt <= SCROLL_RIGHT && m_PanelIndex[SLOT_CENTER] > 0 )
|
|
{
|
|
idxOffset = 1;
|
|
startIdx = SLOT_OFFLEFT;
|
|
m_ScrollDirection = SCROLL_RIGHT;
|
|
}
|
|
|
|
if ( 0 == idxOffset )
|
|
{
|
|
// Kill the scroll, it's outside the bounds
|
|
m_ScrollCt = 0;
|
|
m_bScrolling = false;
|
|
m_ScrollDirection = SCROLL_NONE;
|
|
vgui::surface()->PlaySound( "player/suit_denydevice.wav" );
|
|
return;
|
|
}
|
|
|
|
// Should never happen
|
|
if ( startIdx > endIdx )
|
|
return;
|
|
|
|
for ( int i = startIdx; i <= endIdx; ++i )
|
|
{
|
|
// Don't animate the special panel, just skip it
|
|
if ( m_PanelIndex[i] == m_nDeletedPanel )
|
|
continue;
|
|
|
|
int nNextIdx = i+idxOffset;
|
|
if ( m_PanelIndex[i] != INVALID_INDEX )
|
|
{
|
|
PerformSlideAction( i, nNextIdx );
|
|
}
|
|
}
|
|
|
|
vgui::surface()->PlaySound( "UI/buttonclick.wav" );
|
|
|
|
// Animate the center background panel
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "alpha", 0, 0, m_ScrollSpeed * 0.25f, vgui::AnimationController::INTERPOLATOR_SIMPLESPLINE );
|
|
|
|
// Scrolling up through chapters, offset is negative
|
|
m_iSelectedSave -= idxOffset;
|
|
|
|
UpdateFooterOptions();
|
|
|
|
PostMessage( this, new KeyValues( "FinishScroll" ), m_ScrollSpeed );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: After a scroll, each panel slot holds the index of a panel that has
|
|
// scrolled to an adjacent slot. This function updates each slot so
|
|
// it holds the index of the panel that is actually in that slot's position.
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ShiftPanelIndices( int offset )
|
|
{
|
|
// Shift all the elements over one slot, then calculate what the last slot's index should be.
|
|
int lastSlot = NUM_SLOTS - 1;
|
|
|
|
// Handle the deletion case
|
|
if ( m_nDeletedPanel != INVALID_INDEX )
|
|
{
|
|
// Scroll panels in from the right
|
|
Q_memmove( &m_PanelIndex[SLOT_CENTER], &m_PanelIndex[SLOT_RIGHT], 2* sizeof( m_PanelIndex[SLOT_CENTER] ) );
|
|
|
|
if ( m_PanelIndex[lastSlot] != INVALID_INDEX )
|
|
{
|
|
int num = m_PanelIndex[ lastSlot ] + 1;
|
|
if ( IsValidPanel( num ) )
|
|
{
|
|
m_PanelIndex[lastSlot] = num;
|
|
InitPanelIndexForDisplay( lastSlot );
|
|
}
|
|
else
|
|
{
|
|
m_PanelIndex[lastSlot] = INVALID_INDEX;
|
|
}
|
|
}
|
|
}
|
|
else if ( offset > 0 )
|
|
{
|
|
// Hide the panel that's dropping out of the slots
|
|
if ( IsValidPanel( m_PanelIndex[0] ) )
|
|
{
|
|
m_SavePanels[ m_PanelIndex[0] ]->SetVisible( false );
|
|
}
|
|
|
|
// Scrolled panels to the right, so shift the indices one slot to the left
|
|
Q_memmove( &m_PanelIndex[0], &m_PanelIndex[1], lastSlot * sizeof( m_PanelIndex[0] ) );
|
|
if ( m_PanelIndex[lastSlot] != INVALID_INDEX )
|
|
{
|
|
int num = m_PanelIndex[ lastSlot ] + 1;
|
|
if ( IsValidPanel( num ) )
|
|
{
|
|
m_PanelIndex[lastSlot] = num;
|
|
InitPanelIndexForDisplay( lastSlot );
|
|
}
|
|
else
|
|
{
|
|
m_PanelIndex[lastSlot] = INVALID_INDEX;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Hide the panel that's dropping out of the slots
|
|
if ( IsValidPanel( m_PanelIndex[lastSlot] ) )
|
|
{
|
|
m_SavePanels[ m_PanelIndex[lastSlot] ]->SetVisible( false );
|
|
}
|
|
|
|
// Scrolled panels to the left, so shift the indices one slot to the right
|
|
Q_memmove( &m_PanelIndex[1], &m_PanelIndex[0], lastSlot * sizeof( m_PanelIndex[0] ) );
|
|
if ( m_PanelIndex[0] != INVALID_INDEX )
|
|
{
|
|
int num = m_PanelIndex[0] - 1;
|
|
if ( IsValidPanel( num ) )
|
|
{
|
|
m_PanelIndex[0] = num;
|
|
InitPanelIndexForDisplay( 0 );
|
|
}
|
|
else
|
|
{
|
|
m_PanelIndex[0] = INVALID_INDEX;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Validates an index into the selection panels vector
|
|
//-----------------------------------------------------------------------------
|
|
bool CSaveGameBrowserDialog::IsValidPanel( const int idx )
|
|
{
|
|
if ( idx < 0 || idx >= m_SavePanels.Count() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets up a panel's properties before it is displayed
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::InitPanelIndexForDisplay( const int idx )
|
|
{
|
|
CGameSavePanel *panel = m_SavePanels[ m_PanelIndex[idx] ];
|
|
if ( panel )
|
|
{
|
|
panel->SetPos( m_PanelXPos[idx], m_PanelYPos[idx] );
|
|
panel->SetAlpha( m_PanelAlpha[idx] );
|
|
panel->SetVisible( true );
|
|
panel->SetEnabled( true );
|
|
if ( m_PanelAlpha[idx] )
|
|
{
|
|
panel->SetZPos( NUM_SLOTS );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets which scroll speed should be used
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::SetFastScroll( bool fast )
|
|
{
|
|
m_ScrollSpeed = fast ? m_ScrollSpeedFast : m_ScrollSpeedSlow;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks if a button is being held down, and speeds up the scroll
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ContinueScrolling( void )
|
|
{
|
|
if ( !GameUI().IsConsoleUI() )
|
|
{
|
|
if ( m_PanelIndex[SLOT_CENTER-1] % 3 )
|
|
{
|
|
ScrollSelectionPanels( m_ScrollDirection );
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( m_ButtonPressed == m_ScrollDirection )
|
|
{
|
|
SetFastScroll( true );
|
|
ScrollSelectionPanels( m_ScrollDirection );
|
|
}
|
|
else if ( m_ButtonPressed != SCROLL_NONE )
|
|
{
|
|
// The other direction has been pressed - start a slow scroll
|
|
SetFastScroll( false );
|
|
ScrollSelectionPanels( (EScrollDirection)m_ButtonPressed );
|
|
}
|
|
else
|
|
{
|
|
SetFastScroll( false );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fade animation has finished, now slide or be done
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::FinishDelete( void )
|
|
{
|
|
// Catch the case where all saves are now gone!
|
|
if ( m_SavePanels.Count() == 1 )
|
|
{
|
|
m_nDeletedPanel = INVALID_INDEX;
|
|
m_SavePanels.PurgeAndDeleteElements();
|
|
|
|
for ( int i = 0; i < NUM_SLOTS; i++ )
|
|
{
|
|
m_PanelIndex[i] = INVALID_INDEX;
|
|
}
|
|
|
|
LayoutPanels();
|
|
return;
|
|
}
|
|
|
|
EScrollDirection nDirection = ( IsValidPanel( m_nDeletedPanel + 1 ) ) ? SCROLL_LEFT : SCROLL_RIGHT;
|
|
ScrollSelectionPanels( nDirection );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when a scroll distance of one slot has been completed
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::FinishScroll( void )
|
|
{
|
|
// Fade the center bg panel back in
|
|
GetAnimationController()->RunAnimationCommand( m_pCenterBg, "alpha", 255, 0, m_ScrollSpeed * 0.25f, vgui::AnimationController::INTERPOLATOR_LINEAR );
|
|
|
|
ShiftPanelIndices( m_ScrollDirection );
|
|
m_bScrolling = false;
|
|
m_ScrollCt = 0;
|
|
|
|
// End of scroll step
|
|
PostScroll( m_ScrollDirection );
|
|
|
|
if ( m_nDeletedPanel != INVALID_INDEX )
|
|
{
|
|
// Find where we're going next
|
|
int newSave = m_nDeletedPanel;
|
|
if ( m_SavePanels.IsValidIndex( m_nDeletedPanel + 1 ) == false )
|
|
{
|
|
newSave = m_nDeletedPanel - 1;
|
|
}
|
|
|
|
// Remove it from our list
|
|
CGameSavePanel *pPanel = m_SavePanels[ m_nDeletedPanel ];
|
|
m_SavePanels.Remove( m_nDeletedPanel );
|
|
delete pPanel;
|
|
|
|
// Decrement all the indices to reflect the change
|
|
for ( int i = 0; i < NUM_SLOTS; i++ )
|
|
{
|
|
if ( m_PanelIndex[i] > m_nDeletedPanel )
|
|
m_PanelIndex[i]--;
|
|
}
|
|
|
|
// Clear the spot and be done with it
|
|
SetSelectedSaveIndex( newSave );
|
|
m_nDeletedPanel = INVALID_INDEX;
|
|
UpdateMenuComponents( SCROLL_NONE );
|
|
}
|
|
|
|
// Size the "autosave" blade if need-be
|
|
CGameSavePanel *selectedPanel = GetActivePanel();
|
|
if ( selectedPanel && selectedPanel->IsAutoSaveType() )
|
|
{
|
|
m_pCenterBg->SetTall( m_nCenterBgTallDefault + 20 );
|
|
}
|
|
else
|
|
{
|
|
m_pCenterBg->SetTall( m_nCenterBgTallDefault );
|
|
}
|
|
|
|
// Continue scrolling if necessary
|
|
ContinueScrolling();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::OnClose( void )
|
|
{
|
|
SetControlDisabled( true );
|
|
|
|
m_KeyRepeat.Reset();
|
|
BasePanel()->RunCloseAnimation( "CloseNewGameDialog_OpenMainMenu" );
|
|
|
|
BaseClass::OnClose();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Our save games have changed, so layout our panel again
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::RefreshSaveGames( void )
|
|
{
|
|
// Close any pending messages
|
|
BasePanel()->CloseMessageDialog( DIALOG_STACK_IDX_WARNING );
|
|
|
|
// Don't leave us in a locked state
|
|
SetControlDisabled( false );
|
|
|
|
// Re-scan the saved games
|
|
ScanSavedGames( m_bFilterAutosaves );
|
|
|
|
// Re-layout the panels
|
|
LayoutPanels();
|
|
|
|
// Run our animation again
|
|
AnimateDialogStart();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::PerformSelectedAction( void )
|
|
{
|
|
// By default, do nothing
|
|
m_KeyRepeat.Reset();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::PerformDeletion( void )
|
|
{
|
|
// By default, do nothing
|
|
m_KeyRepeat.Reset();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Release our key repeater
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::OnKeyCodeReleased( vgui::KeyCode code )
|
|
{
|
|
m_KeyRepeat.KeyUp( code );
|
|
|
|
BaseClass::OnKeyCodeReleased( code );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Update our keypress repeater
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::OnThink( void )
|
|
{
|
|
vgui::KeyCode code = m_KeyRepeat.KeyRepeated();
|
|
if ( code )
|
|
{
|
|
OnKeyCodePressed( code );
|
|
}
|
|
|
|
BaseClass::OnThink();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::OnKeyCodePressed( vgui::KeyCode code )
|
|
{
|
|
// If the console has UI up, then ignore it
|
|
if ( BasePanel()->IsWaitingForConsoleUI() )
|
|
return;
|
|
|
|
// Inhibit key activity during transitions
|
|
if ( GetAlpha() != 255 || m_bControlDisabled )
|
|
return;
|
|
|
|
m_KeyRepeat.KeyDown( code );
|
|
|
|
switch( code )
|
|
{
|
|
case KEY_XBUTTON_A:
|
|
case STEAMCONTROLLER_A:
|
|
PerformSelectedAction();
|
|
break;
|
|
|
|
case KEY_XBUTTON_B:
|
|
case STEAMCONTROLLER_B:
|
|
OnClose();
|
|
break;
|
|
|
|
case KEY_XBUTTON_X:
|
|
case STEAMCONTROLLER_X:
|
|
PerformDeletion();
|
|
break;
|
|
|
|
case KEY_XBUTTON_Y:
|
|
case STEAMCONTROLLER_Y:
|
|
BasePanel()->OnChangeStorageDevice();
|
|
break;
|
|
|
|
// Move the selection up and down
|
|
case KEY_XSTICK1_LEFT:
|
|
case KEY_XBUTTON_LEFT:
|
|
case STEAMCONTROLLER_DPAD_LEFT:
|
|
ScrollSelectionPanels( SCROLL_RIGHT );
|
|
break;
|
|
|
|
case KEY_XSTICK1_RIGHT:
|
|
case KEY_XBUTTON_RIGHT:
|
|
case STEAMCONTROLLER_DPAD_RIGHT:
|
|
ScrollSelectionPanels( SCROLL_LEFT );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::PaintBackground( void )
|
|
{
|
|
int wide, tall;
|
|
GetSize( wide, tall );
|
|
|
|
Color col = GetBgColor();
|
|
DrawBox( 0, 0, wide, tall, col, 1.0f );
|
|
|
|
int y = 32;
|
|
|
|
// draw an inset
|
|
Color darkColor;
|
|
darkColor.SetColor( 0.70f * (float)col.r(), 0.70f * (float)col.g(), 0.70f * (float)col.b(), col.a() );
|
|
vgui::surface()->DrawSetColor( darkColor );
|
|
vgui::surface()->DrawFilledRect( 8, y, wide - 8, tall - 8 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parses the save game info out of the .sav file header
|
|
//-----------------------------------------------------------------------------
|
|
bool CSaveGameBrowserDialog::ParseSaveData( char const *pszFileName, char const *pszShortName, SaveGameDescription_t *save )
|
|
{
|
|
char szMapName[SAVEGAME_MAPNAME_LEN];
|
|
char szComment[SAVEGAME_COMMENT_LEN];
|
|
char szElapsedTime[SAVEGAME_ELAPSED_LEN];
|
|
|
|
if ( !pszFileName || !pszShortName )
|
|
return false;
|
|
|
|
Q_strncpy( save->szShortName, pszShortName, sizeof(save->szShortName) );
|
|
Q_strncpy( save->szFileName, pszFileName, sizeof(save->szFileName) );
|
|
|
|
FileHandle_t fh = g_pFullFileSystem->Open( pszFileName, "rb", "MOD" );
|
|
if (fh == FILESYSTEM_INVALID_HANDLE)
|
|
return false;
|
|
|
|
save->iSize = g_pFullFileSystem->Size( fh );
|
|
|
|
int readok = SaveReadNameAndComment( fh, szMapName, sizeof(szMapName), szComment, sizeof(szComment) );
|
|
g_pFullFileSystem->Close(fh);
|
|
|
|
if ( !readok )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Q_strncpy( save->szMapName, szMapName, sizeof(save->szMapName) );
|
|
|
|
// Elapsed time is the last 6 characters in comment. (mmm:ss)
|
|
int i;
|
|
i = strlen( szComment );
|
|
Q_strncpy( szElapsedTime, "??", sizeof( szElapsedTime ) );
|
|
if (i >= 6)
|
|
{
|
|
Q_strncpy( szElapsedTime, (char *)&szComment[i - 6], 7 );
|
|
szElapsedTime[6] = '\0';
|
|
|
|
// parse out
|
|
int minutes = atoi( szElapsedTime );
|
|
int seconds = atoi( szElapsedTime + 4);
|
|
int hours = minutes / 60;
|
|
minutes %= 60;
|
|
|
|
wchar_t wzHours[6];
|
|
wchar_t wzMins[4];
|
|
wchar_t wzSecs[4];
|
|
|
|
_snwprintf( wzHours, ARRAYSIZE(wzHours), L"%d", hours );
|
|
_snwprintf( wzMins, ARRAYSIZE(wzMins), L"%d", minutes );
|
|
_snwprintf( wzSecs, ARRAYSIZE(wzSecs), L"%d", seconds );
|
|
|
|
wchar_t buf[20];
|
|
|
|
// reformat
|
|
if ( hours )
|
|
{
|
|
g_pVGuiLocalize->ConstructString( buf, sizeof( buf ), g_pVGuiLocalize->Find( "#GameUI_LoadDialog_Hr_Min" ), 2, wzHours, wzMins );
|
|
}
|
|
else if ( minutes )
|
|
{
|
|
g_pVGuiLocalize->ConstructString( buf, sizeof( buf ), g_pVGuiLocalize->Find( "#GameUI_LoadDialog_Min_Sec" ), 2, wzMins, wzSecs );
|
|
}
|
|
else
|
|
{
|
|
g_pVGuiLocalize->ConstructString( buf, sizeof( buf ), g_pVGuiLocalize->Find( "#GameUI_LoadDialog_Sec" ), 1, wzSecs );
|
|
}
|
|
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( buf, szElapsedTime, sizeof(szElapsedTime) );
|
|
|
|
// Chop elapsed out of comment.
|
|
char *pChop = Q_stristr( szComment, " " );
|
|
if ( pChop != NULL )
|
|
{
|
|
(*pChop) = '\0';
|
|
}
|
|
}
|
|
|
|
// calculate the file name to print
|
|
const char *pszType = "";
|
|
if (strstr(pszFileName, "quick"))
|
|
{
|
|
pszType = "#GameUI_QuickSave";
|
|
}
|
|
else if (strstr(pszFileName, "autosave"))
|
|
{
|
|
pszType = "#GameUI_AutoSave";
|
|
}
|
|
|
|
Q_strncpy( save->szType, pszType, sizeof(save->szType) );
|
|
Q_strncpy( save->szComment, szComment, sizeof(save->szComment) );
|
|
Q_strncpy( save->szElapsedTime, szElapsedTime, sizeof(save->szElapsedTime) );
|
|
|
|
// Now get file time stamp.
|
|
long fileTime = g_pFullFileSystem->GetFileTime(pszFileName);
|
|
char szFileTime[32];
|
|
g_pFullFileSystem->FileTimeToString(szFileTime, sizeof(szFileTime), fileTime);
|
|
char *newline = strstr(szFileTime, "\n");
|
|
if (newline)
|
|
{
|
|
*newline = 0;
|
|
}
|
|
Q_strncpy( save->szFileTime, szFileTime, sizeof(save->szFileTime) );
|
|
save->iTimestamp = fileTime;
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Update our footer options depending on what we've selected
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::UpdateFooterOptions( void )
|
|
{
|
|
// Do nothing
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sort our games by time
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::SortSaveGames( SaveGameDescription_t *pSaves, unsigned int nNumSaves )
|
|
{
|
|
qsort( pSaves, nNumSaves, sizeof(SaveGameDescription_t), &CBaseSaveGameDialog::SaveGameSortFunc );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: builds save game list from directory
|
|
//-----------------------------------------------------------------------------
|
|
void CSaveGameBrowserDialog::ScanSavedGames( bool bIgnoreAutosave )
|
|
{
|
|
// Start with a clean slate
|
|
m_nUsedStorageSpace = 0;
|
|
m_bSaveGameIsCorrupt = false;
|
|
|
|
// Clear all known panels I'm holding now
|
|
m_SavePanels.PurgeAndDeleteElements();
|
|
|
|
// Reset all indices
|
|
for ( int i = 0; i < NUM_SLOTS; ++i )
|
|
{
|
|
m_PanelIndex[i] = INVALID_INDEX;
|
|
}
|
|
|
|
// Clear our list
|
|
CUtlVector<SaveGameDescription_t> saveGames;
|
|
|
|
// Get the search path
|
|
char szDirectory[_MAX_PATH];
|
|
|
|
if ( IsX360() )
|
|
Q_snprintf( szDirectory, sizeof( szDirectory ), "%s:/*", COM_GetModDirectory() );
|
|
else
|
|
Q_snprintf( szDirectory, sizeof( szDirectory ), "save/*" );
|
|
|
|
Q_DefaultExtension( szDirectory, IsX360() ? ".360.sav" : ".sav", sizeof( szDirectory ) );
|
|
Q_FixSlashes( szDirectory );
|
|
|
|
// iterate the saved files
|
|
FileFindHandle_t handle;
|
|
const char *pFileName = g_pFullFileSystem->FindFirst( szDirectory, &handle );
|
|
while (pFileName)
|
|
{
|
|
if ( !Q_strnicmp(pFileName, "HLSave", strlen( "HLSave" ) ) )
|
|
{
|
|
pFileName = g_pFullFileSystem->FindNext( handle );
|
|
continue;
|
|
}
|
|
|
|
char szFileName[_MAX_PATH];
|
|
|
|
if ( IsX360() )
|
|
Q_snprintf(szFileName, sizeof( szFileName ), "%s:/%s", COM_GetModDirectory(), pFileName );
|
|
else
|
|
Q_snprintf(szFileName, sizeof( szFileName ), "save/%s", pFileName);
|
|
|
|
Q_FixSlashes( szFileName );
|
|
|
|
// Only load save games from the current mod's save dir
|
|
if( !g_pFullFileSystem->FileExists( szFileName, "MOD" ) )
|
|
{
|
|
pFileName = g_pFullFileSystem->FindNext( handle );
|
|
continue;
|
|
}
|
|
|
|
SaveGameDescription_t save;
|
|
if ( ParseSaveData( szFileName, pFileName, &save ) )
|
|
{
|
|
// Add on this file's size to the count
|
|
m_nUsedStorageSpace += save.iSize;
|
|
|
|
// Always ignore autosave dangerous (they're not considered safe until committed)
|
|
if ( Q_stristr( save.szShortName, "dangerous" ) )
|
|
{
|
|
pFileName = g_pFullFileSystem->FindNext( handle );
|
|
continue;
|
|
}
|
|
|
|
// If we're ignoring autosaves, skip it here
|
|
if ( bIgnoreAutosave )
|
|
{
|
|
if ( !Q_stricmp( save.szType, "#GameUI_Autosave" ) )
|
|
{
|
|
pFileName = g_pFullFileSystem->FindNext( handle );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
saveGames.AddToTail( save );
|
|
}
|
|
|
|
pFileName = g_pFullFileSystem->FindNext( handle );
|
|
}
|
|
|
|
g_pFullFileSystem->FindClose( handle );
|
|
|
|
// Sort the save list
|
|
SortSaveGames( saveGames.Base(), saveGames.Count() );
|
|
|
|
// Now add them in order
|
|
for ( int i = 0; i < saveGames.Count(); i++ )
|
|
{
|
|
CGameSavePanel *savePanel = SETUP_PANEL( new CGameSavePanel( this, &saveGames[i] ) );
|
|
|
|
savePanel->SetVisible( false );
|
|
m_SavePanels.AddToTail( savePanel );
|
|
}
|
|
|
|
// Notify derived classes that save games are done being scanned
|
|
OnDoneScanningSaveGames();
|
|
|
|
// Always start with the first panel (as we're sorted in a specific order)
|
|
SetSelectedSaveIndex( 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the currently selected panel
|
|
//-----------------------------------------------------------------------------
|
|
CGameSavePanel *CSaveGameBrowserDialog::GetActivePanel( void )
|
|
{
|
|
if ( IsValidPanel( m_iSelectedSave ) == false )
|
|
return NULL;
|
|
|
|
return m_SavePanels[ m_iSelectedSave ];
|
|
}
|