source-engine/gameui/BaseSaveGameDialog.cpp

669 lines
18 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "BaseSaveGameDialog.h"
#include "filesystem.h"
#include "savegame_version.h"
#include "vgui_controls/PanelListPanel.h"
#include "vgui_controls/Label.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui_controls/Button.h"
#include "tier1/utlbuffer.h"
#include <stdio.h>
#include <stdlib.h>
#include "filesystem.h"
#include "MouseMessageForwardingPanel.h"
#include "TGAImagePanel.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace vgui;
#define TGA_IMAGE_PANEL_WIDTH 180
#define TGA_IMAGE_PANEL_HEIGHT 100
#define MAX_LISTED_SAVE_GAMES 128
//-----------------------------------------------------------------------------
// Purpose: Describes the layout of a same game pic
//-----------------------------------------------------------------------------
class CSaveGamePanel : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CSaveGamePanel, vgui::EditablePanel );
public:
CSaveGamePanel( PanelListPanel *parent, const char *name, int saveGameListItemID ) : BaseClass( parent, name )
{
m_iSaveGameListItemID = saveGameListItemID;
m_pParent = parent;
m_pSaveGameImage = new CTGAImagePanel( this, "SaveGameImage" );
m_pAutoSaveImage = new ImagePanel( this, "AutoSaveImage" );
m_pSaveGameScreenshotBackground = new ImagePanel( this, "SaveGameScreenshotBackground" );
m_pChapterLabel = new Label( this, "ChapterLabel", "" );
m_pTypeLabel = new Label( this, "TypeLabel", "" );
m_pElapsedTimeLabel = new Label( this, "ElapsedTimeLabel", "" );
m_pFileTimeLabel = new Label( this, "FileTimeLabel", "" );
CMouseMessageForwardingPanel *panel = new CMouseMessageForwardingPanel(this, NULL);
panel->SetZPos(2);
SetSize( 200, 140 );
LoadControlSettings( "resource/SaveGamePanel.res" );
m_FillColor = m_pSaveGameScreenshotBackground->GetFillColor();
}
void SetSaveGameInfo( SaveGameDescription_t &save )
{
// set the bitmap to display
char tga[_MAX_PATH];
Q_strncpy( tga, save.szFileName, sizeof(tga) );
char *ext = strstr( tga, ".sav" );
if ( ext )
{
strcpy( ext, ".tga" );
}
// If a TGA file exists then it is a user created savegame
if ( g_pFullFileSystem->FileExists( tga ) )
{
m_pSaveGameImage->SetTGA( tga );
}
// If there is no TGA then it is either an autosave or the user TGA file has been deleted
else
{
m_pSaveGameImage->SetVisible( false );
m_pAutoSaveImage->SetVisible( true );
m_pAutoSaveImage->SetImage( "resource\\autosave" );
}
// set the title text
m_pChapterLabel->SetText( save.szComment );
// type
SetControlString( "TypeLabel", save.szType );
SetControlString( "ElapsedTimeLabel", save.szElapsedTime );
SetControlString( "FileTimeLabel", save.szFileTime );
}
MESSAGE_FUNC_INT( OnPanelSelected, "PanelSelected", state )
{
if ( state )
{
// set the text color to be orange, and the pic border to be orange
m_pSaveGameScreenshotBackground->SetFillColor( m_SelectedColor );
m_pChapterLabel->SetFgColor( m_SelectedColor );
m_pTypeLabel->SetFgColor( m_SelectedColor );
m_pElapsedTimeLabel->SetFgColor( m_SelectedColor );
m_pFileTimeLabel->SetFgColor( m_SelectedColor );
}
else
{
m_pSaveGameScreenshotBackground->SetFillColor( m_FillColor );
m_pChapterLabel->SetFgColor( m_TextColor );
m_pTypeLabel->SetFgColor( m_TextColor );
m_pElapsedTimeLabel->SetFgColor( m_TextColor );
m_pFileTimeLabel->SetFgColor( m_TextColor );
}
PostMessage( m_pParent->GetVParent(), new KeyValues("PanelSelected") );
}
virtual void OnMousePressed( vgui::MouseCode code )
{
m_pParent->SetSelectedPanel( this );
}
virtual void ApplySchemeSettings( IScheme *pScheme )
{
m_TextColor = pScheme->GetColor( "NewGame.TextColor", Color(255, 255, 255, 255) );
m_SelectedColor = pScheme->GetColor( "NewGame.SelectionColor", Color(255, 255, 255, 255) );
BaseClass::ApplySchemeSettings( pScheme );
}
virtual void OnMouseDoublePressed( vgui::MouseCode code )
{
// call the panel
OnMousePressed( code );
PostMessage( m_pParent->GetParent(), new KeyValues("Command", "command", "loadsave") );
}
int GetSaveGameListItemID()
{
return m_iSaveGameListItemID;
}
private:
vgui::PanelListPanel *m_pParent;
vgui::Label *m_pChapterLabel;
CTGAImagePanel *m_pSaveGameImage;
ImagePanel *m_pAutoSaveImage;
// things to change color when the selection changes
ImagePanel *m_pSaveGameScreenshotBackground;
Label *m_pTypeLabel;
Label *m_pElapsedTimeLabel;
Label *m_pFileTimeLabel;
Color m_TextColor, m_FillColor, m_SelectedColor;
int m_iSaveGameListItemID;
};
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CBaseSaveGameDialog::CBaseSaveGameDialog( vgui::Panel *parent, const char *name ) : BaseClass( parent, name )
{
CreateSavedGamesList();
ScanSavedGames();
m_pLoadButton = new vgui::Button( this, "loadsave", "" );
SetControlEnabled( "loadsave", false );
}
//-----------------------------------------------------------------------------
// Purpose: Creates the load game display list
//-----------------------------------------------------------------------------
void CBaseSaveGameDialog::CreateSavedGamesList()
{
m_pGameList = new vgui::PanelListPanel( this, "listpanel_loadgame" );
m_pGameList->SetFirstColumnWidth( 0 );
}
//-----------------------------------------------------------------------------
// Purpose: returns the save file name of the selected item
//-----------------------------------------------------------------------------
int CBaseSaveGameDialog::GetSelectedItemSaveIndex()
{
CSaveGamePanel *panel = dynamic_cast<CSaveGamePanel *>(m_pGameList->GetSelectedPanel());
if ( panel )
{
// find the panel in the list
for ( int i = 0; i < m_SaveGames.Count(); i++ )
{
if ( i == panel->GetSaveGameListItemID() )
{
return i;
}
}
}
return m_SaveGames.InvalidIndex();
}
//-----------------------------------------------------------------------------
// Purpose: builds save game list from directory
//-----------------------------------------------------------------------------
void CBaseSaveGameDialog::ScanSavedGames()
{
// populate list box with all saved games on record:
char szDirectory[_MAX_PATH];
Q_snprintf( szDirectory, sizeof( szDirectory ), "save/*.sav" );
// clear the current list
m_pGameList->DeleteAllItems();
m_SaveGames.RemoveAll();
// 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];
Q_snprintf(szFileName, sizeof( szFileName ), "save/%s", pFileName);
// 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 ) )
{
m_SaveGames.AddToTail( save );
}
pFileName = g_pFullFileSystem->FindNext( handle );
}
g_pFullFileSystem->FindClose( handle );
// notify derived classes that save games are being scanned (so they can insert their own)
OnScanningSaveGames();
// sort the save list
qsort( m_SaveGames.Base(), m_SaveGames.Count(), sizeof(SaveGameDescription_t), &SaveGameSortFunc );
// add to the list
for ( int saveIndex = 0; saveIndex < m_SaveGames.Count() && saveIndex < MAX_LISTED_SAVE_GAMES; saveIndex++ )
{
// add the item to the panel
AddSaveGameItemToList( saveIndex );
}
// display a message if there are no save games
if ( !m_SaveGames.Count() )
{
vgui::Label *pNoSavesLabel = SETUP_PANEL(new Label(m_pGameList, "NoSavesLabel", "#GameUI_NoSaveGamesToDisplay"));
pNoSavesLabel->SetTextColorState(vgui::Label::CS_DULL);
m_pGameList->AddItem( NULL, pNoSavesLabel );
}
SetControlEnabled( "loadsave", false );
SetControlEnabled( "delete", false );
}
//-----------------------------------------------------------------------------
// Purpose: Adds an item to the list
//-----------------------------------------------------------------------------
void CBaseSaveGameDialog::AddSaveGameItemToList( int saveIndex )
{
// create the new panel and add to the list
CSaveGamePanel *saveGamePanel = new CSaveGamePanel( m_pGameList, "SaveGamePanel", saveIndex );
saveGamePanel->SetSaveGameInfo( m_SaveGames[saveIndex] );
m_pGameList->AddItem( NULL, saveGamePanel );
}
//-----------------------------------------------------------------------------
// Purpose: Parses the save game info out of the .sav file header
//-----------------------------------------------------------------------------
bool CBaseSaveGameDialog::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;
int readok = SaveReadNameAndComment( fh, szMapName, ARRAYSIZE(szMapName), szComment, ARRAYSIZE(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);
// reformat
if ( minutes )
{
Q_snprintf( szElapsedTime, sizeof(szElapsedTime), "%d %s %d seconds", minutes, minutes > 1 ? "minutes" : "minute", seconds );
}
else
{
Q_snprintf( szElapsedTime, sizeof(szElapsedTime), "%d seconds", seconds );
}
// Chop elapsed out of comment.
int n;
n = i - 6;
szComment[n] = '\0';
n--;
// Strip back the spaces at the end.
while ((n >= 1) &&
szComment[n] &&
szComment[n] == ' ')
{
szComment[n--] = '\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;
}
void CBaseSaveGameDialog::OnKeyCodeTyped( vgui::KeyCode code )
{
if ( code == KEY_ESCAPE )
{
OnCommand( "Close" );
return;
}
BaseClass::OnKeyCodeTyped( code );
}
void CBaseSaveGameDialog::OnKeyCodePressed( vgui::KeyCode code )
{
if ( code == KEY_XBUTTON_B )
{
OnCommand( "Close" );
return;
}
else if ( code == KEY_XSTICK1_DOWN ||
code == KEY_XSTICK2_DOWN ||
code == KEY_XBUTTON_DOWN ||
code == KEY_DOWN )
{
if ( m_pGameList->GetItemCount() )
{
Panel *pSelectedPanel = m_pGameList->GetSelectedPanel();
if ( !pSelectedPanel )
{
m_pGameList->SetSelectedPanel( m_pGameList->GetItemPanel( m_pGameList->FirstItem() ) );
m_pGameList->ScrollToItem( m_pGameList->FirstItem() );
return;
}
else
{
int nNextPanelID = m_pGameList->FirstItem();
while ( nNextPanelID != m_pGameList->InvalidItemID() )
{
if ( m_pGameList->GetItemPanel( nNextPanelID ) == pSelectedPanel )
{
nNextPanelID = m_pGameList->NextItem( nNextPanelID );
if ( nNextPanelID != m_pGameList->InvalidItemID() )
{
m_pGameList->SetSelectedPanel( m_pGameList->GetItemPanel( nNextPanelID ) );
m_pGameList->ScrollToItem( nNextPanelID );
return;
}
break;
}
nNextPanelID = m_pGameList->NextItem( nNextPanelID );
}
}
}
}
else if ( code == KEY_XSTICK1_UP ||
code == KEY_XSTICK2_UP ||
code == KEY_XBUTTON_UP ||
code == KEY_UP )
{
if ( m_pGameList->GetItemCount() )
{
Panel *pSelectedPanel = m_pGameList->GetSelectedPanel();
if ( !pSelectedPanel )
{
m_pGameList->SetSelectedPanel( m_pGameList->GetItemPanel( m_pGameList->FirstItem() ) );
m_pGameList->ScrollToItem( m_pGameList->FirstItem() );
return;
}
else
{
int nNextPanelID = m_pGameList->FirstItem();
if ( m_pGameList->GetItemPanel( nNextPanelID ) != pSelectedPanel )
{
while ( nNextPanelID != m_pGameList->InvalidItemID() )
{
int nOldPanelID = nNextPanelID;
nNextPanelID = m_pGameList->NextItem( nNextPanelID );
if ( nNextPanelID != m_pGameList->InvalidItemID() )
{
if ( m_pGameList->GetItemPanel( nNextPanelID ) == pSelectedPanel )
{
m_pGameList->SetSelectedPanel( m_pGameList->GetItemPanel( nOldPanelID ) );
m_pGameList->ScrollToItem( nOldPanelID );
return;
}
}
}
}
}
}
}
else if ( code == KEY_ENTER || code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A )
{
Panel *pSelectedPanel = m_pGameList->GetSelectedPanel();
if ( pSelectedPanel )
{
if ( code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A )
{
ConVarRef var( "joystick" );
if ( var.IsValid() && !var.GetBool() )
{
var.SetValue( true );
}
ConVarRef var2( "hud_fastswitch" );
if ( var2.IsValid() && var2.GetInt() != 2 )
{
var2.SetValue( 2 );
}
}
m_pLoadButton->DoClick();
return;
}
}
BaseClass::OnKeyCodePressed( code );
}
//-----------------------------------------------------------------------------
// Purpose: timestamp sort function for savegames
//-----------------------------------------------------------------------------
int CBaseSaveGameDialog::SaveGameSortFunc( const void *lhs, const void *rhs )
{
const SaveGameDescription_t *s1 = (const SaveGameDescription_t *)lhs;
const SaveGameDescription_t *s2 = (const SaveGameDescription_t *)rhs;
if (s1->iTimestamp < s2->iTimestamp)
return 1;
else if (s1->iTimestamp > s2->iTimestamp)
return -1;
// timestamps are equal, so just sort by filename
return strcmp(s1->szFileName, s2->szFileName);
}
#define MAKEID(d,c,b,a) ( ((int)(a) << 24) | ((int)(b) << 16) | ((int)(c) << 8) | ((int)(d)) )
int SaveReadNameAndComment( FileHandle_t f, OUT_Z_CAP(nameSize) char *name, int nameSize, OUT_Z_CAP(commentSize) char *comment, int commentSize )
{
int i, tag, size, tokenSize, tokenCount;
char *pSaveData, *pFieldName, **pTokenList;
name[0] = '\0';
comment[0] = '\0';
g_pFullFileSystem->Read( &tag, sizeof(int), f );
if ( tag != MAKEID('J','S','A','V') )
{
return 0;
}
g_pFullFileSystem->Read( &tag, sizeof(int), f );
if ( tag != SAVEGAME_VERSION ) // Enforce version for now
{
return 0;
}
g_pFullFileSystem->Read( &size, sizeof(int), f );
g_pFullFileSystem->Read( &tokenCount, sizeof(int), f ); // These two ints are the token list
g_pFullFileSystem->Read( &tokenSize, sizeof(int), f );
size += tokenSize;
// Sanity Check.
if ( tokenCount < 0 || tokenCount > 1024*1024*32 )
{
return 0;
}
if ( tokenSize < 0 || tokenSize > 1024*1024*32 )
{
return 0;
}
pSaveData = (char *)new char[size];
g_pFullFileSystem->Read(pSaveData, size, f);
int nNumberOfFields;
char *pData;
int nFieldSize;
pData = pSaveData;
// Allocate a table for the strings, and parse the table
if ( tokenSize > 0 )
{
pTokenList = new char *[tokenCount];
// Make sure the token strings pointed to by the pToken hashtable.
for( i=0; i<tokenCount; i++ )
{
pTokenList[i] = *pData ? pData : NULL; // Point to each string in the pToken table
while( *pData++ ); // Find next token (after next null)
}
}
else
pTokenList = NULL;
// short, short (size, index of field name)
nFieldSize = *(short *)pData;
pData += sizeof(short);
pFieldName = pTokenList[ *(short *)pData ];
if (stricmp(pFieldName, "GameHeader"))
{
delete[] pSaveData;
return 0;
};
// int (fieldcount)
pData += sizeof(short);
nNumberOfFields = *(int*)pData;
pData += nFieldSize;
// Each field is a short (size), short (index of name), binary string of "size" bytes (data)
for (i = 0; i < nNumberOfFields; i++)
{
// Data order is:
// Size
// szName
// Actual Data
nFieldSize = *(short *)pData;
pData += sizeof(short);
pFieldName = pTokenList[ *(short *)pData ];
pData += sizeof(short);
if (!stricmp(pFieldName, "comment"))
{
int copySize = MAX(commentSize, nFieldSize);
Q_strncpy(comment, pData, copySize);
}
else if (!stricmp(pFieldName, "mapName"))
{
int copySize = MAX(nameSize, nFieldSize);
Q_strncpy(name, pData, copySize);
};
// Move to Start of next field.
pData += nFieldSize;
};
// Delete the string table we allocated
delete[] pTokenList;
delete[] pSaveData;
if (strlen(name) > 0 && strlen(comment) > 0)
return 1;
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: deletes an existing save game
//-----------------------------------------------------------------------------
void CBaseSaveGameDialog::DeleteSaveGame( const char *fileName )
{
if ( !fileName || !fileName[0] )
return;
// delete the save game file
g_pFullFileSystem->RemoveFile( fileName, "MOD" );
// delete the associated tga
char tga[_MAX_PATH];
Q_strncpy( tga, fileName, sizeof(tga) );
char *ext = strstr( tga, ".sav" );
if ( ext )
{
strcpy( ext, ".tga" );
}
g_pFullFileSystem->RemoveFile( tga, "MOD" );
}
//-----------------------------------------------------------------------------
// Purpose: One item has been selected
//-----------------------------------------------------------------------------
void CBaseSaveGameDialog::OnPanelSelected()
{
SetControlEnabled( "loadsave", true );
SetControlEnabled( "delete", true );
}