d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
84 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 977bac3205
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '977bac3205'
${ noResults }
source-engine/game/client/cstrike/VGUI/career_box.cpp

1296 lines
37 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
#include "cbase.h"
#include <vgui/KeyCode.h>
#include "career_box.h"
#include "career_button.h"
#include "buypreset_listbox.h"
#include <vgui_controls/TextImage.h>
#include <vgui_controls/CheckButton.h>
#include <vgui_controls/ComboBox.h>
#include "cs_ammodef.h"
#include "weapon_csbase.h"
#include "backgroundpanel.h"
#include "cs_gamerules.h"
#include <vgui/IInput.h>
#include "bot/shared_util.h"
#include <vgui_controls/BitmapImagePanel.h>
#include <vgui/ISurface.h>
#include <vgui/ILocalize.h>
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
using namespace vgui;
//--------------------------------------------------------------------------------------------------------------
class ConVarToggleCheckButton : public vgui::CheckButton
{
DECLARE_CLASS_SIMPLE( ConVarToggleCheckButton, vgui::CheckButton );
public:
ConVarToggleCheckButton( vgui::Panel *parent, const char *panelName, const char *text );
~ConVarToggleCheckButton();
virtual void SetSelected( bool state );
virtual void Paint();
void Reset();
void ApplyChanges();
bool HasBeenModified();
void SetConVar( const char *name );
virtual void ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
const char *name = inResourceData->GetString( "convar", NULL );
if ( name )
{
SetConVar( name );
}
}
private:
MESSAGE_FUNC( OnButtonChecked, "CheckButtonChecked" );
char *m_pszCvarName;
bool m_bStartValue;
};
//--------------------------------------------------------------------------------------------------------------
ConVarToggleCheckButton::ConVarToggleCheckButton( Panel *parent, const char *panelName, const char *text )
: CheckButton( parent, panelName, text )
{
m_pszCvarName = NULL;
AddActionSignalTarget( this );
}
//--------------------------------------------------------------------------------------------------------------
ConVarToggleCheckButton::~ConVarToggleCheckButton()
{
if ( m_pszCvarName )
delete[] m_pszCvarName;
}
//--------------------------------------------------------------------------------------------------------------
void ConVarToggleCheckButton::SetConVar( const char *name )
{
if ( m_pszCvarName )
delete[] m_pszCvarName;
m_pszCvarName = CloneString( name );
if (m_pszCvarName && *m_pszCvarName)
{
Reset();
}
}
//--------------------------------------------------------------------------------------------------------------
void ConVarToggleCheckButton::Paint()
{
if ( !m_pszCvarName || !m_pszCvarName[ 0 ] )
{
BaseClass::Paint();
return;
}
// Look up current value
ConVar const *var = cvar->FindVar( m_pszCvarName );
if ( !var )
return;
bool value = var->GetBool();
if (value != m_bStartValue)
{
SetSelected( value );
m_bStartValue = value;
}
BaseClass::Paint();
}
//--------------------------------------------------------------------------------------------------------------
void ConVarToggleCheckButton::ApplyChanges()
{
m_bStartValue = IsSelected();
ConVar *var = (ConVar *)cvar->FindVar( m_pszCvarName );
if ( !var )
return;
var->SetValue(m_bStartValue);
}
//--------------------------------------------------------------------------------------------------------------
void ConVarToggleCheckButton::Reset()
{
ConVar const *var = cvar->FindVar( m_pszCvarName );
if ( !var )
return;
m_bStartValue = var->GetBool();
SetSelected(m_bStartValue);
}
//--------------------------------------------------------------------------------------------------------------
bool ConVarToggleCheckButton::HasBeenModified()
{
return IsSelected() != m_bStartValue;
}
//--------------------------------------------------------------------------------------------------------------
void ConVarToggleCheckButton::SetSelected( bool state )
{
BaseClass::SetSelected( state );
if ( !m_pszCvarName || !m_pszCvarName[ 0 ] )
return;
}
//--------------------------------------------------------------------------------------------------------------
void ConVarToggleCheckButton::OnButtonChecked()
{
if (HasBeenModified())
{
PostActionSignal(new KeyValues("ControlModified"));
}
}
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
CCareerBaseBox::CCareerBaseBox(Panel *parent, const char *panelName, bool loadResources, bool useCareerButtons) : Frame(parent, panelName, false)
{
// @TODO: SetScheme("CareerBoxScheme");
SetScheme("ClientScheme");
SetProportional( true );
SetMoveable(false);
SetSizeable(false);
m_bgColor = Color( 0, 0, 0, 0 );
m_borderColor = Color( 0, 0, 0, 0 );
m_pTextLabel = new Label( this, "TextLabel", "" );
if ( useCareerButtons )
{
m_pOkButton = new CCareerButton( this, "OkButton", "", "", false );
m_pCancelButton = new CCareerButton( this, "CancelButton", "", "", false );
}
else
{
m_pOkButton = new Button( this, "OkButton", "" );
m_pCancelButton = new Button( this, "CancelButton", "" );
}
m_pOkButton->SetVisible(false);
if ( useCareerButtons )
{
m_buttons.PutElement( m_pOkButton );
m_buttons.PutElement( m_pCancelButton );
}
m_cancelFocus = false;
if (loadResources)
{
const int BufLen = strlen(panelName) + 32;
char *buf = new char[BufLen];
Q_snprintf( buf, BufLen, "Resource/Career/%s.res", panelName );
LoadControlSettings( buf );
delete[] buf;
}
}
//--------------------------------------------------------------------------------------------------------------
vgui::Panel * CCareerBaseBox::CreateControlByName(const char *controlName)
{
if ( Q_stricmp( controlName, "ConVarCheckButton" ) == 0 )
{
ConVarToggleCheckButton *button = new ConVarToggleCheckButton( NULL, controlName, "" );
m_conVarCheckButtons.PutElement( button );
return button;
}
return BaseClass::CreateControlByName( controlName );
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::SetCancelButtonAsDefault()
{
m_cancelFocus = true;
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::SetLabelText( const wchar_t *text )
{
m_pTextLabel->SetText(text);
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::SetLabelText( const char *text )
{
m_pTextLabel->SetText(text);
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
for (int i=0; i<m_buttons.GetCount(); ++i)
{
m_buttons[i]->SetArmedSound("UI/buttonrollover.wav");
m_buttons[i]->SetDepressedSound("UI/buttonclick.wav");
m_buttons[i]->SetReleasedSound("UI/buttonclickrelease.wav");
}
m_bgColor = GetSchemeColor("Popup.BgColor", Color( 64, 64, 64, 255 ), pScheme);
m_borderColor = GetSchemeColor("FgColor", Color( 64, 64, 64, 255 ), pScheme);
SetBorder( pScheme->GetBorder( "BaseBorder" ) );
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::PerformLayout( )
{
BaseClass::PerformLayout();
int x, y, w, h;
GetBounds(x, y, w, h);
int screenWide, screenTall;
GetHudSize( screenWide, screenTall );
if ( x + w/2 != screenWide/2 )
{
SetPos( screenWide/2 - w/2, screenTall/2 - h/2 );
GetBounds(x, y, w, h);
}
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::PaintBackground( )
{
int wide, tall;
GetSize( wide, tall );
DrawRoundedBackground( m_bgColor, wide, tall );
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::PaintBorder( )
{
int wide, tall;
GetSize( wide, tall );
DrawRoundedBorder( m_borderColor, wide, tall );
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::ShowWindow()
{
SetVisible( true );
SetEnabled( true );
MoveToFront();
if ( m_pCancelButton->IsVisible() && m_cancelFocus )
{
m_pCancelButton->RequestFocus();
}
else if ( m_pOkButton->IsVisible() )
{
m_pOkButton->RequestFocus();
}
else // handle message boxes with no button
{
RequestFocus();
}
InvalidateLayout();
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::DoModal()
{
ShowWindow();
input()->SetAppModalSurface(GetVPanel());
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::OnKeyCodeTyped(KeyCode code)
{
if (code == KEY_ESCAPE)
{
OnCommand("Cancel");
}
else if (code == KEY_ENTER)
{
BaseClass::OnKeyCodeTyped( KEY_SPACE );
}
else
{
BaseClass::OnKeyCodeTyped(code);
}
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::OnCommand(const char *command)
{
KeyValues *okSettings = new KeyValues( "GetCommand" );
if ( m_pOkButton->RequestInfo( okSettings ) )
{
const char *okCommand = okSettings->GetString( "command", "Ok" );
if ( stricmp(command, okCommand) == 0 )
{
for (int i=0; i<m_conVarCheckButtons.GetCount(); ++i)
{
m_conVarCheckButtons[i]->ApplyChanges();
}
}
}
if (stricmp(command, "close"))
{
PostActionSignal( new KeyValues("Command", "command", command) );
}
BaseClass::OnCommand(command);
Close();
}
//--------------------------------------------------------------------------------------------------------------
void CCareerBaseBox::AddButton( vgui::Button *pButton )
{
m_buttons.PutElement( pButton );
}
//--------------------------------------------------------------------------------------------------------------
CCareerQueryBox::CCareerQueryBox(vgui::Panel *parent, const char *panelName, const char *resourceName) : CCareerBaseBox(parent, panelName, (resourceName == NULL))
{
if ( resourceName )
{
LoadControlSettings( resourceName );
}
}
//--------------------------------------------------------------------------------------------------------------
CCareerQueryBox::CCareerQueryBox(const char *title, const char *labelText, const char *panelName, vgui::Panel *parent) : CCareerBaseBox(parent, panelName)
{
}
//--------------------------------------------------------------------------------------------------------------
CCareerQueryBox::CCareerQueryBox(const wchar_t *title, const wchar_t *labelText, const char *panelName, vgui::Panel *parent) : CCareerBaseBox(parent, panelName)
{
}
//--------------------------------------------------------------------------------------------------------------
CCareerQueryBox::~CCareerQueryBox()
{
}
// sorted order weapon list -----------------------------------------------------------------------
const int NUM_SECONDARY_WEAPONS = 7;
static CSWeaponID s_secondaryWeapons[NUM_SECONDARY_WEAPONS] =
{
WEAPON_NONE,
WEAPON_USP,
WEAPON_GLOCK,
WEAPON_DEAGLE,
WEAPON_ELITE,
WEAPON_P228,
WEAPON_FIVESEVEN,
};
const int NUM_PRIMARY_WEAPONS = 23;
static CSWeaponID s_primaryWeapons[NUM_PRIMARY_WEAPONS] =
{
WEAPON_NONE,
// Assault Rifles
CSWeaponID(-WEAPONTYPE_RIFLE),
WEAPON_SG552,
WEAPON_AUG,
WEAPON_AK47,
WEAPON_M4A1,
WEAPON_GALIL,
WEAPON_FAMAS,
// Snipers
CSWeaponID(-WEAPONTYPE_SNIPER_RIFLE),
WEAPON_AWP,
WEAPON_SG550,
WEAPON_G3SG1,
WEAPON_SCOUT,
// SMG
CSWeaponID(-WEAPONTYPE_SUBMACHINEGUN),
WEAPON_P90,
WEAPON_UMP45,
WEAPON_MP5NAVY,
WEAPON_MAC10,
WEAPON_TMP,
// Heavy
CSWeaponID(-WEAPONTYPE_SHOTGUN),
WEAPON_M249,
WEAPON_XM1014,
WEAPON_M3,
// WEAPON_SHIELDGUN,
};
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
class CWeaponButton : public vgui::Button
{
typedef vgui::Button BaseClass;
public:
CWeaponButton( BuyPresetListBox *pParent, CSWeaponID weaponID, bool isPrimary ) : BaseClass( pParent->GetParent(), SharedVarArgs( "WeaponButton%d", weaponID ), "" )
{
m_isPrimary = isPrimary;
m_pImage = NULL;
m_pTitleImage = new TextImage( WeaponIDToDisplayName( weaponID ) );
m_pCostImage = new TextImage( L"" );
m_pListBox = pParent;
BuyPresetWeapon weapon( weaponID );
SetWeapon( weapon );
}
virtual ~CWeaponButton() { delete m_pTitleImage; delete m_pCostImage; }
virtual void ApplySchemeSettings( IScheme *pScheme );
virtual Color GetBgColor() { return (IsCurrent()) ? m_selectedBgColor : Button::GetBgColor(); }
virtual Color GetFgColor() { return (IsCurrent()) ? m_selectedFgColor : Button::GetFgColor(); }
void SetCurrent() { s_current = this; }
bool IsCurrent() const { return s_current == this; }
void SetWeapon( const BuyPresetWeapon& weapon );
const BuyPresetWeapon& GetWeapon() { return m_weapon; }
virtual void Paint();
virtual void PerformLayout();
virtual void PaintBorder() {}
virtual void OnMousePressed( MouseCode code )
{
if ( code == MOUSE_LEFT )
{
SetCurrent();
m_pListBox->GetParent()->OnCommand( "select_weapon" );
}
Button::OnMousePressed( code );
}
virtual void OnMouseDoublePressed( MouseCode code )
{
if ( code == MOUSE_LEFT )
{
SetCurrent();
m_pListBox->GetParent()->OnCommand( "select_weapon" );
m_pListBox->GetParent()->OnCommand( "popup_ok" );
}
Button::OnMouseDoublePressed( code );
}
protected:
static CWeaponButton * s_current;
BuyPresetListBox * m_pListBox;
BuyPresetWeapon m_weapon;
IImage *m_pImage;
TextImage *m_pTitleImage;
TextImage *m_pCostImage;
int m_imageWide;
int m_imageTall;
int m_imageX;
int m_imageY;
Color m_selectedBgColor;
Color m_selectedFgColor;
bool m_isPrimary;
};
//--------------------------------------------------------------------------------------------------------------
CWeaponButton * CWeaponButton::s_current = NULL;
//--------------------------------------------------------------------------------------------------------------
void CWeaponButton::ApplySchemeSettings( IScheme *pScheme )
{
CWeaponButton * current = s_current; // save off current so Button::ApplySchemeSettings() can get the right colors
s_current = NULL;
Button::ApplySchemeSettings( pScheme );
m_selectedBgColor = GetSchemeColor( "Button.ArmedBgColor", Button::GetBgColor(), pScheme );
m_selectedFgColor = GetSchemeColor( "Button.ArmedTextColor", Button::GetFgColor(), pScheme );
s_current = current;
m_pTitleImage->SetColor( pScheme->GetColor( "Button.TextColor", Color() ) );
m_pTitleImage->SetFont( pScheme->GetFont( "Default", IsProportional() ) );
m_pTitleImage->SetWrap( true );
m_pCostImage->SetColor( pScheme->GetColor( "Button.TextColor", Color() ) );
m_pCostImage->SetFont( pScheme->GetFont( "Default", IsProportional() ) );
m_pCostImage->SetWrap( true );
SetWeapon( m_weapon );
SetBorder( NULL );
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponButton::SetWeapon( const BuyPresetWeapon& weapon )
{
m_weapon = weapon;
if ( m_weapon.GetName() )
{
// weapon string
const wchar_t * name = m_weapon.GetName();
m_pTitleImage->SetText( name );
// cost string
CCSWeaponInfo *info = GetWeaponInfo( m_weapon.GetWeaponID() );
if ( info )
{
const int BufLen = 256;
wchar_t wbuf[BufLen];
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( info->GetWeaponPrice() ) );
m_pCostImage->SetText( wbuf );
}
else
{
m_pCostImage->SetText( L"" );
}
}
else
{
m_pTitleImage->SetText( L"" );
m_pCostImage->SetText( L"" );
}
m_pTitleImage->ResizeImageToContent();
m_pCostImage->ResizeImageToContent();
InvalidateLayout( true, false );
m_pImage = scheme()->GetImage( ImageFnameFromWeaponID( m_weapon.GetWeaponID(), m_isPrimary ), true );
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponButton::PerformLayout()
{
BaseClass::PerformLayout();
// Calculate some sizes
int oldWide, oldTall;
GetSize( oldWide, oldTall );
const float IMAGE_PERCENT = 0.42f;
const float TITLE_PERCENT = 0.45f;
const float COST_PERCENT = 1.0f - TITLE_PERCENT - IMAGE_PERCENT;
int maxTitleWide = (int) oldWide * TITLE_PERCENT;
int maxImageWide = (int) oldWide * IMAGE_PERCENT;
int maxCostWide = (int) oldWide * COST_PERCENT;
int textTall = surface()->GetFontTall( m_pTitleImage->GetFont() ) * 2;
if ( oldTall != textTall )
{
oldTall = textTall;
SetSize( oldWide, oldTall );
m_pListBox->InvalidateLayout();
}
// Position the weapon name
{
m_pTitleImage->SetSize( maxTitleWide, oldTall );
m_pTitleImage->RecalculateNewLinePositions();
m_pTitleImage->ResizeImageToContent();
int textContentWide, textContentTall;
m_pTitleImage->GetSize( textContentWide, textContentTall );
if ( textContentTall < textTall )
{
m_pTitleImage->SetSize( maxTitleWide, textContentTall );
m_pTitleImage->SetPos( maxImageWide, (textTall - textContentTall) / 2 );
}
else
{
m_pTitleImage->SetPos( maxImageWide, 0 );
}
}
// Position the weapon cost
{
m_pCostImage->SetSize( maxCostWide, oldTall );
m_pCostImage->RecalculateNewLinePositions();
m_pCostImage->ResizeImageToContent();
int textContentWide, textContentTall;
m_pCostImage->GetSize( textContentWide, textContentTall );
if ( textContentTall < textTall )
{
m_pCostImage->SetSize( maxCostWide, textContentTall );
m_pCostImage->SetPos( oldWide - maxCostWide, (textTall - textContentTall) / 2 );
}
else
{
m_pCostImage->SetPos( oldWide - maxCostWide, 0 );
}
}
// Position the weapon image
m_pImage = scheme()->GetImage( ImageFnameFromWeaponID( m_weapon.GetWeaponID(), m_isPrimary ), true );
int maxImageTall = textTall;
m_pImage->GetContentSize( m_imageWide, m_imageTall );
if ( m_imageTall > maxImageTall )
{
m_imageWide = (int) m_imageWide * 1.0f * maxImageTall / m_imageTall;
m_imageTall = maxImageTall;
}
if ( m_imageWide > maxImageWide )
{
m_imageTall = (int) m_imageTall * 1.0f * maxImageWide / m_imageWide;
m_imageWide = maxImageWide;
}
m_imageY = (textTall - m_imageTall) / 2;
m_imageX = (((int) oldWide * IMAGE_PERCENT) - m_imageWide) / 2;
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponButton::Paint()
{
if ( m_pImage )
{
m_pImage->SetSize( m_imageWide, m_imageTall );
m_pImage->SetPos( m_imageX, m_imageY );
m_pImage->Paint();
m_pImage->SetSize( 0, 0 );
}
m_pTitleImage->Paint();
m_pCostImage->Paint();
BaseClass::Paint();
}
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
class WeaponComboBox : public vgui::ComboBox
{
public:
WeaponComboBox( CWeaponSelectBox *parent, const char *name, int numEntries, bool editable )
: ComboBox( parent, name, numEntries, editable )
{
m_pBox = parent;
}
virtual void OnSetText( const wchar_t *newText )
{
ComboBox::OnSetText( newText );
if ( m_pBox )
m_pBox->UpdateClips();
}
private:
CWeaponSelectBox *m_pBox;
};
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
CWeaponSelectBox::CWeaponSelectBox(vgui::Panel *parent, WeaponSet *pWeaponSet, bool isSecondary ) : CCareerBaseBox(parent, "BuyBoxSelectWeapon", false)
{
m_pWeaponSet = pWeaponSet;
m_isSecondary = isSecondary;
m_numWeapons = NUM_PRIMARY_WEAPONS;
m_weaponIDs = s_primaryWeapons;
BuyPresetWeapon *weapon;
if ( !m_isSecondary )
{
weapon = &m_pWeaponSet->m_primaryWeapon;
if ( !IsPrimaryWeapon( weapon->GetWeaponID() ) && weapon->GetWeaponID() != WEAPON_NONE )
{
BuyPresetWeapon tmp( WEAPON_NONE );
m_pWeaponSet->m_primaryWeapon = tmp;
}
}
else
{
m_numWeapons = NUM_SECONDARY_WEAPONS;
m_weaponIDs = s_secondaryWeapons;
weapon = &m_pWeaponSet->m_secondaryWeapon;
if ( !IsSecondaryWeapon( weapon->GetWeaponID() ) && weapon->GetWeaponID() != WEAPON_NONE )
{
BuyPresetWeapon tmp( WEAPON_NONE );
*weapon = tmp;
}
}
int maxClips = 0;
const CCSWeaponInfo *info = GetWeaponInfo( weapon->GetWeaponID() );
if ( info )
{
int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
maxClips = (buyClipSize > 0) ? ceil(maxRounds/(float)buyClipSize) : 0;
}
else
{
maxClips = NUM_CLIPS_FOR_CURRENT; // so we can buy ammo for our current gun
}
m_pClips = new WeaponComboBox( this, "Clips", 2*maxClips+1, false );
m_pClips->SetOpenDirection( Menu::UP );
m_pListBox = new BuyPresetListBox( this, "WeaponListBox" );
m_pBullets = new Label( this, "bullets", "" );
int selectedWeaponIndex = -1;
int i;
for ( i=0; i<m_numWeapons; ++i )
{
if ( m_weaponIDs[i] < 0 )
{
const char *text = "";
switch ( (int)m_weaponIDs[i] )
{
case -WEAPONTYPE_RIFLE:
text = "#Cstrike_BuyPresetCategoryRifle";
break;
case -WEAPONTYPE_SNIPER_RIFLE:
text = "#Cstrike_BuyPresetCategorySniper";
break;
case -WEAPONTYPE_SUBMACHINEGUN:
text = "#Cstrike_BuyPresetCategorySMG";
break;
case -WEAPONTYPE_SHOTGUN:
text = "#Cstrike_BuyPresetCategoryHeavy";
break;
}
Label *pLabel = new Label( m_pListBox, SharedVarArgs("weaponlabel%d", i), text );
m_pListBox->AddItem( pLabel, NULL );
}
else
{
CWeaponButton *pWeaponButton = new CWeaponButton( m_pListBox, m_weaponIDs[i], !m_isSecondary );
m_pListBox->AddItem( pWeaponButton, NULL );
if ( m_weaponIDs[i] == weapon->GetWeaponID() )
{
pWeaponButton->SetCurrent();
selectedWeaponIndex = i;
}
}
}
m_pListBox->MakeItemVisible( selectedWeaponIndex );
LoadControlSettings( "resource/UI/BuyPreset/BoxSelectWeapon.res" );
PopulateControls();
}
//--------------------------------------------------------------------------------------------------------------
CWeaponSelectBox::~CWeaponSelectBox()
{
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponSelectBox::ActivateBuildMode()
{
SetClipsVisible( true );
m_pListBox->DeleteAllItems();
BaseClass::ActivateBuildMode();
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponSelectBox::SetClipsVisible( bool visible )
{
SetLabelVisible( visible );
m_pClips->SetVisible( visible );
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponSelectBox::PopulateControls()
{
BuyPresetWeapon *weapon;
if (!m_isSecondary)
{
weapon = &m_pWeaponSet->m_primaryWeapon;
}
else
{
weapon = &m_pWeaponSet->m_secondaryWeapon;
}
int i;
int maxClips = 0;
const CCSWeaponInfo *info = GetWeaponInfo( weapon->GetWeaponID() );
if ( info )
{
int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
maxClips = (buyClipSize > 0) ? ceil(maxRounds/(float)buyClipSize) : 0;
}
else
{
maxClips = NUM_CLIPS_FOR_CURRENT;
}
m_pClips->SetNumberOfEditLines( 2*maxClips+1 );
SetClipsVisible( maxClips != 0 );
m_pClips->DeleteAllItems();
// populate clips combo box
m_pClips->AddItem( "#Cstrike_BuyPresetEditWeaponFullClips", NULL );
const int BufLen = 64;
wchar_t buf[BufLen];
for ( i=maxClips-1; i>=0; --i )
{
const char* clipsOrMore = "#Cstrike_BuyPresetEditClipsOrMore";
const char* clips = "#Cstrike_BuyPresetEditClips";
if ( i == 1 )
{
clipsOrMore = "#Cstrike_BuyPresetEditClipOrMore";
clips = "#Cstrike_BuyPresetEditClip";
}
g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
g_pVGuiLocalize->Find( clipsOrMore ),
1, NumAsWString( i ));
m_pClips->AddItem( buf, NULL );
g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
g_pVGuiLocalize->Find( clips ),
1, NumAsWString( i ));
m_pClips->AddItem( buf, NULL );
}
// now select the proper entry
int clipIndexToSelect = weapon->GetFillAmmo();
clipIndexToSelect += 2 * weapon->GetAmmoAmount();
clipIndexToSelect = maxClips*2 - clipIndexToSelect;
m_pClips->ActivateItemByRow( clipIndexToSelect );
if ( m_isSecondary )
{
Panel *pPanel = FindChildByName( "TitleLabel" );
if ( pPanel )
{
const wchar_t *title = g_pVGuiLocalize->Find( "#Cstrike_BuyPresetWizardSecondary" );
if ( title )
PostMessage(pPanel, new KeyValues("SetText", "text", title));
}
}
UpdateClips();
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponSelectBox::UpdateClips()
{
if ( !m_pClips )
return;
int numEntries = m_pClips->GetItemCount();
int activeID = m_pClips->GetActiveItem();
int combined = numEntries - activeID + 1;
int numClips = combined/2 - 1;
//bool isFill = (combined%2) != 0;
BuyPresetWeapon *weapon;
if (!m_isSecondary)
{
weapon = &m_pWeaponSet->m_primaryWeapon;
}
else
{
weapon = &m_pWeaponSet->m_secondaryWeapon;
}
const CCSWeaponInfo *info = GetWeaponInfo( weapon->GetWeaponID() );
if ( info )
{
int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
m_pBullets->SetVisible( true );
const int BufLen = 64;
wchar_t buf[BufLen];
g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetsBullets" ),
2, NumAsWString( MIN( maxRounds, numClips * buyClipSize ) ), NumAsWString( maxRounds ) );
m_pBullets->SetText( buf );
}
else
{
m_pBullets->SetVisible( false );
}
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponSelectBox::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings(pScheme);
HFont font = pScheme->GetFont("Default", IsProportional());
int tall = surface()->GetFontTall(font) + 2;
if ( font != INVALID_FONT )
{
Menu *pMenu = m_pClips->GetMenu();
pMenu->SetMenuItemHeight( tall );
}
for ( int i=0; i<m_pListBox->GetItemCount(); ++i )
{
if ( m_weaponIDs[i] >= 0 )
{
CWeaponButton *pButton = static_cast< CWeaponButton * >(m_pListBox->GetItemPanel(i));
if ( pButton && pButton->IsCurrent() )
{
m_pListBox->MakeItemVisible( i );
}
}
else
{
// it's a caption label
Label *pLabel = static_cast< Label * >(m_pListBox->GetItemPanel(i));
if ( pLabel )
{
pLabel->SetContentAlignment( Label::a_center );
pLabel->SetBorder( pScheme->GetBorder( "ButtonBorder" ) );
pLabel->SetBgColor( pScheme->GetColor( "Frame.BgColor", Color( 0, 0, 0, 255 ) ) );
}
}
}
}
//--------------------------------------------------------------------------------------------------------------
CSWeaponID CWeaponSelectBox::GetSelectedWeaponID()
{
int selectedIndex = -1;
for ( int i=0; i<m_pListBox->GetItemCount(); ++i )
{
if ( m_weaponIDs[selectedIndex] >= 0 )
{
CWeaponButton *pButton = static_cast< CWeaponButton * >(m_pListBox->GetItemPanel(i));
if ( pButton && pButton->IsCurrent() )
{
selectedIndex = i;
}
}
}
if ( selectedIndex >= 0 )
{
return m_weaponIDs[selectedIndex];
}
return WEAPON_NONE;
}
//--------------------------------------------------------------------------------------------------------------
void CWeaponSelectBox::OnCommand(const char *command)
{
if (!stricmp(command, "select_weapon"))
{
CSWeaponID weaponID = GetSelectedWeaponID();
BuyPresetWeapon weapon( weaponID );
if ( m_isSecondary )
{
m_pWeaponSet->m_secondaryWeapon = weapon;
}
else
{
m_pWeaponSet->m_primaryWeapon = weapon;
}
PopulateControls();
return;
}
if (!stricmp(command, "popup_ok"))
{
if ( !m_pClips )
return;
int numEntries = m_pClips->GetItemCount();
int activeID = m_pClips->GetActiveItem();
int combined = numEntries - activeID + 1;
int numClips = combined/2 - 1;
bool isFill = (combined%2) != 0;
BuyPresetWeapon weapon( GetSelectedWeaponID() );
weapon.SetAmmoType( AMMO_CLIPS );
weapon.SetAmmoAmount( numClips );
weapon.SetFillAmmo( isFill );
if ( m_isSecondary )
{
m_pWeaponSet->m_secondaryWeapon = weapon;
}
else
{
m_pWeaponSet->m_primaryWeapon = weapon;
}
BaseClass::OnCommand( command );
}
else
{
BaseClass::OnCommand(command);
}
}
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
class EquipmentComboBox : public ComboBox
{
public:
EquipmentComboBox( CBaseSelectBox *parent, const char *name, int numEntries, bool editable )
: ComboBox( parent, name, numEntries, editable )
{
m_pBox = parent;
}
virtual void OnSetText( const wchar_t *newText )
{
ComboBox::OnSetText( newText );
m_pBox->OnControlChanged();
}
private:
CBaseSelectBox *m_pBox;
};
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
CGrenadeSelectBox::CGrenadeSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet ) : BaseClass( parent, "BuyBoxSelectGrenades", false )
{
m_pWeaponSet = pWeaponSet;
// Equipment controls
m_pHEGrenade = new EquipmentComboBox( this, "hegrenade", 2, false );
m_pSmokeGrenade = new EquipmentComboBox( this, "smokegrenade", 2, false );
m_pFlashbangs = new EquipmentComboBox( this, "flashbangs", 3, false );
// Equipment images
m_pHEGrenadeImage = new EquipmentLabel( this, "HEGrenadeImage" );
m_pSmokeGrenadeImage = new EquipmentLabel( this, "SmokeGrenadeImage" );
m_pFlashbangImage = new EquipmentLabel( this, "FlashbangImage" );
m_pHELabel = new Label( this, "HECost", "" );
m_pSmokeLabel = new Label( this, "SmokeCost", "" );
m_pFlashLabel = new Label( this, "FlashCost", "" );
LoadControlSettings( "Resource/UI/BuyPreset/BoxSelectGrenades.res" );
// Add entries to the combo boxes
m_pHEGrenade->AddItem( "0", NULL );
m_pHEGrenade->AddItem( "1", NULL );
m_pSmokeGrenade->AddItem( "0", NULL );
m_pSmokeGrenade->AddItem( "1", NULL );
m_pFlashbangs->AddItem( "0", NULL );
m_pFlashbangs->AddItem( "1", NULL );
m_pFlashbangs->AddItem( "2", NULL );
// populate the data
m_pHEGrenade->ActivateItemByRow( m_pWeaponSet->m_HEGrenade );
m_pSmokeGrenade->ActivateItemByRow( m_pWeaponSet->m_smokeGrenade );
m_pFlashbangs->ActivateItemByRow( m_pWeaponSet->m_flashbangs );
m_pHEGrenadeImage->SetItem( "gfx/vgui/hegrenade_square", 1 );
m_pSmokeGrenadeImage->SetItem( "gfx/vgui/smokegrenade_square", 1 );
m_pFlashbangImage->SetItem( "gfx/vgui/flashbang_square", 1 );
OnControlChanged();
}
//--------------------------------------------------------------------------------------------------------------
void CGrenadeSelectBox::OnControlChanged()
{
const int BufLen = 256;
wchar_t wbuf[BufLen];
CCSWeaponInfo *info;
int numGrenades;
info = GetWeaponInfo( WEAPON_HEGRENADE );
if ( info )
{
numGrenades = m_pHEGrenade->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( info->GetWeaponPrice() * numGrenades ) );
m_pHELabel->SetText( wbuf );
}
info = GetWeaponInfo( WEAPON_SMOKEGRENADE );
if ( info )
{
numGrenades = m_pSmokeGrenade->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( info->GetWeaponPrice() * numGrenades ) );
m_pSmokeLabel->SetText( wbuf );
}
info = GetWeaponInfo( WEAPON_FLASHBANG );
if ( info )
{
numGrenades = m_pFlashbangs->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( info->GetWeaponPrice() * numGrenades ) );
m_pFlashLabel->SetText( wbuf );
}
}
//--------------------------------------------------------------------------------------------------------------
void CGrenadeSelectBox::OnCommand( const char *command )
{
if (!stricmp(command, "popup_ok"))
{
// stuff values back in m_pWeaponSet
m_pWeaponSet->m_HEGrenade = m_pHEGrenade->GetActiveItem();
m_pWeaponSet->m_smokeGrenade = m_pSmokeGrenade->GetActiveItem();
m_pWeaponSet->m_flashbangs = m_pFlashbangs->GetActiveItem();
}
BaseClass::OnCommand( command );
}
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
CEquipmentSelectBox::CEquipmentSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet ) : BaseClass( parent, "BuyBoxSelectEquipment", false )
{
m_pWeaponSet = pWeaponSet;
// Equipment controls
m_pKevlar = new EquipmentComboBox( this, "kevlar", 2, false );
m_pHelmet = new EquipmentComboBox( this, "helmet", 2, false );
m_pDefuser = new EquipmentComboBox( this, "defuser", 2, false );
m_pNightvision = new EquipmentComboBox( this, "nightvision", 2, false );
// Equipment labels
m_pKevlarLabel = new Label( this, "kevlarCost", "" );
m_pHelmetLabel = new Label( this, "helmetCost", "" );
m_pDefuserLabel = new Label( this, "defuserCost", "" );
m_pNightvisionLabel = new Label( this, "nightvisionCost", "" );
// Equipment images
m_pKevlarImage = new EquipmentLabel( this, "KevlarImage" );
m_pHelmetImage = new EquipmentLabel( this, "HelmetImage" );
m_pDefuserImage = new EquipmentLabel( this, "DefuserImage" );
m_pNightvisionImage = new EquipmentLabel( this, "NightvisionImage" );
LoadControlSettings( "Resource/UI/BuyPreset/BoxSelectEquipment.res" );
// Add entries to the combo boxes
m_pKevlar->AddItem( "0", NULL );
m_pKevlar->AddItem( "1", NULL );
m_pHelmet->AddItem( "0", NULL );
m_pHelmet->AddItem( "1", NULL );
m_pDefuser->AddItem( "0", NULL );
m_pDefuser->AddItem( "1", NULL );
m_pNightvision->AddItem( "0", NULL );
m_pNightvision->AddItem( "1", NULL );
// populate the data
m_pKevlar->ActivateItemByRow( ( m_pWeaponSet->m_armor > 0 ) );
m_pHelmet->ActivateItemByRow( ( m_pWeaponSet->m_armor && m_pWeaponSet->m_helmet ) );
m_pDefuser->ActivateItemByRow( m_pWeaponSet->m_defuser );
m_pNightvision->ActivateItemByRow( m_pWeaponSet->m_nightvision );
m_pKevlarImage->SetItem( "gfx/vgui/kevlar", 1 );
m_pHelmetImage->SetItem( "gfx/vgui/helmet", 1 );
m_pDefuserImage->SetItem( "gfx/vgui/defuser", 1 );
m_pNightvisionImage->SetItem( "gfx/vgui/nightvision", 1 );
OnControlChanged();
}
//--------------------------------------------------------------------------------------------------------------
void CEquipmentSelectBox::OnControlChanged()
{
const int BufLen = 256;
wchar_t wbuf[BufLen];
int iHelmetPrice = HELMET_PRICE;
int iKevlarPrice = KEVLAR_PRICE;
int iNVGPrice = NVG_PRICE;
if ( CSGameRules()->IsBlackMarket() )
{
iHelmetPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT ) - CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
iKevlarPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
iNVGPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG );
}
int count = m_pKevlar->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( iKevlarPrice * count ) );
m_pKevlarLabel->SetText( wbuf );
m_pHelmet->SetEnabled( count );
if ( !count && m_pHelmet->GetActiveItem() )
m_pHelmet->ActivateItemByRow( 0 );
count = m_pHelmet->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( iHelmetPrice * count ) );
m_pHelmetLabel->SetText( wbuf );
count = m_pDefuser->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( DEFUSEKIT_PRICE * count ) );
m_pDefuserLabel->SetText( wbuf );
count = m_pNightvision->GetActiveItem();
g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
1, NumAsWString( NVG_PRICE * count ) );
m_pNightvisionLabel->SetText( wbuf );
}
//--------------------------------------------------------------------------------------------------------------
void CEquipmentSelectBox::OnCommand( const char *command )
{
if (!stricmp(command, "popup_ok"))
{
// stuff values back in m_pWeaponSet
m_pWeaponSet->m_armor = m_pKevlar->GetActiveItem() ? 100 : 0;
m_pWeaponSet->m_helmet = m_pWeaponSet->m_armor && m_pHelmet->GetActiveItem();
m_pWeaponSet->m_defuser = m_pDefuser->GetActiveItem();
m_pWeaponSet->m_nightvision = m_pNightvision->GetActiveItem();
}
BaseClass::OnCommand( command );
}
//--------------------------------------------------------------------------------------------------------------