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.

762 lines
22 KiB

5 years ago
//========= 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 <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"
//-----------------------------------------------------------------------------
// 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;
}
private:
C_BaseCombatWeapon *FindNextWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition);
C_BaseCombatWeapon *FindPrevWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition);
void FastWeaponSwitch( int iWeaponSlot );
virtual void SetSelectedWeapon( C_BaseCombatWeapon *pWeapon )
{
m_hSelectedWeapon = pWeapon;
}
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" );
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_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", "255" );
CPanelAnimationVar( float, m_flSelectionAlphaOverride, "SelectionAlpha", "255" );
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, "SelectedBoxClor", "SelectionSelectedBoxBg" );
CPanelAnimationVar( float, m_flWeaponPickupGrowTime, "SelectionGrowTime", "0.1" );
CPanelAnimationVar( float, m_flTextScan, "TextScan", "1.0" );
bool m_bFadingOut;
};
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 );
}
}
#define SELECTION_TIMEOUT_THRESHOLD 5.0f // Seconds
#define SELECTION_FADEOUT_TIME 1.5f
//-----------------------------------------------------------------------------
// Purpose: updates animation status
//-----------------------------------------------------------------------------
void CHudWeaponSelection::OnThink( void )
{
// Time out after awhile of inactivity
if ( ( gpGlobals->curtime - m_flSelectionTime ) > SELECTION_TIMEOUT_THRESHOLD )
{
if (!m_bFadingOut)
{
// start fading out
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "FadeOutWeaponSelectionMenu" );
m_bFadingOut = true;
}
else if (gpGlobals->curtime - m_flSelectionTime > SELECTION_TIMEOUT_THRESHOLD + SELECTION_FADEOUT_TIME)
{
// 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;
return ( m_bSelectionVisible ) ? true : false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHudWeaponSelection::LevelInit()
{
CHudElement::LevelInit();
}
//-------------------------------------------------------------------------
// Purpose: draws the selection area
//-------------------------------------------------------------------------
void CHudWeaponSelection::Paint()
{
if (!ShouldDraw())
return;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
// find and display our current selection
C_BaseCombatWeapon *pSelectedWeapon = GetSelectedWeapon();
if ( !pSelectedWeapon )
return;
int iActiveSlot = (pSelectedWeapon ? pSelectedWeapon->GetSlot() : -1);
// 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);
}}
// calculate where to start drawing
int width = (MAX_WEAPON_SLOTS - 1) * (m_flSmallBoxSize + m_flBoxGap) + largeBoxWide;
int xpos = (GetWide() - width) / 2;
int ypos = 0;
// iterate over all the weapon slots
for ( int i = 0; i < MAX_WEAPON_SLOTS; i++ )
{
if ( i == iActiveSlot )
{
bool bFirstItem = true;
for (int slotpos = 0; slotpos < MAX_WEAPON_POSITIONS; slotpos++)
{
C_BaseCombatWeapon *pWeapon = GetWeaponInSlot(i, slotpos);
if ( !pWeapon )
continue;
// draw box for selected weapon
DrawBox(xpos, ypos, largeBoxWide, largeBoxTall, selectedColor, m_flSelectionAlphaOverride, bFirstItem ? i + 1 : -1);
// draw icon
Color col = GetFgColor();
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 = (largeBoxWide - iconWidth) / 2;
int y_offs = (largeBoxTall - iconHeight) / 2;
if (!pWeapon->CanBeSelected())
{
// unselectable weapon, display as such
col = Color(255, 0, 0, col[3]);
}
else if (pWeapon == pSelectedWeapon)
{
// currently selected weapon, display brighter
col[3] = m_flSelectionAlphaOverride;
// 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 );
}
// draw text
col = m_TextColor;
const FileWeaponInfo_t &weaponInfo = pWeapon->GetWpnData();
if (pWeapon == pSelectedWeapon)
{
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 + ((largeBoxWide - 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 + ((largeBoxWide - slen) / 2), ty + (surface()->GetFontTall(m_hTextFont) * 1.1f));
}
else if (*pch == '\r')
{
// do nothing
}
else
{
surface()->DrawUnicodeChar(*pch);
charCount--;
}
}
}
ypos += (largeBoxTall + m_flBoxGap);
bFirstItem = 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;
}
}
//-----------------------------------------------------------------------------
// 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);
SetBounds(0, y, screenWide, screenTall - y);
}
//-----------------------------------------------------------------------------
// Purpose: Opens weapon selection control
//-----------------------------------------------------------------------------
void CHudWeaponSelection::OpenSelection( void )
{
Assert(!IsInSelectionMode());
CBaseHudWeaponSelection::OpenSelection();
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("OpenWeaponSelectionMenu");
}
//-----------------------------------------------------------------------------
// 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 ( pWeapon->CanBeSelected() )
{
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 ( pWeapon->CanBeSelected() )
{
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;
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 );
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;
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 );
if ( !IsInSelectionMode() )
{
OpenSelection();
}
// Play the "cycle to next weapon" sound
pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
}
}
//-----------------------------------------------------------------------------
// 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;
// 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" );
}
}
//-----------------------------------------------------------------------------
// 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;
// do a fast switch if set
if ( hud_fastswitch.GetBool() )
{
FastWeaponSwitch( iSlot );
return;
}
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 );
}
pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
}