mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 22:27:05 +00:00
1526 lines
43 KiB
C++
1526 lines
43 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "weapon_selection.h"
|
|
#include "iclientmode.h"
|
|
#include "history_resource.h"
|
|
#include "input.h"
|
|
#include "../hud_crosshair.h"
|
|
|
|
#include "VGuiMatSurface/IMatSystemSurface.h"
|
|
#include <KeyValues.h>
|
|
#include <vgui/IScheme.h>
|
|
#include <vgui/ISurface.h>
|
|
#include <vgui/ISystem.h>
|
|
#include <vgui_controls/AnimationController.h>
|
|
#include <vgui_controls/Panel.h>
|
|
|
|
#include "vgui/ILocalize.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar hud_showemptyweaponslots( "hud_showemptyweaponslots", "1", FCVAR_ARCHIVE, "Shows slots for missing weapons when recieving weapons out of order" );
|
|
|
|
#define SELECTION_TIMEOUT_THRESHOLD 0.5f // Seconds
|
|
#define SELECTION_FADEOUT_TIME 0.75f
|
|
|
|
#define PLUS_DISPLAY_TIMEOUT 0.5f // Seconds
|
|
#define PLUS_FADEOUT_TIME 0.75f
|
|
|
|
#define FASTSWITCH_DISPLAY_TIMEOUT 1.5f
|
|
#define FASTSWITCH_FADEOUT_TIME 1.5f
|
|
|
|
#define CAROUSEL_SMALL_DISPLAY_ALPHA 200.0f
|
|
#define FASTSWITCH_SMALL_DISPLAY_ALPHA 160.0f
|
|
|
|
#define MAX_CAROUSEL_SLOTS 5
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: hl2 weapon selection hud element
|
|
//-----------------------------------------------------------------------------
|
|
class CHudWeaponSelection : public CBaseHudWeaponSelection, public vgui::Panel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CHudWeaponSelection, vgui::Panel );
|
|
|
|
public:
|
|
CHudWeaponSelection(const char *pElementName );
|
|
|
|
virtual bool ShouldDraw();
|
|
virtual void OnWeaponPickup( C_BaseCombatWeapon *pWeapon );
|
|
|
|
virtual void CycleToNextWeapon( void );
|
|
virtual void CycleToPrevWeapon( void );
|
|
|
|
virtual C_BaseCombatWeapon *GetWeaponInSlot( int iSlot, int iSlotPos );
|
|
virtual void SelectWeaponSlot( int iSlot );
|
|
|
|
virtual C_BaseCombatWeapon *GetSelectedWeapon( void )
|
|
{
|
|
return m_hSelectedWeapon;
|
|
}
|
|
|
|
virtual void OpenSelection( void );
|
|
virtual void HideSelection( void );
|
|
|
|
virtual void LevelInit();
|
|
|
|
protected:
|
|
virtual void OnThink();
|
|
virtual void Paint();
|
|
virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
|
|
|
|
virtual bool IsWeaponSelectable()
|
|
{
|
|
if (IsInSelectionMode())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
virtual void SetWeaponSelected()
|
|
{
|
|
CBaseHudWeaponSelection::SetWeaponSelected();
|
|
|
|
switch( hud_fastswitch.GetInt() )
|
|
{
|
|
case HUDTYPE_FASTSWITCH:
|
|
case HUDTYPE_CAROUSEL:
|
|
ActivateFastswitchWeaponDisplay( GetSelectedWeapon() );
|
|
break;
|
|
case HUDTYPE_PLUS:
|
|
ActivateWeaponHighlight( GetSelectedWeapon() );
|
|
break;
|
|
default:
|
|
// do nothing
|
|
break;
|
|
}
|
|
}
|
|
|
|
private:
|
|
C_BaseCombatWeapon *FindNextWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition);
|
|
C_BaseCombatWeapon *FindPrevWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition);
|
|
|
|
void DrawLargeWeaponBox( C_BaseCombatWeapon *pWeapon, bool bSelected, int x, int y, int wide, int tall, Color color, float alpha, int number );
|
|
void ActivateFastswitchWeaponDisplay( C_BaseCombatWeapon *pWeapon );
|
|
void ActivateWeaponHighlight( C_BaseCombatWeapon *pWeapon );
|
|
float GetWeaponBoxAlpha( bool bSelected );
|
|
int GetLastPosInSlot( int iSlot ) const;
|
|
|
|
void FastWeaponSwitch( int iWeaponSlot );
|
|
void PlusTypeFastWeaponSwitch( int iWeaponSlot );
|
|
|
|
virtual void SetSelectedWeapon( C_BaseCombatWeapon *pWeapon )
|
|
{
|
|
m_hSelectedWeapon = pWeapon;
|
|
}
|
|
|
|
virtual void SetSelectedSlot( int slot )
|
|
{
|
|
m_iSelectedSlot = slot;
|
|
}
|
|
|
|
void SetSelectedSlideDir( int dir )
|
|
{
|
|
m_iSelectedSlideDir = dir;
|
|
}
|
|
|
|
void DrawBox(int x, int y, int wide, int tall, Color color, float normalizedAlpha, int number);
|
|
|
|
CPanelAnimationVar( vgui::HFont, m_hNumberFont, "NumberFont", "HudSelectionNumbers" );
|
|
CPanelAnimationVar( vgui::HFont, m_hTextFont, "TextFont", "HudSelectionText" );
|
|
CPanelAnimationVar( float, m_flBlur, "Blur", "0" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flSmallBoxSize, "SmallBoxSize", "32", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flLargeBoxWide, "LargeBoxWide", "108", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flLargeBoxTall, "LargeBoxTall", "72", "proportional_float" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flMediumBoxWide, "MediumBoxWide", "75", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flMediumBoxTall, "MediumBoxTall", "50", "proportional_float" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flBoxGap, "BoxGap", "12", "proportional_float" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flSelectionNumberXPos, "SelectionNumberXPos", "4", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flSelectionNumberYPos, "SelectionNumberYPos", "4", "proportional_float" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flTextYPos, "TextYPos", "54", "proportional_float" );
|
|
|
|
CPanelAnimationVar( float, m_flAlphaOverride, "Alpha", "0" );
|
|
CPanelAnimationVar( float, m_flSelectionAlphaOverride, "SelectionAlpha", "0" );
|
|
|
|
CPanelAnimationVar( Color, m_TextColor, "TextColor", "SelectionTextFg" );
|
|
CPanelAnimationVar( Color, m_NumberColor, "NumberColor", "SelectionNumberFg" );
|
|
CPanelAnimationVar( Color, m_EmptyBoxColor, "EmptyBoxColor", "SelectionEmptyBoxBg" );
|
|
CPanelAnimationVar( Color, m_BoxColor, "BoxColor", "SelectionBoxBg" );
|
|
CPanelAnimationVar( Color, m_SelectedBoxColor, "SelectedBoxColor", "SelectionSelectedBoxBg" );
|
|
CPanelAnimationVar( Color, m_SelectedFgColor, "SelectedFgColor", "FgColor" );
|
|
CPanelAnimationVar( Color, m_BrightBoxColor, "SelectedFgColor", "BgColor" );
|
|
|
|
CPanelAnimationVar( float, m_flWeaponPickupGrowTime, "SelectionGrowTime", "0.1" );
|
|
|
|
CPanelAnimationVar( float, m_flTextScan, "TextScan", "1.0" );
|
|
|
|
bool m_bFadingOut;
|
|
|
|
// fastswitch weapon display
|
|
struct WeaponBox_t
|
|
{
|
|
int m_iSlot;
|
|
int m_iSlotPos;
|
|
};
|
|
CUtlVector<WeaponBox_t> m_WeaponBoxes;
|
|
int m_iSelectedWeaponBox;
|
|
int m_iSelectedSlideDir;
|
|
int m_iSelectedBoxPosition;
|
|
int m_iSelectedSlot;
|
|
C_BaseCombatWeapon *m_pLastWeapon;
|
|
CPanelAnimationVar( float, m_flHorizWeaponSelectOffsetPoint, "WeaponBoxOffset", "0" );
|
|
};
|
|
|
|
DECLARE_HUDELEMENT( CHudWeaponSelection );
|
|
|
|
using namespace vgui;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CHudWeaponSelection::CHudWeaponSelection( const char *pElementName ) : CBaseHudWeaponSelection(pElementName), BaseClass(NULL, "HudWeaponSelection")
|
|
{
|
|
vgui::Panel *pParent = g_pClientMode->GetViewport();
|
|
SetParent( pParent );
|
|
m_bFadingOut = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: sets up display for showing weapon pickup
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::OnWeaponPickup( C_BaseCombatWeapon *pWeapon )
|
|
{
|
|
// add to pickup history
|
|
CHudHistoryResource *pHudHR = GET_HUDELEMENT( CHudHistoryResource );
|
|
if ( pHudHR )
|
|
{
|
|
pHudHR->AddToHistory( pWeapon );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: updates animation status
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::OnThink( void )
|
|
{
|
|
float flSelectionTimeout = SELECTION_TIMEOUT_THRESHOLD;
|
|
float flSelectionFadeoutTime = SELECTION_FADEOUT_TIME;
|
|
if ( hud_fastswitch.GetBool() )
|
|
{
|
|
flSelectionTimeout = FASTSWITCH_DISPLAY_TIMEOUT;
|
|
flSelectionFadeoutTime = FASTSWITCH_FADEOUT_TIME;
|
|
}
|
|
|
|
// Time out after awhile of inactivity
|
|
if ( ( gpGlobals->curtime - m_flSelectionTime ) > flSelectionTimeout )
|
|
{
|
|
if (!m_bFadingOut)
|
|
{
|
|
// start fading out
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "FadeOutWeaponSelectionMenu" );
|
|
m_bFadingOut = true;
|
|
}
|
|
else if ( gpGlobals->curtime - m_flSelectionTime > flSelectionTimeout + flSelectionFadeoutTime )
|
|
{
|
|
// finished fade, close
|
|
HideSelection();
|
|
}
|
|
}
|
|
else if (m_bFadingOut)
|
|
{
|
|
// stop us fading out, show the animation again
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "OpenWeaponSelectionMenu" );
|
|
m_bFadingOut = false;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns true if the panel should draw
|
|
//-----------------------------------------------------------------------------
|
|
bool CHudWeaponSelection::ShouldDraw()
|
|
{
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
{
|
|
if ( IsInSelectionMode() )
|
|
{
|
|
HideSelection();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool bret = CBaseHudWeaponSelection::ShouldDraw();
|
|
if ( !bret )
|
|
return false;
|
|
|
|
// draw weapon selection a little longer if in fastswitch so we can see what we've selected
|
|
if ( hud_fastswitch.GetBool() && ( gpGlobals->curtime - m_flSelectionTime ) < (FASTSWITCH_DISPLAY_TIMEOUT + FASTSWITCH_FADEOUT_TIME) )
|
|
return true;
|
|
|
|
return ( m_bSelectionVisible ) ? true : false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::LevelInit()
|
|
{
|
|
CHudElement::LevelInit();
|
|
|
|
m_iSelectedWeaponBox = -1;
|
|
m_iSelectedSlideDir = 0;
|
|
m_pLastWeapon = NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: starts animating the center of the draw point to the newly selected weapon
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::ActivateFastswitchWeaponDisplay( C_BaseCombatWeapon *pSelectedWeapon )
|
|
{
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// make sure all our configuration data is read
|
|
MakeReadyForUse();
|
|
|
|
m_WeaponBoxes.RemoveAll();
|
|
m_iSelectedWeaponBox = 0;
|
|
|
|
// find out where our selected weapon is in the full list
|
|
int cWeapons = 0;
|
|
int iLastSelectedWeaponBox = -1;
|
|
for ( int i = 0; i < MAX_WEAPON_SLOTS; i++ )
|
|
{
|
|
for (int slotpos = 0; slotpos < MAX_WEAPON_POSITIONS; slotpos++)
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( i, slotpos );
|
|
if ( !pWeapon )
|
|
continue;
|
|
|
|
WeaponBox_t box = { i, slotpos };
|
|
m_WeaponBoxes.AddToTail( box );
|
|
|
|
if ( pWeapon == pSelectedWeapon )
|
|
{
|
|
m_iSelectedWeaponBox = cWeapons;
|
|
}
|
|
if ( pWeapon == m_pLastWeapon )
|
|
{
|
|
iLastSelectedWeaponBox = cWeapons;
|
|
}
|
|
cWeapons++;
|
|
}
|
|
}
|
|
|
|
if ( iLastSelectedWeaponBox == -1 )
|
|
{
|
|
// unexpected failure, no last weapon to scroll from, default to snap behavior
|
|
m_pLastWeapon = NULL;
|
|
}
|
|
|
|
// calculate where we would have to start drawing for this weapon to slide into center
|
|
float flStart, flStop, flTime;
|
|
if ( !m_pLastWeapon || m_iSelectedSlideDir == 0 || m_flHorizWeaponSelectOffsetPoint != 0 )
|
|
{
|
|
// no previous weapon or weapon selected directly or selection during slide, snap to exact position
|
|
m_pLastWeapon = pSelectedWeapon;
|
|
flStart = flStop = flTime = 0;
|
|
}
|
|
else
|
|
{
|
|
// offset display for a scroll
|
|
// causing selected weapon to slide into position
|
|
// scroll direction based on user's "previous" or "next" selection
|
|
int numIcons = 0;
|
|
int start = iLastSelectedWeaponBox;
|
|
for (int i=0; i<cWeapons; i++)
|
|
{
|
|
// count icons in direction of slide to destination
|
|
if ( start == m_iSelectedWeaponBox )
|
|
break;
|
|
if ( m_iSelectedSlideDir < 0 )
|
|
{
|
|
start--;
|
|
}
|
|
else
|
|
{
|
|
start++;
|
|
}
|
|
// handle wraparound in either direction
|
|
start = ( start + cWeapons ) % cWeapons;
|
|
numIcons++;
|
|
}
|
|
|
|
flStart = numIcons * (m_flLargeBoxWide + m_flBoxGap);
|
|
if ( m_iSelectedSlideDir < 0 )
|
|
flStart *= -1;
|
|
flStop = 0;
|
|
|
|
// shorten duration for scrolling when desired weapon is farther away
|
|
// otherwise a large skip in the same duration causes the scroll to fly too fast
|
|
flTime = numIcons * 0.20f;
|
|
if ( numIcons > 1 )
|
|
flTime *= 0.5f;
|
|
}
|
|
m_flHorizWeaponSelectOffsetPoint = flStart;
|
|
g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "WeaponBoxOffset", flStop, 0, flTime, AnimationController::INTERPOLATOR_LINEAR );
|
|
|
|
// start the highlight after the scroll completes
|
|
m_flBlur = 7.f;
|
|
g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "Blur", 0, flTime, 0.75f, AnimationController::INTERPOLATOR_DEACCEL );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: starts animating the highlight for the selected weapon
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::ActivateWeaponHighlight( C_BaseCombatWeapon *pSelectedWeapon )
|
|
{
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// make sure all our configuration data is read
|
|
MakeReadyForUse();
|
|
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( m_iSelectedSlot, m_iSelectedBoxPosition );
|
|
if ( !pWeapon )
|
|
return;
|
|
|
|
// start the highlight after the scroll completes
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "WeaponHighlight" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns an (per frame animating) alpha value for different weapon boxes
|
|
//-----------------------------------------------------------------------------
|
|
float CHudWeaponSelection::GetWeaponBoxAlpha( bool bSelected )
|
|
{
|
|
float alpha;
|
|
if ( bSelected )
|
|
{
|
|
alpha = m_flSelectionAlphaOverride;
|
|
}
|
|
else
|
|
{
|
|
alpha = m_flSelectionAlphaOverride * (m_flAlphaOverride / 255.0f);
|
|
}
|
|
return alpha;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Purpose: draws the selection area
|
|
//-------------------------------------------------------------------------
|
|
void CHudWeaponSelection::Paint()
|
|
{
|
|
int width;
|
|
int xpos;
|
|
int ypos;
|
|
|
|
if (!ShouldDraw())
|
|
return;
|
|
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// find and display our current selection
|
|
C_BaseCombatWeapon *pSelectedWeapon = NULL;
|
|
switch ( hud_fastswitch.GetInt() )
|
|
{
|
|
case HUDTYPE_FASTSWITCH:
|
|
case HUDTYPE_CAROUSEL:
|
|
pSelectedWeapon = pPlayer->GetActiveWeapon();
|
|
break;
|
|
default:
|
|
pSelectedWeapon = GetSelectedWeapon();
|
|
break;
|
|
}
|
|
if ( !pSelectedWeapon )
|
|
return;
|
|
|
|
bool bPushedViewport = false;
|
|
if( hud_fastswitch.GetInt() == HUDTYPE_FASTSWITCH || hud_fastswitch.GetInt() == HUDTYPE_PLUS )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
if( pRenderContext->GetRenderTarget() )
|
|
{
|
|
surface()->PushFullscreenViewport();
|
|
bPushedViewport = true;
|
|
}
|
|
}
|
|
|
|
// interpolate the selected box size between the small box size and the large box size
|
|
// interpolation has been removed since there is no weapon pickup animation anymore, so it's all at the largest size
|
|
float percentageDone = 1.0f; //min(1.0f, (gpGlobals->curtime - m_flPickupStartTime) / m_flWeaponPickupGrowTime);
|
|
int largeBoxWide = m_flSmallBoxSize + ((m_flLargeBoxWide - m_flSmallBoxSize) * percentageDone);
|
|
int largeBoxTall = m_flSmallBoxSize + ((m_flLargeBoxTall - m_flSmallBoxSize) * percentageDone);
|
|
Color selectedColor;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
selectedColor[i] = m_BoxColor[i] + ((m_SelectedBoxColor[i] - m_BoxColor[i]) * percentageDone);
|
|
}
|
|
|
|
switch ( hud_fastswitch.GetInt() )
|
|
{
|
|
case HUDTYPE_CAROUSEL:
|
|
{
|
|
// carousel style - flat line of items
|
|
ypos = 0;
|
|
if ( m_iSelectedWeaponBox == -1 || m_WeaponBoxes.Count() <= 1 )
|
|
{
|
|
// nothing to do
|
|
return;
|
|
}
|
|
else if ( m_WeaponBoxes.Count() < MAX_CAROUSEL_SLOTS )
|
|
{
|
|
// draw the selected weapon as a 1 of n style
|
|
width = (m_WeaponBoxes.Count()-1) * (m_flLargeBoxWide+m_flBoxGap) + m_flLargeBoxWide;
|
|
xpos = (GetWide() - width)/2;
|
|
for ( int i=0; i<m_WeaponBoxes.Count(); i++ )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( m_WeaponBoxes[i].m_iSlot, m_WeaponBoxes[i].m_iSlotPos );
|
|
if ( !pWeapon )
|
|
break;
|
|
|
|
float alpha = GetWeaponBoxAlpha( i == m_iSelectedWeaponBox );
|
|
if ( i == m_iSelectedWeaponBox )
|
|
{
|
|
// draw selected in highlighted style
|
|
DrawLargeWeaponBox( pWeapon, true, xpos, ypos, m_flLargeBoxWide, m_flLargeBoxTall, selectedColor, alpha, -1 );
|
|
}
|
|
else
|
|
{
|
|
DrawLargeWeaponBox( pWeapon, false, xpos, ypos, m_flLargeBoxWide, m_flLargeBoxTall / 1.5f, m_BoxColor, alpha, -1 );
|
|
}
|
|
|
|
xpos += (m_flLargeBoxWide + m_flBoxGap);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// draw the selected weapon in the center, as a continuous scrolling carosuel
|
|
// draw at center the current selected and all items to its right
|
|
xpos = GetWide()/2 + m_flHorizWeaponSelectOffsetPoint - largeBoxWide/2;
|
|
int i = m_iSelectedWeaponBox;
|
|
while ( 1 )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( m_WeaponBoxes[i].m_iSlot, m_WeaponBoxes[i].m_iSlotPos );
|
|
if ( !pWeapon )
|
|
break;
|
|
|
|
float alpha;
|
|
if ( i == m_iSelectedWeaponBox && !m_flHorizWeaponSelectOffsetPoint )
|
|
{
|
|
// draw selected in highlighted style
|
|
alpha = GetWeaponBoxAlpha( true );
|
|
DrawLargeWeaponBox( pWeapon, true, xpos, ypos, largeBoxWide, largeBoxTall, selectedColor, alpha, -1 );
|
|
}
|
|
else
|
|
{
|
|
alpha = GetWeaponBoxAlpha( false );
|
|
DrawLargeWeaponBox( pWeapon, false, xpos, ypos, largeBoxWide, largeBoxTall / 1.5f, m_BoxColor, alpha, -1 );
|
|
}
|
|
|
|
// advance until past edge
|
|
xpos += (largeBoxWide + m_flBoxGap);
|
|
if ( xpos >= GetWide() )
|
|
break;
|
|
|
|
++i;
|
|
if ( i >= m_WeaponBoxes.Count() )
|
|
{
|
|
// wraparound
|
|
i = 0;
|
|
}
|
|
}
|
|
|
|
// draw all items left of center
|
|
xpos = GetWide()/2 + m_flHorizWeaponSelectOffsetPoint - (3*largeBoxWide/2 + m_flBoxGap);
|
|
i = m_iSelectedWeaponBox - 1;
|
|
while ( 1 )
|
|
{
|
|
if ( i < 0 )
|
|
{
|
|
// wraparound
|
|
i = m_WeaponBoxes.Count() - 1;
|
|
}
|
|
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( m_WeaponBoxes[i].m_iSlot, m_WeaponBoxes[i].m_iSlotPos );
|
|
if ( !pWeapon )
|
|
break;
|
|
|
|
float alpha;
|
|
if ( i == m_iSelectedWeaponBox && !m_flHorizWeaponSelectOffsetPoint )
|
|
{
|
|
// draw selected in highlighted style
|
|
alpha = GetWeaponBoxAlpha( true );
|
|
DrawLargeWeaponBox( pWeapon, true, xpos, ypos, largeBoxWide, largeBoxTall, selectedColor, alpha, -1 );
|
|
}
|
|
else
|
|
{
|
|
alpha = GetWeaponBoxAlpha( false );
|
|
DrawLargeWeaponBox( pWeapon, false, xpos, ypos, largeBoxWide, largeBoxTall / 1.5f, m_BoxColor, alpha, -1 );
|
|
}
|
|
|
|
// retreat until past edge
|
|
xpos -= (largeBoxWide + m_flBoxGap);
|
|
if ( xpos + largeBoxWide <= 0 )
|
|
break;
|
|
|
|
--i;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HUDTYPE_PLUS:
|
|
{
|
|
float fCenterX, fCenterY;
|
|
bool bBehindCamera = false;
|
|
CHudCrosshair::GetDrawPosition( &fCenterX, &fCenterY, &bBehindCamera );
|
|
|
|
// if the crosshair is behind the camera, don't draw it
|
|
if( bBehindCamera )
|
|
return;
|
|
|
|
// bucket style
|
|
int screenCenterX = (int) fCenterX;
|
|
int screenCenterY = (int) fCenterY - 15; // Height isn't quite screen height, so adjust for center alignment
|
|
|
|
// Modifiers for the four directions. Used to change the x and y offsets
|
|
// of each box based on which bucket we're drawing. Bucket directions are
|
|
// 0 = UP, 1 = RIGHT, 2 = DOWN, 3 = LEFT
|
|
int xModifiers[] = { 0, 1, 0, -1, -1, 1 };
|
|
int yModifiers[] = { -1, 0, 1, 0, 1, 1 };
|
|
|
|
// Draw the four buckets
|
|
for ( int i = 0; i < MAX_WEAPON_SLOTS; ++i )
|
|
{
|
|
// Set the top left corner so the first box would be centered in the screen.
|
|
int xPos = screenCenterX -( m_flMediumBoxWide / 2 );
|
|
int yPos = screenCenterY -( m_flMediumBoxTall / 2 );
|
|
|
|
// Find out how many positions to draw - an empty position should still
|
|
// be drawn if there is an active weapon in any slots past it.
|
|
int lastSlotPos = -1;
|
|
for ( int slotPos = 0; slotPos < MAX_WEAPON_POSITIONS; ++slotPos )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( i, slotPos );
|
|
if ( pWeapon )
|
|
{
|
|
lastSlotPos = slotPos;
|
|
}
|
|
}
|
|
|
|
// Draw the weapons in this bucket
|
|
for ( int slotPos = 0; slotPos <= lastSlotPos; ++slotPos )
|
|
{
|
|
// Offset the box position
|
|
xPos += ( m_flMediumBoxWide + 5 ) * xModifiers[ i ];
|
|
yPos += ( m_flMediumBoxTall + 5 ) * yModifiers[ i ];
|
|
|
|
int boxWide = m_flMediumBoxWide;
|
|
int boxTall = m_flMediumBoxTall;
|
|
int x = xPos;
|
|
int y = yPos;
|
|
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( i, slotPos );
|
|
bool selectedWeapon = false;
|
|
if ( i == m_iSelectedSlot && slotPos == m_iSelectedBoxPosition )
|
|
{
|
|
// This is a bit of a misnomer... we really are asking "Is this the selected slot"?
|
|
selectedWeapon = true;
|
|
}
|
|
|
|
// Draw the box with the appropriate icon
|
|
DrawLargeWeaponBox( pWeapon,
|
|
selectedWeapon,
|
|
x,
|
|
y,
|
|
boxWide,
|
|
boxTall,
|
|
selectedWeapon ? selectedColor : m_BoxColor,
|
|
GetWeaponBoxAlpha( selectedWeapon ),
|
|
-1 );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HUDTYPE_BUCKETS:
|
|
{
|
|
// bucket style
|
|
width = (MAX_WEAPON_SLOTS - 1) * (m_flSmallBoxSize + m_flBoxGap) + largeBoxWide;
|
|
xpos = (GetWide() - width) / 2;
|
|
ypos = 0;
|
|
|
|
int iActiveSlot = (pSelectedWeapon ? pSelectedWeapon->GetSlot() : -1);
|
|
|
|
// draw the bucket set
|
|
// iterate over all the weapon slots
|
|
for ( int i = 0; i < MAX_WEAPON_SLOTS; i++ )
|
|
{
|
|
if ( i == iActiveSlot )
|
|
{
|
|
bool bDrawBucketNumber = true;
|
|
int iLastPos = GetLastPosInSlot( i );
|
|
|
|
for (int slotpos = 0; slotpos <= iLastPos; slotpos++)
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( i, slotpos );
|
|
if ( !pWeapon )
|
|
{
|
|
if ( !hud_showemptyweaponslots.GetBool() )
|
|
continue;
|
|
DrawBox( xpos, ypos, largeBoxWide, largeBoxTall, m_EmptyBoxColor, m_flAlphaOverride, bDrawBucketNumber ? i + 1 : -1 );
|
|
}
|
|
else
|
|
{
|
|
bool bSelected = (pWeapon == pSelectedWeapon);
|
|
DrawLargeWeaponBox( pWeapon,
|
|
bSelected,
|
|
xpos,
|
|
ypos,
|
|
largeBoxWide,
|
|
largeBoxTall,
|
|
bSelected ? selectedColor : m_BoxColor,
|
|
GetWeaponBoxAlpha( bSelected ),
|
|
bDrawBucketNumber ? i + 1 : -1 );
|
|
}
|
|
|
|
// move down to the next bucket
|
|
ypos += (largeBoxTall + m_flBoxGap);
|
|
bDrawBucketNumber = false;
|
|
}
|
|
|
|
xpos += largeBoxWide;
|
|
}
|
|
else
|
|
{
|
|
// check to see if there is a weapons in this bucket
|
|
if ( GetFirstPos( i ) )
|
|
{
|
|
// draw has weapon in slot
|
|
DrawBox(xpos, ypos, m_flSmallBoxSize, m_flSmallBoxSize, m_BoxColor, m_flAlphaOverride, i + 1);
|
|
}
|
|
else
|
|
{
|
|
// draw empty slot
|
|
DrawBox(xpos, ypos, m_flSmallBoxSize, m_flSmallBoxSize, m_EmptyBoxColor, m_flAlphaOverride, -1);
|
|
}
|
|
|
|
xpos += m_flSmallBoxSize;
|
|
}
|
|
|
|
// reset position
|
|
ypos = 0;
|
|
xpos += m_flBoxGap;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
// do nothing
|
|
}
|
|
break;
|
|
}
|
|
|
|
if( bPushedViewport )
|
|
{
|
|
surface()->PopFullscreenViewport();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: draws a single weapon selection box
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::DrawLargeWeaponBox( C_BaseCombatWeapon *pWeapon, bool bSelected, int xpos, int ypos, int boxWide, int boxTall, Color selectedColor, float alpha, int number )
|
|
{
|
|
Color col = bSelected ? m_SelectedFgColor : GetFgColor();
|
|
|
|
switch ( hud_fastswitch.GetInt() )
|
|
{
|
|
case HUDTYPE_BUCKETS:
|
|
{
|
|
// draw box for selected weapon
|
|
DrawBox( xpos, ypos, boxWide, boxTall, selectedColor, alpha, number );
|
|
|
|
// draw icon
|
|
col[3] *= (alpha / 255.0f);
|
|
if ( pWeapon->GetSpriteActive() )
|
|
{
|
|
// find the center of the box to draw in
|
|
int iconWidth = pWeapon->GetSpriteActive()->Width();
|
|
int iconHeight = pWeapon->GetSpriteActive()->Height();
|
|
|
|
int x_offs = (boxWide - iconWidth) / 2;
|
|
|
|
int y_offs;
|
|
if ( bSelected && hud_fastswitch.GetInt() != 0 )
|
|
{
|
|
// place the icon aligned with the non-selected version
|
|
y_offs = (boxTall / 1.5f - iconHeight) / 2;
|
|
}
|
|
else
|
|
{
|
|
y_offs = (boxTall - iconHeight) / 2;
|
|
}
|
|
|
|
if (!pWeapon->CanBeSelected())
|
|
{
|
|
// unselectable weapon, display as such
|
|
col = Color(255, 0, 0, col[3]);
|
|
}
|
|
else if (bSelected)
|
|
{
|
|
// currently selected weapon, display brighter
|
|
col[3] = alpha;
|
|
|
|
// draw an active version over the top
|
|
pWeapon->GetSpriteActive()->DrawSelf( xpos + x_offs, ypos + y_offs, col );
|
|
}
|
|
|
|
// draw the inactive version
|
|
pWeapon->GetSpriteInactive()->DrawSelf( xpos + x_offs, ypos + y_offs, col );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case HUDTYPE_PLUS:
|
|
case HUDTYPE_CAROUSEL:
|
|
{
|
|
if ( !pWeapon )
|
|
{
|
|
// draw red box for an empty bubble
|
|
if( bSelected )
|
|
{
|
|
selectedColor.SetColor( 255, 0, 0, 40 );
|
|
}
|
|
|
|
DrawBox( xpos, ypos, boxWide, boxTall, selectedColor, alpha, number );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// draw box for selected weapon
|
|
DrawBox( xpos, ypos, boxWide, boxTall, selectedColor, alpha, number );
|
|
}
|
|
|
|
int iconWidth;
|
|
int iconHeight;
|
|
int x_offs;
|
|
int y_offs;
|
|
|
|
// draw icon
|
|
col[3] *= (alpha / 255.0f);
|
|
|
|
if ( pWeapon->GetSpriteInactive() )
|
|
{
|
|
iconWidth = pWeapon->GetSpriteInactive()->Width();
|
|
iconHeight = pWeapon->GetSpriteInactive()->Height();
|
|
|
|
x_offs = (boxWide - iconWidth) / 2;
|
|
if ( bSelected && HUDTYPE_CAROUSEL == hud_fastswitch.GetInt() )
|
|
{
|
|
// place the icon aligned with the non-selected version
|
|
y_offs = (boxTall/1.5f - iconHeight) / 2;
|
|
}
|
|
else
|
|
{
|
|
y_offs = (boxTall - iconHeight) / 2;
|
|
}
|
|
|
|
if ( !pWeapon->CanBeSelected() )
|
|
{
|
|
// unselectable weapon, display as such
|
|
col = Color(255, 0, 0, col[3]);
|
|
}
|
|
|
|
// draw the inactive version
|
|
pWeapon->GetSpriteInactive()->DrawSelf( xpos + x_offs, ypos + y_offs, iconWidth, iconHeight, col );
|
|
}
|
|
|
|
if ( bSelected && pWeapon->GetSpriteActive() )
|
|
{
|
|
// find the center of the box to draw in
|
|
iconWidth = pWeapon->GetSpriteActive()->Width();
|
|
iconHeight = pWeapon->GetSpriteActive()->Height();
|
|
|
|
x_offs = (boxWide - iconWidth) / 2;
|
|
if ( HUDTYPE_CAROUSEL == hud_fastswitch.GetInt() )
|
|
{
|
|
// place the icon aligned with the non-selected version
|
|
y_offs = (boxTall/1.5f - iconHeight) / 2;
|
|
}
|
|
else
|
|
{
|
|
y_offs = (boxTall - iconHeight) / 2;
|
|
}
|
|
|
|
col[3] = 255;
|
|
for (float fl = m_flBlur; fl > 0.0f; fl -= 1.0f)
|
|
{
|
|
if (fl >= 1.0f)
|
|
{
|
|
pWeapon->GetSpriteActive()->DrawSelf( xpos + x_offs, ypos + y_offs, col );
|
|
}
|
|
else
|
|
{
|
|
// draw a percentage of the last one
|
|
col[3] *= fl;
|
|
pWeapon->GetSpriteActive()->DrawSelf( xpos + x_offs, ypos + y_offs, col );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
// do nothing
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( HUDTYPE_PLUS == hud_fastswitch.GetInt() )
|
|
{
|
|
// No text in plus bucket method
|
|
return;
|
|
}
|
|
|
|
// draw text
|
|
col = m_TextColor;
|
|
const FileWeaponInfo_t &weaponInfo = pWeapon->GetWpnData();
|
|
|
|
if ( bSelected )
|
|
{
|
|
wchar_t text[128];
|
|
wchar_t *tempString = g_pVGuiLocalize->Find(weaponInfo.szPrintName);
|
|
|
|
// setup our localized string
|
|
if ( tempString )
|
|
{
|
|
#ifdef WIN32
|
|
_snwprintf(text, sizeof(text)/sizeof(wchar_t) - 1, L"%s", tempString);
|
|
#else
|
|
_snwprintf(text, sizeof(text)/sizeof(wchar_t) - 1, L"%S", tempString);
|
|
#endif
|
|
text[sizeof(text)/sizeof(wchar_t) - 1] = 0;
|
|
}
|
|
else
|
|
{
|
|
// string wasn't found by g_pVGuiLocalize->Find()
|
|
g_pVGuiLocalize->ConvertANSIToUnicode(weaponInfo.szPrintName, text, sizeof(text));
|
|
}
|
|
|
|
surface()->DrawSetTextColor( col );
|
|
surface()->DrawSetTextFont( m_hTextFont );
|
|
|
|
// count the position
|
|
int slen = 0, charCount = 0, maxslen = 0;
|
|
int firstslen = 0;
|
|
{
|
|
for (wchar_t *pch = text; *pch != 0; pch++)
|
|
{
|
|
if (*pch == '\n')
|
|
{
|
|
// newline character, drop to the next line
|
|
if (slen > maxslen)
|
|
{
|
|
maxslen = slen;
|
|
}
|
|
if (!firstslen)
|
|
{
|
|
firstslen = slen;
|
|
}
|
|
|
|
slen = 0;
|
|
}
|
|
else if (*pch == '\r')
|
|
{
|
|
// do nothing
|
|
}
|
|
else
|
|
{
|
|
slen += surface()->GetCharacterWidth( m_hTextFont, *pch );
|
|
charCount++;
|
|
}
|
|
}
|
|
}
|
|
if (slen > maxslen)
|
|
{
|
|
maxslen = slen;
|
|
}
|
|
if (!firstslen)
|
|
{
|
|
firstslen = maxslen;
|
|
}
|
|
|
|
int tx = xpos + ((m_flLargeBoxWide - firstslen) / 2);
|
|
int ty = ypos + (int)m_flTextYPos;
|
|
surface()->DrawSetTextPos( tx, ty );
|
|
// adjust the charCount by the scan amount
|
|
charCount *= m_flTextScan;
|
|
for (wchar_t *pch = text; charCount > 0; pch++)
|
|
{
|
|
if (*pch == '\n')
|
|
{
|
|
// newline character, move to the next line
|
|
surface()->DrawSetTextPos( xpos + ((boxWide - slen) / 2), ty + (surface()->GetFontTall(m_hTextFont) * 1.1f));
|
|
}
|
|
else if (*pch == '\r')
|
|
{
|
|
// do nothing
|
|
}
|
|
else
|
|
{
|
|
surface()->DrawUnicodeChar(*pch);
|
|
charCount--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: draws a selection box
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::DrawBox(int x, int y, int wide, int tall, Color color, float normalizedAlpha, int number)
|
|
{
|
|
BaseClass::DrawBox( x, y, wide, tall, color, normalizedAlpha / 255.0f );
|
|
|
|
// draw the number
|
|
if (number >= 0)
|
|
{
|
|
Color numberColor = m_NumberColor;
|
|
numberColor[3] *= normalizedAlpha / 255.0f;
|
|
surface()->DrawSetTextColor(numberColor);
|
|
surface()->DrawSetTextFont(m_hNumberFont);
|
|
wchar_t wch = '0' + number;
|
|
surface()->DrawSetTextPos(x + m_flSelectionNumberXPos, y + m_flSelectionNumberYPos);
|
|
surface()->DrawUnicodeChar(wch);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: hud scheme settings
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::ApplySchemeSettings(vgui::IScheme *pScheme)
|
|
{
|
|
BaseClass::ApplySchemeSettings(pScheme);
|
|
SetPaintBackgroundEnabled(false);
|
|
|
|
// set our size
|
|
int screenWide, screenTall;
|
|
int x, y;
|
|
GetPos(x, y);
|
|
GetHudSize(screenWide, screenTall);
|
|
|
|
if ( hud_fastswitch.GetInt() == HUDTYPE_CAROUSEL )
|
|
{
|
|
// need bounds to be exact width for proper clipping during scroll
|
|
int width = MAX_CAROUSEL_SLOTS*m_flLargeBoxWide + (MAX_CAROUSEL_SLOTS-1)*m_flBoxGap;
|
|
SetBounds( (screenWide-width)/2, y, width, screenTall - y);
|
|
}
|
|
else
|
|
{
|
|
SetBounds( x, y, screenWide - x, screenTall - y );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens weapon selection control
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::OpenSelection( void )
|
|
{
|
|
Assert(!IsInSelectionMode());
|
|
|
|
CBaseHudWeaponSelection::OpenSelection();
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("OpenWeaponSelectionMenu");
|
|
m_iSelectedBoxPosition = 0;
|
|
m_iSelectedSlot = -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Closes weapon selection control immediately
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::HideSelection( void )
|
|
{
|
|
CBaseHudWeaponSelection::HideSelection();
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("CloseWeaponSelectionMenu");
|
|
m_bFadingOut = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the next available weapon item in the weapon selection
|
|
//-----------------------------------------------------------------------------
|
|
C_BaseCombatWeapon *CHudWeaponSelection::FindNextWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition)
|
|
{
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return NULL;
|
|
|
|
C_BaseCombatWeapon *pNextWeapon = NULL;
|
|
|
|
// search all the weapons looking for the closest next
|
|
int iLowestNextSlot = MAX_WEAPON_SLOTS;
|
|
int iLowestNextPosition = MAX_WEAPON_POSITIONS;
|
|
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = pPlayer->GetWeapon(i);
|
|
if ( !pWeapon )
|
|
continue;
|
|
|
|
if ( CanBeSelectedInHUD( pWeapon ) )
|
|
{
|
|
int weaponSlot = pWeapon->GetSlot(), weaponPosition = pWeapon->GetPosition();
|
|
|
|
// see if this weapon is further ahead in the selection list
|
|
if ( weaponSlot > iCurrentSlot || (weaponSlot == iCurrentSlot && weaponPosition > iCurrentPosition) )
|
|
{
|
|
// see if this weapon is closer than the current lowest
|
|
if ( weaponSlot < iLowestNextSlot || (weaponSlot == iLowestNextSlot && weaponPosition < iLowestNextPosition) )
|
|
{
|
|
iLowestNextSlot = weaponSlot;
|
|
iLowestNextPosition = weaponPosition;
|
|
pNextWeapon = pWeapon;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return pNextWeapon;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the prior available weapon item in the weapon selection
|
|
//-----------------------------------------------------------------------------
|
|
C_BaseCombatWeapon *CHudWeaponSelection::FindPrevWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition)
|
|
{
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return NULL;
|
|
|
|
C_BaseCombatWeapon *pPrevWeapon = NULL;
|
|
|
|
// search all the weapons looking for the closest next
|
|
int iLowestPrevSlot = -1;
|
|
int iLowestPrevPosition = -1;
|
|
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = pPlayer->GetWeapon(i);
|
|
if ( !pWeapon )
|
|
continue;
|
|
|
|
if ( CanBeSelectedInHUD( pWeapon ) )
|
|
{
|
|
int weaponSlot = pWeapon->GetSlot(), weaponPosition = pWeapon->GetPosition();
|
|
|
|
// see if this weapon is further ahead in the selection list
|
|
if ( weaponSlot < iCurrentSlot || (weaponSlot == iCurrentSlot && weaponPosition < iCurrentPosition) )
|
|
{
|
|
// see if this weapon is closer than the current lowest
|
|
if ( weaponSlot > iLowestPrevSlot || (weaponSlot == iLowestPrevSlot && weaponPosition > iLowestPrevPosition) )
|
|
{
|
|
iLowestPrevSlot = weaponSlot;
|
|
iLowestPrevPosition = weaponPosition;
|
|
pPrevWeapon = pWeapon;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return pPrevWeapon;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Moves the selection to the next item in the menu
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::CycleToNextWeapon( void )
|
|
{
|
|
// Get the local player.
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
m_pLastWeapon = pPlayer->GetActiveWeapon();
|
|
|
|
C_BaseCombatWeapon *pNextWeapon = NULL;
|
|
if ( IsInSelectionMode() )
|
|
{
|
|
// find the next selection spot
|
|
C_BaseCombatWeapon *pWeapon = GetSelectedWeapon();
|
|
if ( !pWeapon )
|
|
return;
|
|
|
|
pNextWeapon = FindNextWeaponInWeaponSelection( pWeapon->GetSlot(), pWeapon->GetPosition() );
|
|
}
|
|
else
|
|
{
|
|
// open selection at the current place
|
|
pNextWeapon = pPlayer->GetActiveWeapon();
|
|
if ( pNextWeapon )
|
|
{
|
|
pNextWeapon = FindNextWeaponInWeaponSelection( pNextWeapon->GetSlot(), pNextWeapon->GetPosition() );
|
|
}
|
|
}
|
|
|
|
if ( !pNextWeapon )
|
|
{
|
|
// wrap around back to start
|
|
pNextWeapon = FindNextWeaponInWeaponSelection(-1, -1);
|
|
}
|
|
|
|
if ( pNextWeapon )
|
|
{
|
|
SetSelectedWeapon( pNextWeapon );
|
|
SetSelectedSlideDir( 1 );
|
|
|
|
if ( !IsInSelectionMode() )
|
|
{
|
|
OpenSelection();
|
|
}
|
|
|
|
// Play the "cycle to next weapon" sound
|
|
pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Moves the selection to the previous item in the menu
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::CycleToPrevWeapon( void )
|
|
{
|
|
// Get the local player.
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
m_pLastWeapon = pPlayer->GetActiveWeapon();
|
|
|
|
C_BaseCombatWeapon *pNextWeapon = NULL;
|
|
if ( IsInSelectionMode() )
|
|
{
|
|
// find the next selection spot
|
|
C_BaseCombatWeapon *pWeapon = GetSelectedWeapon();
|
|
if ( !pWeapon )
|
|
return;
|
|
|
|
pNextWeapon = FindPrevWeaponInWeaponSelection( pWeapon->GetSlot(), pWeapon->GetPosition() );
|
|
}
|
|
else
|
|
{
|
|
// open selection at the current place
|
|
pNextWeapon = pPlayer->GetActiveWeapon();
|
|
if ( pNextWeapon )
|
|
{
|
|
pNextWeapon = FindPrevWeaponInWeaponSelection( pNextWeapon->GetSlot(), pNextWeapon->GetPosition() );
|
|
}
|
|
}
|
|
|
|
if ( !pNextWeapon )
|
|
{
|
|
// wrap around back to end of weapon list
|
|
pNextWeapon = FindPrevWeaponInWeaponSelection(MAX_WEAPON_SLOTS, MAX_WEAPON_POSITIONS);
|
|
}
|
|
|
|
if ( pNextWeapon )
|
|
{
|
|
SetSelectedWeapon( pNextWeapon );
|
|
SetSelectedSlideDir( -1 );
|
|
|
|
if ( !IsInSelectionMode() )
|
|
{
|
|
OpenSelection();
|
|
}
|
|
|
|
// Play the "cycle to next weapon" sound
|
|
pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the # of the last weapon in the specified slot
|
|
//-----------------------------------------------------------------------------
|
|
int CHudWeaponSelection::GetLastPosInSlot( int iSlot ) const
|
|
{
|
|
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
|
|
int iMaxSlotPos;
|
|
|
|
if ( !player )
|
|
return -1;
|
|
|
|
iMaxSlotPos = -1;
|
|
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = player->GetWeapon(i);
|
|
|
|
if ( pWeapon == NULL )
|
|
continue;
|
|
|
|
if ( pWeapon->GetSlot() == iSlot && pWeapon->GetPosition() > iMaxSlotPos )
|
|
iMaxSlotPos = pWeapon->GetPosition();
|
|
}
|
|
|
|
return iMaxSlotPos;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the weapon in the specified slot
|
|
//-----------------------------------------------------------------------------
|
|
C_BaseCombatWeapon *CHudWeaponSelection::GetWeaponInSlot( int iSlot, int iSlotPos )
|
|
{
|
|
C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
|
|
if ( !player )
|
|
return NULL;
|
|
|
|
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = player->GetWeapon(i);
|
|
|
|
if ( pWeapon == NULL )
|
|
continue;
|
|
|
|
if ( pWeapon->GetSlot() == iSlot && pWeapon->GetPosition() == iSlotPos )
|
|
return pWeapon;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens the next weapon in the slot
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::FastWeaponSwitch( int iWeaponSlot )
|
|
{
|
|
// get the slot the player's weapon is in
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
m_pLastWeapon = NULL;
|
|
|
|
// see where we should start selection
|
|
int iPosition = -1;
|
|
C_BaseCombatWeapon *pActiveWeapon = pPlayer->GetActiveWeapon();
|
|
if ( pActiveWeapon && pActiveWeapon->GetSlot() == iWeaponSlot )
|
|
{
|
|
// start after this weapon
|
|
iPosition = pActiveWeapon->GetPosition();
|
|
}
|
|
|
|
C_BaseCombatWeapon *pNextWeapon = NULL;
|
|
|
|
// search for the weapon after the current one
|
|
pNextWeapon = FindNextWeaponInWeaponSelection(iWeaponSlot, iPosition);
|
|
// make sure it's in the same bucket
|
|
if ( !pNextWeapon || pNextWeapon->GetSlot() != iWeaponSlot )
|
|
{
|
|
// just look for any weapon in this slot
|
|
pNextWeapon = FindNextWeaponInWeaponSelection(iWeaponSlot, -1);
|
|
}
|
|
|
|
// see if we found a weapon that's different from the current and in the selected slot
|
|
if ( pNextWeapon && pNextWeapon != pActiveWeapon && pNextWeapon->GetSlot() == iWeaponSlot )
|
|
{
|
|
// select the new weapon
|
|
::input->MakeWeaponSelection( pNextWeapon );
|
|
}
|
|
else if ( pNextWeapon != pActiveWeapon )
|
|
{
|
|
// error sound
|
|
pPlayer->EmitSound( "Player.DenyWeaponSelection" );
|
|
}
|
|
|
|
if ( HUDTYPE_CAROUSEL != hud_fastswitch.GetInt() )
|
|
{
|
|
// kill any fastswitch display
|
|
m_flSelectionTime = 0.0f;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens the next weapon in the slot
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::PlusTypeFastWeaponSwitch( int iWeaponSlot )
|
|
{
|
|
// get the slot the player's weapon is in
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
m_pLastWeapon = NULL;
|
|
int newSlot = m_iSelectedSlot;
|
|
|
|
// Changing slot number does not necessarily mean we need to change the slot - the player could be
|
|
// scrolling through the same slot but in the opposite direction. Slot pairs are 0,2 and 1,3 - so
|
|
// compare the 0 bits to see if we're within a pair. Otherwise, reset the box to the zero position.
|
|
if ( -1 == m_iSelectedSlot || ( ( m_iSelectedSlot ^ iWeaponSlot ) & 1 ) )
|
|
{
|
|
// Changing vertical/horizontal direction. Reset the selected box position to zero.
|
|
m_iSelectedBoxPosition = 0;
|
|
m_iSelectedSlot = iWeaponSlot;
|
|
}
|
|
else
|
|
{
|
|
// Still in the same horizontal/vertical direction. Determine which way we're moving in the slot.
|
|
int increment = 1;
|
|
if ( m_iSelectedSlot != iWeaponSlot )
|
|
{
|
|
// Decrementing within the slot. If we're at the zero position in this slot,
|
|
// jump to the zero position of the opposite slot. This also counts as our increment.
|
|
increment = -1;
|
|
if ( 0 == m_iSelectedBoxPosition )
|
|
{
|
|
newSlot = ( m_iSelectedSlot + 2 ) % 4;
|
|
increment = 0;
|
|
}
|
|
}
|
|
|
|
// Find out of the box position is at the end of the slot
|
|
int lastSlotPos = -1;
|
|
for ( int slotPos = 0; slotPos < MAX_WEAPON_POSITIONS; ++slotPos )
|
|
{
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( newSlot, slotPos );
|
|
if ( pWeapon )
|
|
{
|
|
lastSlotPos = slotPos;
|
|
}
|
|
}
|
|
|
|
// Increment/Decrement the selected box position
|
|
if ( m_iSelectedBoxPosition + increment <= lastSlotPos )
|
|
{
|
|
m_iSelectedBoxPosition += increment;
|
|
m_iSelectedSlot = newSlot;
|
|
}
|
|
else
|
|
{
|
|
// error sound
|
|
pPlayer->EmitSound( "Player.DenyWeaponSelection" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Select the weapon in this position
|
|
bool bWeaponSelected = false;
|
|
C_BaseCombatWeapon *pActiveWeapon = pPlayer->GetActiveWeapon();
|
|
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot( m_iSelectedSlot, m_iSelectedBoxPosition );
|
|
if ( pWeapon )
|
|
{
|
|
if ( pWeapon != pActiveWeapon )
|
|
{
|
|
// Select the new weapon
|
|
::input->MakeWeaponSelection( pWeapon );
|
|
SetSelectedWeapon( pWeapon );
|
|
bWeaponSelected = true;
|
|
}
|
|
}
|
|
|
|
if ( !bWeaponSelected )
|
|
{
|
|
// Still need to set this to make hud display appear
|
|
SetSelectedWeapon( pPlayer->GetActiveWeapon() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Moves selection to the specified slot
|
|
//-----------------------------------------------------------------------------
|
|
void CHudWeaponSelection::SelectWeaponSlot( int iSlot )
|
|
{
|
|
// iSlot is one higher than it should be, since it's the number key, not the 0-based index into the weapons
|
|
--iSlot;
|
|
|
|
// Get the local player.
|
|
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// Don't try and read past our possible number of slots
|
|
if ( iSlot >= MAX_WEAPON_SLOTS )
|
|
return;
|
|
|
|
// Make sure the player's allowed to switch weapons
|
|
if ( pPlayer->IsAllowedToSwitchWeapons() == false )
|
|
return;
|
|
|
|
switch( hud_fastswitch.GetInt() )
|
|
{
|
|
case HUDTYPE_FASTSWITCH:
|
|
case HUDTYPE_CAROUSEL:
|
|
{
|
|
FastWeaponSwitch( iSlot );
|
|
return;
|
|
}
|
|
|
|
case HUDTYPE_PLUS:
|
|
{
|
|
if ( !IsInSelectionMode() )
|
|
{
|
|
// open the weapon selection
|
|
OpenSelection();
|
|
}
|
|
|
|
PlusTypeFastWeaponSwitch( iSlot );
|
|
ActivateWeaponHighlight( GetSelectedWeapon() );
|
|
}
|
|
break;
|
|
|
|
case HUDTYPE_BUCKETS:
|
|
{
|
|
int slotPos = 0;
|
|
C_BaseCombatWeapon *pActiveWeapon = GetSelectedWeapon();
|
|
|
|
// start later in the list
|
|
if ( IsInSelectionMode() && pActiveWeapon && pActiveWeapon->GetSlot() == iSlot )
|
|
{
|
|
slotPos = pActiveWeapon->GetPosition() + 1;
|
|
}
|
|
|
|
// find the weapon in this slot
|
|
pActiveWeapon = GetNextActivePos( iSlot, slotPos );
|
|
if ( !pActiveWeapon )
|
|
{
|
|
pActiveWeapon = GetNextActivePos( iSlot, 0 );
|
|
}
|
|
|
|
if ( pActiveWeapon != NULL )
|
|
{
|
|
if ( !IsInSelectionMode() )
|
|
{
|
|
// open the weapon selection
|
|
OpenSelection();
|
|
}
|
|
|
|
// Mark the change
|
|
SetSelectedWeapon( pActiveWeapon );
|
|
SetSelectedSlideDir( 0 );
|
|
}
|
|
}
|
|
|
|
default:
|
|
{
|
|
// do nothing
|
|
}
|
|
break;
|
|
}
|
|
|
|
pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
|
|
}
|