BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/gameui/BonusMapsDialog.cpp

1007 lines
30 KiB
C++
Raw Normal View History

import hl2_src from full.7z source: magnet:?xt=urn:btih:21DDA6847DDE983F2F8063739249D2D1D09A5DDA
2020-12-25 16:26:23 +01:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "BonusMapsDialog.h"
#include "EngineInterface.h"
#include "vgui/ISystem.h"
#include "vgui/ISurface.h"
#include "vgui/IVGui.h"
#include <vgui/ILocalize.h>
#include "filesystem.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/ComboBox.h"
#include "vgui_controls/PanelListPanel.h"
#include "vgui_controls/QueryBox.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui_controls/BitmapImagePanel.h"
#include "vgui_controls/FileOpenDialog.h"
#include "TGAImagePanel.h"
#include "MouseMessageForwardingPanel.h"
#include "BasePanel.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace vgui;
#define MAX_LISTED_BONUS_MAPS 128
extern const char *COM_GetModDirectory( void );
bool ConstructFullImagePath( const char *pCurrentPath, const char *pchImageName, char *pchImageFileName )
{
char *ext = Q_strstr( pchImageName , ".tga" );
if ( ext )
{
// Use the specified image
if ( pchImageName[ 0 ] != '.' )
Q_snprintf( pchImageFileName, _MAX_PATH, "%s", pchImageName );
else
Q_snprintf( pchImageFileName, _MAX_PATH, "%s/%s", pCurrentPath, pchImageName );
return true;
}
Q_strcpy( pchImageFileName, pchImageName );
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Describes the layout of a same game pic
//-----------------------------------------------------------------------------
class CBonusMapPanel : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CBonusMapPanel, vgui::EditablePanel );
public:
CBonusMapPanel( PanelListPanel *parent, const char *name, int bonusMapListItemID ) : BaseClass( parent, name )
{
m_iBonusMapListItemID = bonusMapListItemID;
m_pParent = parent;
m_pBonusMapTGAImage = new CTGAImagePanel( this, "BonusMapTGAImage" );
m_pBonusMapImage = SETUP_PANEL( new ImagePanel( this, "BonusMapImage" ) );
m_pBonusMapScreenshotBackground = SETUP_PANEL( new ImagePanel( this, "BonusMapScreenshotBackground" ) );
m_pMapNameLabel = new Label( this, "MapNameLabel", "" );
m_pLockIcon = new ImagePanel( this, "LockIcon" );
m_pCompleteIcon = new ImagePanel( this, "CompleteIcon" );
CMouseMessageForwardingPanel *panel = new CMouseMessageForwardingPanel(this, NULL);
panel->SetZPos(2);
SetSize( 200, 140 );
LoadControlSettings( "resource/BonusMapPanel.res" );
m_FillColor = m_pBonusMapScreenshotBackground->GetFillColor();
}
void SetBonusMapInfo( const char *pCurrentPath, BonusMapDescription_t &map )
{
// set the image to display
char szImageFileName[_MAX_PATH];
bool bIsTGA = false;
if ( map.bIsFolder )
{
if ( map.szImageName[ 0 ] == '\0' )
{
// use associate bonus folder icon
Q_snprintf( szImageFileName, sizeof(szImageFileName), "%s/foldericon.tga", map.szFileName );
bIsTGA = true;
// use default folder icon
if( !g_pFullFileSystem->FileExists( szImageFileName, "MOD" ) )
{
V_strcpy_safe( szImageFileName, "bonusmaps/icon_bonus_map_folder" );
bIsTGA = false;
}
}
else
{
// Use the specified image
bIsTGA = ConstructFullImagePath( pCurrentPath, map.szImageName, szImageFileName );
}
}
else
{
if ( map.szImageName[ 0 ] == '\0' )
{
// Didn't specify an image name, so pair it with the name of this file
char szImpliedTgaName[_MAX_PATH];
Q_snprintf( szImpliedTgaName, sizeof( szImpliedTgaName ), "%s.tga", map.szMapFileName );
bIsTGA = ConstructFullImagePath( pCurrentPath, szImpliedTgaName, szImageFileName );
// if it doesn't exist use default bonus map icon
if( !g_pFullFileSystem->FileExists( szImageFileName, "MOD" ) )
{
V_strcpy_safe( szImageFileName, "bonusmaps/icon_bonus_map_default" );
bIsTGA = false;
}
}
else
{
// Use the specified image
bIsTGA = ConstructFullImagePath( pCurrentPath, map.szImageName, szImageFileName );
}
}
if ( bIsTGA )
{
m_pBonusMapTGAImage->SetTGANonMod( szImageFileName );
m_pBonusMapTGAImage->SetSize( 180, 100 );
m_pBonusMapTGAImage->SetVisible( true );
m_pBonusMapImage->SetVisible( false );
}
else
{
m_pBonusMapImage->SetImage( szImageFileName );
m_pBonusMapImage->SetSize( 180, 100 );
m_pBonusMapImage->SetVisible( true );
m_pBonusMapTGAImage->SetVisible( false );
}
m_pLockIcon->SetVisible( map.bLocked );
m_pCompleteIcon->SetVisible( map.bComplete );
// set the title text
m_pMapNameLabel->SetText( map.szMapName );
}
MESSAGE_FUNC_INT( OnPanelSelected, "PanelSelected", state )
{
if ( state )
{
// set the text color to be orange, and the pic border to be orange
m_pBonusMapScreenshotBackground->SetFillColor( m_SelectedColor );
m_pMapNameLabel->SetFgColor( Color( 0, 0, 0, 255 ) );
}
else
{
m_pBonusMapScreenshotBackground->SetFillColor( m_FillColor );
m_pMapNameLabel->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", "loadbonusmap") );
}
int GetBonusMapListItemID()
{
return m_iBonusMapListItemID;
}
private:
vgui::PanelListPanel *m_pParent;
vgui::Label *m_pMapNameLabel;
ImagePanel *m_pBonusMapImage;
CTGAImagePanel *m_pBonusMapTGAImage;
ImagePanel *m_pLockIcon;
ImagePanel *m_pCompleteIcon;
// things to change color when the selection changes
ImagePanel *m_pBonusMapScreenshotBackground;
Color m_TextColor, m_FillColor, m_SelectedColor;
int m_iBonusMapListItemID;
};
CBonusMapsDialog *g_pBonusMapsDialog = NULL;
//-----------------------------------------------------------------------------
// Purpose:Constructor
//-----------------------------------------------------------------------------
CBonusMapsDialog::CBonusMapsDialog(vgui::Panel *parent) : BaseClass(parent, "BonusMapsDialog")
{
g_pBonusMapsDialog = this;
m_hImportBonusMapsDialog = NULL;
BonusMapsDatabase()->RootPath();
CreateBonusMapsList();
BuildMapsList();
new vgui::Button( this, "loadbonusmap", "" );
SetControlEnabled( "loadbonusmap", false );
SetDeleteSelfOnClose(true);
//SetBounds(0, 0, 512, 384);
//SetMinimumSize( 256, 300 );
SetSizeable( false );
SetTitle("#GameUI_BonusMaps", true);
vgui::Button *cancel = new vgui::Button( this, "Cancel", "#GameUI_Cancel" );
cancel->SetCommand( "Close" );
m_pPercentageBarBackground = SETUP_PANEL( new ImagePanel( this, "PercentageBarBackground" ) );
m_pPercentageBar = SETUP_PANEL( new ImagePanel( this, "PercentageBar" ) );
LoadControlSettings("resource/BonusMapsDialog.res");
// Stop blinking the bonus maps menu item
CBasePanel *pBasePanel = BasePanel();
if ( pBasePanel )
pBasePanel->SetMenuItemBlinkingState( "OpenBonusMapsDialog", false );
BonusMapsDatabase()->SetBlink( false );
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CBonusMapsDialog::~CBonusMapsDialog()
{
BonusMapsDatabase()->WriteSaveData(); // Closing this dialog is a good time to save
g_pBonusMapsDialog = NULL;
}
bool CBonusMapsDialog::ImportZippedBonusMaps( const char *pchZippedFileName )
{
// Get the zip file's name with dir info
char *pchShortFileName = Q_strrchr( pchZippedFileName, CORRECT_PATH_SEPARATOR );
if ( !pchShortFileName )
return false;
// It's going to go in the maps folder
char szOutFilename[ 512 ];
Q_snprintf( szOutFilename, sizeof( szOutFilename ), "maps%s", pchShortFileName );
Q_StripExtension( szOutFilename, szOutFilename, sizeof( szOutFilename ) );
// If there's already a folder by the same name we're going to tack a number onto the end
int iOutFilenameLength = Q_strlen( szOutFilename );
int iSameFolderCount = 1;
while ( g_pFullFileSystem->FileExists( szOutFilename, "MOD" ) )
{
++iSameFolderCount;
if ( iSameFolderCount > 99 )
{
return false;
}
szOutFilename[ iOutFilenameLength ] = '\0';
Q_snprintf( szOutFilename, sizeof( szOutFilename ), "%s%02i", szOutFilename, iSameFolderCount );
}
// Pull the files out of the zip
if ( g_pFullFileSystem->UnzipFile( pchZippedFileName, "MOD", szOutFilename ) )
{
// New maps have been imported, so refresh the list
BuildMapsList();
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: builds bonus map list from directory
//-----------------------------------------------------------------------------
void CBonusMapsDialog::BuildMapsList( void )
{
// clear the current list
m_pGameList->DeleteAllItems();
BonusMapsDatabase()->ClearBonusMapsList();
BonusMapsDatabase()->ScanBonusMaps();
// Enable back button if we're in a sub folder
bool bIsRoot = ( Q_strcmp( BonusMapsDatabase()->GetPath(), "." ) == 0 );
SetControlEnabled( "Back", !bIsRoot );
SetControlVisible( "Back", !bIsRoot );
SetControlEnabled( "ImportBonusMaps", bIsRoot );
SetControlVisible( "ImportBonusMaps", bIsRoot );
char szDisplayPath[_MAX_PATH];
Q_snprintf( szDisplayPath, _MAX_PATH, "%s/", BonusMapsDatabase()->GetPath() );
SetControlString( "FileName", szDisplayPath );
SetControlString( "CommentLabel", "" );
int iMapCount = BonusMapsDatabase()->BonusCount();
// add to the list
for ( int iMapIndex = 0; iMapIndex < iMapCount && iMapIndex < MAX_LISTED_BONUS_MAPS; ++iMapIndex )
{
CBonusMapPanel *bonusMapPanel = new CBonusMapPanel( m_pGameList, "BonusMapPanel", iMapIndex );
bonusMapPanel->SetBonusMapInfo( BonusMapsDatabase()->GetPath(), *(BonusMapsDatabase()->GetBonusData( iMapIndex )) );
m_pGameList->AddItem( NULL, bonusMapPanel );
}
// display a message if there are no save games
if ( iMapCount <= 0 )
{
vgui::Label *pNoSavesLabel = SETUP_PANEL(new Label(m_pGameList, "NoBonusMapsLabel", "#GameUI_NoBonusMapsToDisplay"));
pNoSavesLabel->SetTextColorState(vgui::Label::CS_DULL);
m_pGameList->AddItem( NULL, pNoSavesLabel );
m_pGameList->SetNumColumns( 1 );
}
else
{
m_pGameList->SetNumColumns( 3 );
}
RefreshCompletionPercentage();
// Disable load button
SetControlEnabled( "loadbonusmap", false );
// Make challenge selection invisible
m_pChallengeSelection->SetEnabled( false );
m_pChallengeSelection->SetVisible( false );
}
//-----------------------------------------------------------------------------
// Purpose: Creates the load game display list
//-----------------------------------------------------------------------------
void CBonusMapsDialog::CreateBonusMapsList()
{
m_pGameList = new vgui::PanelListPanel( this, "listpanel_bonusmaps" );
m_pGameList->SetFirstColumnWidth( 0 );
new Label( this, "FileName", "./" );
new Label( this, "CommentLabel", "" );
m_pChallengeSelection = new vgui::ComboBox( this, "ChallengeSelection", 0, false );
}
//-----------------------------------------------------------------------------
// Purpose: returns the save file name of the selected item
//-----------------------------------------------------------------------------
int CBonusMapsDialog::GetSelectedItemBonusMapIndex()
{
CBonusMapPanel *panel = dynamic_cast<CBonusMapPanel *>(m_pGameList->GetSelectedPanel());
if ( panel && panel->GetBonusMapListItemID() < BonusMapsDatabase()->BonusCount() )
return panel->GetBonusMapListItemID();
return BonusMapsDatabase()->InvalidIndex();
}
void CBonusMapsDialog::SetSelectedBooleanStatus( const char *pchName, bool bValue )
{
CBonusMapPanel *pSelectedBonusMapPanel = (CBonusMapPanel *)m_pGameList->GetSelectedPanel();
if ( !pSelectedBonusMapPanel )
return;
BonusMapsDatabase()->SetBooleanStatus( pchName, pSelectedBonusMapPanel->GetBonusMapListItemID(), bValue );
// Change the status in the dialog
BonusMapDescription_t *pMap = BonusMapsDatabase()->GetBonusData( pSelectedBonusMapPanel->GetBonusMapListItemID() );
pSelectedBonusMapPanel->SetBonusMapInfo( BonusMapsDatabase()->GetPath(), *pMap );
RefreshCompletionPercentage();
RefreshDialog( pMap );
}
void CBonusMapsDialog::RefreshData( void )
{
for ( int iMap = 0; iMap < m_pGameList->GetItemCount(); ++iMap )
{
CBonusMapPanel *pBonusMapPanel = (CBonusMapPanel *)m_pGameList->GetItemPanel( iMap );
if ( pBonusMapPanel )
pBonusMapPanel->SetBonusMapInfo( BonusMapsDatabase()->GetPath(), *(BonusMapsDatabase()->GetBonusData( pBonusMapPanel->GetBonusMapListItemID() ) ) );
}
CBonusMapPanel *pSelectedBonusMapPanel = (CBonusMapPanel *)m_pGameList->GetSelectedPanel();
if ( !pSelectedBonusMapPanel )
return;
BonusMapDescription_t *pMap = BonusMapsDatabase()->GetBonusData( pSelectedBonusMapPanel->GetBonusMapListItemID() );
RefreshCompletionPercentage();
RefreshDialog( pMap );
}
int CBonusMapsDialog::GetSelectedChallenge( void )
{
if ( !m_pChallengeSelection->IsEnabled() )
return -1;
KeyValues *pUserDataKey = m_pChallengeSelection->GetActiveItemUserData();
return pUserDataKey->GetInt( "challenge" );
}
void CBonusMapsDialog::RefreshDialog( BonusMapDescription_t *pMap )
{
if ( !pMap || pMap->bLocked || ( m_pChallengeSelection->IsEnabled() && GetSelectedChallenge() == -1 ) )
{
// It's locked or no challenge is selected, so disable the load button
SetControlEnabled( "loadbonusmap", false );
}
else
{
// Enable the load button
SetControlEnabled( "loadbonusmap", true );
}
RefreshMedalDisplay( pMap );
if ( pMap )
SetControlString( "CommentLabel", pMap->szComment );
else
SetControlString( "CommentLabel", "" );
}
void CBonusMapsDialog::RefreshMedalDisplay( BonusMapDescription_t *pMap )
{
{
int iFirstChildIndex = FindChildIndexByName( "ChallengeMedalOverview00" );
for ( int iMedal = 0; iMedal < 5; ++iMedal )
{
Panel *pMedalImage = GetChild( iFirstChildIndex + iMedal );
pMedalImage->SetVisible( false );
}
}
if ( !pMap || !pMap->m_pChallenges )
{
SetControlVisible( "ChallengeCommentLabel", false );
SetControlVisible( "ChallengeEarnedMedal", false );
SetControlVisible( "ChallengeBestLabel", false );
SetControlVisible( "ChallengeNextMedal", false );
SetControlVisible( "ChallengeNextLabel", false );
return;
}
char szBuff[ 512 ];
int iChallenge = GetSelectedChallenge();
if ( iChallenge < 0 )
{
SetControlVisible( "ChallengeCommentLabel", false );
SetControlVisible( "ChallengeEarnedMedal", false );
SetControlVisible( "ChallengeBestLabel", false );
SetControlVisible( "ChallengeNextMedal", false );
SetControlVisible( "ChallengeNextLabel", false );
int iFirstChildIndex = FindChildIndexByName( "ChallengeMedalOverview00" );
for ( int iChallengeIndex = 0; iChallengeIndex < m_pChallengeSelection->GetItemCount(); ++iChallengeIndex )
{
KeyValues *pUserDataKey = m_pChallengeSelection->GetItemUserData( iChallengeIndex );
int iChallengeNum = pUserDataKey->GetInt( "challenge" );
if ( iChallengeNum >= 0 )
{
ChallengeDescription_t *pChallengeDescription = NULL;
for ( int i = 0 ; i < pMap->m_pChallenges->Count(); ++i )
{
int iType = ((*pMap->m_pChallenges)[ i ]).iType;
if ( iType == -1 )
{
iType = i;
}
if ( iType == iChallengeNum )
pChallengeDescription = &((*pMap->m_pChallenges)[ i ]);
}
if ( pChallengeDescription )
{
int iBest, iEarnedMedal, iNext, iNextMedal;
GetChallengeMedals( pChallengeDescription, iBest, iEarnedMedal, iNext, iNextMedal );
if ( iChallengeNum < 10 )
Q_snprintf( szBuff, 256, "medals/medal_0%i_%s", iChallengeNum, g_pszMedalNames[ iEarnedMedal ] );
else
Q_snprintf( szBuff, 256, "medals/medal_%i_%s", iChallengeNum, g_pszMedalNames[ iEarnedMedal ] );
}
CBitmapImagePanel *pBitmap = dynamic_cast<CBitmapImagePanel*>( GetChild( iFirstChildIndex + iChallengeNum ) );
pBitmap->SetVisible( true );
pBitmap->setTexture( szBuff );
}
}
return;
}
ChallengeDescription_t *pChallengeDescription = NULL;
for ( int i = 0 ; i < pMap->m_pChallenges->Count(); ++i )
{
int iType = ((*pMap->m_pChallenges)[ i ]).iType;
if ( iType == -1 )
{
iType = i;
}
if ( iType == iChallenge )
pChallengeDescription = &((*pMap->m_pChallenges)[ i ]);
}
if ( !pChallengeDescription )
return;
const char *pchChallengeComment = pChallengeDescription->szComment;
int iBest, iEarnedMedal, iNext, iNextMedal;
GetChallengeMedals( pChallengeDescription, iBest, iEarnedMedal, iNext, iNextMedal );
// Set comment label
SetControlString( "ChallengeCommentLabel", pchChallengeComment );
SetControlVisible( "ChallengeCommentLabel", true );
// Set earned medal
if ( iEarnedMedal > -1 )
{
if ( iChallenge < 10 )
Q_snprintf( szBuff, sizeof( szBuff ), "medals/medal_0%i_%s", iChallenge, g_pszMedalNames[ iEarnedMedal ] );
else
Q_snprintf( szBuff, sizeof( szBuff ), "medals/medal_%i_%s", iChallenge, g_pszMedalNames[ iEarnedMedal ] );
CBitmapImagePanel *pBitmap = dynamic_cast<CBitmapImagePanel*>( FindChildByName( "ChallengeEarnedMedal" ) );
pBitmap->SetVisible( true );
pBitmap->setTexture( szBuff );
}
// Set next medal
if ( iNextMedal > 0 )
{
if ( iChallenge < 10 )
Q_snprintf( szBuff, sizeof( szBuff ), "medals/medal_0%i_%s", iChallenge, g_pszMedalNames[ iNextMedal ] );
else
Q_snprintf( szBuff, sizeof( szBuff ), "medals/medal_%i_%s", iChallenge, g_pszMedalNames[ iNextMedal ] );
CBitmapImagePanel *pBitmap = dynamic_cast<CBitmapImagePanel*>( FindChildByName( "ChallengeNextMedal" ) );
pBitmap->SetVisible( true );
pBitmap->setTexture( szBuff );
}
else
{
SetControlVisible( "ChallengeNextMedal", false );
}
wchar_t szWideBuff[ 64 ];
wchar_t szWideBuff2[ 64 ];
// Best label
if ( iBest != -1 )
{
Q_snprintf( szBuff, sizeof( szBuff ), "%i", iBest );
g_pVGuiLocalize->ConvertANSIToUnicode( szBuff, szWideBuff2, sizeof( szWideBuff2 ) );
g_pVGuiLocalize->ConstructString( szWideBuff, sizeof( szWideBuff ), g_pVGuiLocalize->Find( "#GameUI_BonusMapsBest" ), 1, szWideBuff2 );
g_pVGuiLocalize->ConvertUnicodeToANSI( szWideBuff, szBuff, sizeof( szBuff ) );
SetControlString( "ChallengeBestLabel", szBuff );
SetControlVisible( "ChallengeBestLabel", true );
}
else
SetControlVisible( "ChallengeBestLabel", false );
// Next label
if ( iNext != -1 )
{
Q_snprintf( szBuff, sizeof( szBuff ), "%i", iNext );
g_pVGuiLocalize->ConvertANSIToUnicode( szBuff, szWideBuff2, sizeof( szWideBuff2 ) );
g_pVGuiLocalize->ConstructString( szWideBuff, sizeof( szWideBuff ), g_pVGuiLocalize->Find( "#GameUI_BonusMapsGoal" ), 1, szWideBuff2 );
g_pVGuiLocalize->ConvertUnicodeToANSI( szWideBuff, szBuff, sizeof( szBuff ) );
SetControlString( "ChallengeNextLabel", szBuff );
SetControlVisible( "ChallengeNextLabel", true );
}
else
SetControlVisible( "ChallengeNextLabel", false );
}
void CBonusMapsDialog::RefreshCompletionPercentage( void )
{
float fPercentage = BonusMapsDatabase()->GetCompletionPercentage();
if ( fPercentage > 0.0f )
{
char szBuff[ 256 ];
if ( fPercentage * 100.0f < 1.0f )
Q_snprintf( szBuff, 256, "%.2f%%", fPercentage * 100.0f ); // Show decimal places if less than 1%
else
Q_snprintf( szBuff, 256, "%.0f%%", fPercentage * 100.0f );
SetControlString( "PercentageText", szBuff );
SetControlVisible( "PercentageText", true );
SetControlVisible( "CompletionText", true );
// Blend the color from backround color 0% to selected color 100%
Color cProgressBar = Color( static_cast<float>( m_PercentageBarBackgroundColor.r() ) * ( 1.0f - fPercentage ) + static_cast<float>( m_PercentageBarColor.r() ) * fPercentage,
static_cast<float>( m_PercentageBarBackgroundColor.g() ) * ( 1.0f - fPercentage ) + static_cast<float>( m_PercentageBarColor.g() ) * fPercentage,
static_cast<float>( m_PercentageBarBackgroundColor.b() ) * ( 1.0f - fPercentage ) + static_cast<float>( m_PercentageBarColor.b() ) * fPercentage,
static_cast<float>( m_PercentageBarBackgroundColor.a() ) * ( 1.0f - fPercentage ) + static_cast<float>( m_PercentageBarColor.a() ) * fPercentage );
m_pPercentageBar->SetFillColor( cProgressBar );
m_pPercentageBar->SetWide( m_pPercentageBarBackground->GetWide() * fPercentage );
SetControlVisible( "PercentageBarBackground", true );
SetControlVisible( "PercentageBar", true );
}
else
{
// 0% complete so don't display
SetControlVisible( "PercentageText", false );
SetControlVisible( "CompletionText", false );
SetControlVisible( "PercentageBarBackground", false );
SetControlVisible( "PercentageBar", false );
}
}
void CBonusMapsDialog::ApplySchemeSettings( IScheme *pScheme )
{
m_PercentageBarBackgroundColor = Color( 0, 0, 0, 64 );
m_PercentageBarColor = pScheme->GetColor( "NewGame.SelectionColor", Color(255, 255, 255, 255) );
BaseClass::ApplySchemeSettings( pScheme );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBonusMapsDialog::OnCommand( const char *command )
{
if ( !stricmp( command, "loadbonusmap" ) )
{
int mapIndex = GetSelectedItemBonusMapIndex();
if ( BonusMapsDatabase()->IsValidIndex( mapIndex ) )
{
BonusMapDescription_t *pBonusMap = BonusMapsDatabase()->GetBonusData( mapIndex );
// Don't do anything with locked items
if ( pBonusMap->bLocked || ( m_pChallengeSelection->IsEnabled() && GetSelectedChallenge() == -1 ) )
return;
const char *shortName = pBonusMap->szShortName;
if ( shortName && shortName[ 0 ] )
{
if ( pBonusMap->bIsFolder )
{
BonusMapsDatabase()->AppendPath( shortName );
// repopulate list with current directory
BuildMapsList();
m_pGameList->MoveScrollBarToTop();
}
else
{
// Load the game, return to top and switch to engine
char sz[ 256 ];
// Set the challenge mode if one is selected
int iChallenge = GetSelectedChallenge() + 1;
if ( iChallenge > 0 )
{
Q_snprintf( sz, sizeof( sz ), "sv_bonus_challenge %i\n", iChallenge );
engine->ClientCmd_Unrestricted( sz );
ChallengeDescription_t *pChallengeDescription = &((*pBonusMap->m_pChallenges)[ iChallenge - 1 ]);
// Set up medal goals
BonusMapsDatabase()->SetCurrentChallengeObjectives( pChallengeDescription->iBronze, pChallengeDescription->iSilver, pChallengeDescription->iGold );
BonusMapsDatabase()->SetCurrentChallengeNames( pBonusMap->szFileName, pBonusMap->szMapName, pChallengeDescription->szName );
}
if ( pBonusMap->szMapFileName[ 0 ] != '.' )
{
Q_snprintf( sz, sizeof( sz ), "map %s\n", pBonusMap->szMapFileName );
}
else
{
const char *pchSubDir = Q_strnchr( BonusMapsDatabase()->GetPath(), '/', Q_strlen( BonusMapsDatabase()->GetPath() ) );
if ( pchSubDir )
{
pchSubDir = Q_strnchr( pchSubDir + 1, '/', Q_strlen( pchSubDir ) );
if ( pchSubDir )
{
++pchSubDir;
const char *pchMapFileName = pBonusMap->szMapFileName + 2;
Q_snprintf( sz, sizeof( sz ), "map %s/%s\n", pchSubDir, pchMapFileName );
}
}
}
engine->ClientCmd_Unrestricted( sz );
// Close this dialog
//OnClose();
}
}
}
}
else if ( !stricmp( command, "back" ) )
{
BonusMapsDatabase()->BackPath();
// repopulate list with current directory
BuildMapsList();
m_pChallengeSelection->RemoveAll();
m_pChallengeSelection->AddItem( "<Select A Challenge>", new KeyValues( "ChallengeSelection", "challenge", -1 ) );
RefreshDialog( NULL );
m_pGameList->MoveScrollBarToTop();
}
else if ( !stricmp( command, "ImportBonusMaps" ) )
{
if ( m_hImportBonusMapsDialog == NULL )
{
m_hImportBonusMapsDialog = new FileOpenDialog( NULL, "#GameUI_ImportBonusMaps", true );
m_hImportBonusMapsDialog->AddFilter( "*.bmz", "#GameUI_BMZ_Files", true );
m_hImportBonusMapsDialog->AddActionSignalTarget( this );
}
m_hImportBonusMapsDialog->DoModal(false);
m_hImportBonusMapsDialog->Activate();
}
else
{
BaseClass::OnCommand( command );
}
}
void CBonusMapsDialog::OnKeyCodeTyped( vgui::KeyCode code )
{
if ( code == KEY_ESCAPE )
{
OnCommand( "Close" );
return;
}
BaseClass::OnKeyCodeTyped( code );
}
void CBonusMapsDialog::OnKeyCodePressed( vgui::KeyCode code )
{
if ( code == KEY_XBUTTON_B )
{
OnCommand( "Close" );
return;
}
else if ( code == KEY_XSTICK1_RIGHT ||
code == KEY_XSTICK2_RIGHT ||
code == KEY_XBUTTON_RIGHT ||
code == KEY_RIGHT )
{
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_LEFT ||
code == KEY_XSTICK2_LEFT ||
code == KEY_XBUTTON_LEFT ||
code == KEY_LEFT )
{
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_XSTICK1_DOWN ||
code == KEY_XSTICK2_DOWN ||
code == KEY_XBUTTON_DOWN ||
code == KEY_DOWN )
{
int nOldActiveItem = m_pChallengeSelection->GetActiveItem();
int nActiveItem = min( nOldActiveItem + 1, m_pChallengeSelection->GetItemCount() - 1 );
if ( nOldActiveItem != nActiveItem )
{
m_pChallengeSelection->ActivateItem( nActiveItem );
return;
}
}
else if ( code == KEY_XSTICK1_UP ||
code == KEY_XSTICK2_UP ||
code == KEY_XBUTTON_UP ||
code == KEY_UP )
{
int nOldActiveItem = m_pChallengeSelection->GetActiveItem();
int nActiveItem = max( nOldActiveItem - 1, 0 );
if ( nOldActiveItem != nActiveItem )
{
m_pChallengeSelection->ActivateItem( nActiveItem );
return;
}
}
else if ( code == KEY_ENTER || code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A )
{
Panel *pSelectedPanel = m_pGameList->GetSelectedPanel();
if ( pSelectedPanel )
{
OnCommand( "loadbonusmap" );
return;
}
}
BaseClass::OnKeyCodePressed( code );
}
//-----------------------------------------------------------------------------
// Purpose: One item has been selected
//-----------------------------------------------------------------------------
void CBonusMapsDialog::OnPanelSelected()
{
CBonusMapPanel *pSelectedBonusMapPanel = (CBonusMapPanel *)m_pGameList->GetSelectedPanel();
if ( !pSelectedBonusMapPanel )
return;
BonusMapDescription_t *pMap = BonusMapsDatabase()->GetBonusData( pSelectedBonusMapPanel->GetBonusMapListItemID() );
if ( !pMap )
return;
SetControlString( "CommentLabel", pMap->szComment );
// Handle challenge selection box
int iNumChallenges = 0;
if ( pMap->m_pChallenges )
{
// Get the name of the previously selected challenge so that we can select a matching challenge (if one exists)
int iSelectedChallenge = GetSelectedChallenge();
m_pChallengeSelection->RemoveAll();
m_pChallengeSelection->AddItem( "<Select A Challenge>", new KeyValues( "ChallengeSelection", "challenge", -1 ) );
int iFoundSimilar = 0;
for ( iNumChallenges; iNumChallenges < pMap->m_pChallenges->Count(); ++iNumChallenges )
{
ChallengeDescription_t *pChallenge = &(*pMap->m_pChallenges)[ iNumChallenges ];
int iType = iNumChallenges;
// If the challenge type was specified then use that instead of (legacy) the order the challenges were listed
if ( pChallenge->iType != -1 )
iType = pChallenge->iType;
m_pChallengeSelection->AddItem( pChallenge->szName, new KeyValues( "ChallengeSelection", "challenge", iType ) );
if ( iSelectedChallenge == iNumChallenges )
iFoundSimilar = iNumChallenges + 1;
}
m_pChallengeSelection->ActivateItemByRow( iFoundSimilar );
}
if ( iNumChallenges > 0 )
{
m_pChallengeSelection->SetEnabled( true );
m_pChallengeSelection->SetVisible( true );
m_pChallengeSelection->SetNumberOfEditLines( iNumChallenges + 1 );
}
else
{
m_pChallengeSelection->SetEnabled( false );
m_pChallengeSelection->SetVisible( false );
}
RefreshDialog( pMap );
}
void CBonusMapsDialog::OnControlModified()
{
CBonusMapPanel *pSelectedBonusMapPanel = (CBonusMapPanel *)m_pGameList->GetSelectedPanel();
if ( !pSelectedBonusMapPanel )
return;
BonusMapDescription_t *pMap = BonusMapsDatabase()->GetBonusData( pSelectedBonusMapPanel->GetBonusMapListItemID() );
if ( !pMap )
return;
RefreshDialog( pMap );
}
// file selected. This can only happen when someone selects an image to be imported as a spray logo.
void CBonusMapsDialog::OnFileSelected( const char *fullpath )
{
if ( fullpath == NULL || fullpath[ 0 ] == '\0' )
return;
// this can take a while, put up a waiting cursor
surface()->SetCursor(dc_hourglass);
ImportZippedBonusMaps( fullpath );
// change the cursor back to normal
surface()->SetCursor(dc_user);
}