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.
692 lines
22 KiB
692 lines
22 KiB
//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Displays HUD elements about health and armor
|
|
//
|
|
//=====================================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "hud.h"
|
|
#include "hudelement.h"
|
|
#include "hud_element_helper.h"
|
|
#include "iclientmode.h"
|
|
#include "view.h"
|
|
#include "vgui_controls/Controls.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "ivrenderview.h"
|
|
#include "scaleformui/scaleformui.h"
|
|
#include "sfhudweaponpanel.h"
|
|
#include "vgui/ILocalize.h"
|
|
#include "c_cs_hostage.h"
|
|
#include "HUD/sfweaponselection.h"
|
|
#include "clientsteamcontext.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#define SAFECALL( handle, func ) \
|
|
if ( handle ) \
|
|
{ \
|
|
func \
|
|
}
|
|
|
|
DECLARE_HUDELEMENT( SFHudWeaponPanel );
|
|
|
|
SFUI_BEGIN_GAME_API_DEF
|
|
SFUI_END_GAME_API_DEF( SFHudWeaponPanel, WeaponModule ); // Asset named WeaponModule to maintain consistency with Flash file naming
|
|
|
|
extern ConVar cl_draw_only_deathnotices;
|
|
|
|
SFHudWeaponPanel::SFHudWeaponPanel( const char *value ) : SFHudFlashInterface( value ),
|
|
m_PanelHandle( NULL ),
|
|
m_CurrentWeaponImageHandle( NULL ),
|
|
m_CurrentWeaponTextHandle( NULL ),
|
|
m_AmmoTextClipHandle( NULL ),
|
|
m_AmmoTextTotalHandle( NULL ),
|
|
m_AmmoAnimationHandle( NULL ),
|
|
m_BurstIcons_Burst( NULL ),
|
|
m_BurstIcons_Single( NULL ),
|
|
m_WeaponPenetration1( NULL ),
|
|
m_WeaponPenetration2( NULL ),
|
|
m_WeaponPenetration3( NULL ),
|
|
m_UpgradeKill1( NULL ),
|
|
m_UpgradeKill2( NULL ),
|
|
m_UpgradeKillText( NULL ),
|
|
m_BombHandle( NULL ),
|
|
m_DefuseHandle( NULL ),
|
|
m_BombZoneHandle( NULL ),
|
|
m_WeaponItemName( NULL ),
|
|
m_PrevAmmoClipCount( -1 ),
|
|
m_PrevAmmoTotalCount( -1 ),
|
|
m_PrevAmmoType( -1 ),
|
|
m_PrevWeaponID( -1 ),
|
|
m_PrevTRGunGameUpgradePoints( 0 ),
|
|
m_bHiddenNoAmmo( false ),
|
|
m_bCarryingC4( false ),
|
|
m_bCarryingDefuse( false ),
|
|
m_bInBombZone( false ),
|
|
m_lastEntityIndex( 0 ),
|
|
m_LastNumRoundKills( 0 ),
|
|
m_lastKillEaterCount( 0 )
|
|
|
|
{
|
|
// TODO Auto-generated constructor stub
|
|
SetHiddenBits( HIDEHUD_WEAPONSELECTION );
|
|
}
|
|
|
|
|
|
SFHudWeaponPanel::~SFHudWeaponPanel()
|
|
{
|
|
// TODO Auto-generated destructor stub
|
|
}
|
|
|
|
void SFHudWeaponPanel::ShowPanel( bool value )
|
|
{
|
|
if ( !m_pScaleformUI )
|
|
return;
|
|
|
|
WITH_SLOT_LOCKED
|
|
{
|
|
if ( m_FlashAPI )
|
|
{
|
|
if ( value )
|
|
{
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "showNow", NULL, 0 );
|
|
}
|
|
else
|
|
{
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "hideNow", NULL, 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SFHudWeaponPanel::SetVisible( bool bVisible )
|
|
{
|
|
if ( FlashAPIIsValid() )
|
|
{
|
|
WITH_SFVALUEARRAY_SLOT_LOCKED( data, 1 )
|
|
{
|
|
m_pScaleformUI->ValueArray_SetElement( data, 0, bVisible );
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "setVisible", data, 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void SFHudWeaponPanel::LockSlot( bool wantItLocked, bool& currentlyLocked )
|
|
{
|
|
if ( currentlyLocked != wantItLocked )
|
|
{
|
|
if ( wantItLocked )
|
|
{
|
|
LockScaleformSlot();
|
|
}
|
|
else
|
|
{
|
|
UnlockScaleformSlot();
|
|
}
|
|
|
|
currentlyLocked = wantItLocked;
|
|
}
|
|
}
|
|
|
|
void SFHudWeaponPanel::ProcessInput( void )
|
|
{
|
|
// Update stats
|
|
int currentClip = 0;
|
|
// we need the map clip to calculate the percentage of ammo left
|
|
// in the clip so the hud knows when to warn you
|
|
int maxClip = 0;
|
|
int totalAmmo = 0;
|
|
int ammoType = -1;
|
|
int weaponID = -1;
|
|
const char *weaponName = NULL;
|
|
const char *shortWeaponName = NULL;
|
|
bool bInTRBombMode = false;
|
|
bool bHideNoAmmo = false;
|
|
int CurrTRPoints = -1;
|
|
|
|
// Collect all player, weapon and game state data first:
|
|
|
|
if ( CSGameRules()->IsPlayingGunGame() )
|
|
{
|
|
if ( CSGameRules()->IsPlayingGunGameTRBomb() )
|
|
{
|
|
bInTRBombMode = true;
|
|
}
|
|
}
|
|
|
|
C_CSPlayer *pPlayer = GetHudPlayer();
|
|
CWeaponCSBase *pWeapon = NULL;
|
|
int entityIndex = pPlayer->entindex();
|
|
|
|
if ( pPlayer)
|
|
{
|
|
if ( CSGameRules()->IsBombDefuseMap() || CSGameRules()->IsHostageRescueMap() )
|
|
{
|
|
if ( m_bCarryingC4 != pPlayer->HasC4() )
|
|
{
|
|
m_bCarryingC4 = pPlayer->HasC4();
|
|
}
|
|
|
|
SFWeaponSelection *pHudWS = GET_HUDELEMENT( SFWeaponSelection );
|
|
if ( pHudWS )
|
|
{
|
|
static ConVarRef cl_hud_bomb_under_radar( "cl_hud_bomb_under_radar" );
|
|
bool bShowBomb = ( cl_hud_bomb_under_radar.GetInt( ) == 0 && m_bCarryingC4 );
|
|
//SAFECALL( m_BombHandle, m_pScaleformUI->Value_SetVisible( m_BombHandle, bShowBomb ); );
|
|
|
|
WITH_SFVALUEARRAY_SLOT_LOCKED( args, 1 )
|
|
{
|
|
m_pScaleformUI->ValueArray_SetElement( args, 0, bShowBomb );
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "ShowBomb", args, 1 );
|
|
}
|
|
}
|
|
|
|
if ( m_bCarryingDefuse != pPlayer->HasDefuser() )
|
|
{
|
|
m_bCarryingDefuse = pPlayer->HasDefuser();
|
|
SAFECALL( m_DefuseHandle, m_pScaleformUI->Value_SetVisible( m_DefuseHandle, m_bCarryingDefuse ); );
|
|
}
|
|
|
|
if ( m_bInBombZone != pPlayer->m_bInBombZone )
|
|
{
|
|
m_bInBombZone = pPlayer->m_bInBombZone;
|
|
SAFECALL( m_BombZoneHandle, m_pScaleformUI->Value_SetVisible( m_BombZoneHandle, m_bInBombZone ); );
|
|
}
|
|
|
|
}
|
|
|
|
int nRoundKills = pPlayer->GetNumRoundKills();
|
|
int nRoundKillsHeadshots = pPlayer->GetNumRoundKillsHeadshots();
|
|
if( pPlayer->IsControllingBot() )
|
|
{
|
|
C_CSPlayer *controlledPlayerScorer = ToCSPlayer( UTIL_PlayerByIndex( pPlayer->GetControlledBotIndex() ) );
|
|
if( controlledPlayerScorer )
|
|
{
|
|
nRoundKills = controlledPlayerScorer->GetNumRoundKills();
|
|
nRoundKillsHeadshots = controlledPlayerScorer->GetNumRoundKillsHeadshots();
|
|
}
|
|
}
|
|
|
|
if ( m_LastNumRoundKills != nRoundKills )
|
|
{
|
|
int nCurIndex = pPlayer->GetPlayerGunGameWeaponIndex();
|
|
int nRequiredKills = 0;
|
|
if ( CSGameRules()->IsPlayingGunGameProgressive() )
|
|
nRequiredKills = CSGameRules()->GetGunGameNumKillsRequiredForWeapon( nCurIndex, pPlayer->GetTeamNumber() );
|
|
|
|
WITH_SFVALUEARRAY_SLOT_LOCKED( args, 3 )
|
|
{
|
|
m_pScaleformUI->ValueArray_SetElement( args, 0, nRoundKills );
|
|
m_pScaleformUI->ValueArray_SetElement( args, 1, nRoundKillsHeadshots );
|
|
m_pScaleformUI->ValueArray_SetElement( args, 2, nRequiredKills );
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "setNumberKills", args, 3 );
|
|
}
|
|
|
|
m_LastNumRoundKills = nRoundKills;
|
|
}
|
|
|
|
if ( bInTRBombMode == true )
|
|
{
|
|
CurrTRPoints = pPlayer->GetNumGunGameTRKillPoints();
|
|
|
|
const int nUpgradedFlag = 99;
|
|
|
|
// We track "upgrade achieved" by saving the upgrade points as 99 - which means it will
|
|
// always differ from the actual kill points once we've already upgraded. So, we don't
|
|
// want to push another change to the panel until our points get reset at the next round
|
|
bool bAlreadyUpgraded = ( m_PrevTRGunGameUpgradePoints == nUpgradedFlag );
|
|
bool bZeroed = ( CurrTRPoints == 0 );
|
|
|
|
if ( ( m_PrevTRGunGameUpgradePoints != CurrTRPoints ) && ( !bAlreadyUpgraded || bZeroed ) )
|
|
{
|
|
// disable the little kill flags now because with the NEXT WEAPON panel serves this purpose and the flags cause confusion
|
|
// TODO: find a way to bring the kill flags back some way because they add a lot of value
|
|
/*
|
|
switch( CurrTRPoints )
|
|
{
|
|
case 0:
|
|
SAFECALL( m_UpgradeKill1, m_pScaleformUI->Value_SetVisible( m_UpgradeKill1, false); );
|
|
SAFECALL( m_UpgradeKill2, m_pScaleformUI->Value_SetVisible( m_UpgradeKill2, false); );
|
|
SAFECALL( m_UpgradeKillText, m_pScaleformUI->Value_SetVisible( m_UpgradeKillText, false ); );
|
|
break;
|
|
|
|
case 1:
|
|
SAFECALL( m_UpgradeKill1, m_pScaleformUI->Value_SetVisible( m_UpgradeKill1, true); );
|
|
break;
|
|
|
|
case 2:
|
|
SAFECALL( m_UpgradeKill2, m_pScaleformUI->Value_SetVisible( m_UpgradeKill2, true); );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
*/
|
|
|
|
static ConVarRef mp_ggtr_bomb_pts_for_upgrade( "mp_ggtr_bomb_pts_for_upgrade" );
|
|
|
|
if ( CurrTRPoints >= mp_ggtr_bomb_pts_for_upgrade.GetInt() )
|
|
{
|
|
// disable the little kill flags now because with the NEXT WEAPON panel serves this purpose and the flags cause confusion
|
|
// TODO: find a way to bring the kill flags back some way because they add a lot of value
|
|
/*
|
|
SAFECALL( m_UpgradeKillText, m_pScaleformUI->Value_SetVisible( m_UpgradeKillText, true); );
|
|
|
|
WITH_SLOT_LOCKED
|
|
{
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "playUpgradeAnim", NULL, 0 );
|
|
}
|
|
*/
|
|
|
|
m_PrevTRGunGameUpgradePoints = nUpgradedFlag;
|
|
}
|
|
else
|
|
{
|
|
m_PrevTRGunGameUpgradePoints = CurrTRPoints;
|
|
}
|
|
}
|
|
}
|
|
|
|
pWeapon = pPlayer ? (CWeaponCSBase*)pPlayer->GetActiveWeapon() : NULL;
|
|
|
|
if ( pWeapon )
|
|
{
|
|
weaponName = pWeapon->GetPrintName();
|
|
shortWeaponName = pWeapon->GetName();
|
|
|
|
// remap weaponID to our ammo numbering (defined in the action script for this hud element) - currently, just bullets vs grenades
|
|
// $TODO: are we going to reflect any other ammo types, like XBLA did?
|
|
|
|
weaponID = pWeapon->GetCSWeaponID();
|
|
switch ( weaponID )
|
|
{
|
|
case WEAPON_DECOY: // $FIXME: prototype grenades just display with the flashbang ammo
|
|
case WEAPON_MOLOTOV:
|
|
case WEAPON_INCGRENADE:
|
|
case WEAPON_FLASHBANG:
|
|
case WEAPON_TAGRENADE:
|
|
ammoType = 1;
|
|
break;
|
|
case WEAPON_HEGRENADE:
|
|
ammoType = 2;
|
|
break;
|
|
case WEAPON_SMOKEGRENADE:
|
|
ammoType = 3;
|
|
break;
|
|
case WEAPON_HEALTHSHOT:
|
|
ammoType = 10;
|
|
break;
|
|
default:
|
|
ammoType = 0;
|
|
break;
|
|
}
|
|
|
|
// determine what to display for ammo: "clip/total", "total" or nothing (for knife, c4, etc)
|
|
if ( !pWeapon->UsesPrimaryAmmo() )
|
|
{
|
|
currentClip = -1;
|
|
maxClip = -1;
|
|
totalAmmo = -1;
|
|
}
|
|
else
|
|
{
|
|
currentClip = pWeapon->Clip1();
|
|
maxClip = pWeapon->GetMaxClip1();
|
|
if ( currentClip < 0 )
|
|
{
|
|
// we don't use clip ammo, just use the total ammo count
|
|
currentClip = pWeapon->GetReserveAmmoCount( AMMO_POSITION_PRIMARY );
|
|
totalAmmo = -1;
|
|
}
|
|
else
|
|
{
|
|
// we use clip ammo, so the second ammo is the total ammo
|
|
totalAmmo = pWeapon->GetReserveAmmoCount( AMMO_POSITION_PRIMARY );
|
|
;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Updating flash, slot locking begins...
|
|
bool bSlotIsLocked = false;
|
|
char cNewStr[ 128 ];
|
|
|
|
// Update weapon image and text
|
|
if ( m_PrevWeaponID != weaponID )
|
|
{
|
|
LockSlot( true, bSlotIsLocked );
|
|
|
|
if ( weaponName )
|
|
{
|
|
SAFECALL( m_CurrentWeaponTextHandle, m_pScaleformUI->Value_SetText( m_CurrentWeaponTextHandle, weaponName ); );
|
|
}
|
|
|
|
// Update the selected weapon image as well
|
|
if ( FlashAPIIsValid() && shortWeaponName )
|
|
{
|
|
WITH_SFVALUEARRAY( data, 1 )
|
|
{
|
|
m_pScaleformUI->ValueArray_SetElement( data, 0, shortWeaponName );
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "switchWeaponName", data, 1 );
|
|
}
|
|
}
|
|
|
|
// CCSWeaponInfo const * pWeaponInfo = GetWeaponInfo( static_cast<CSWeaponID>( weaponID ) );
|
|
|
|
CEconItemView *pItem = pWeapon ? pWeapon->GetEconItemView() : NULL;
|
|
// if ( pWeaponInfo )
|
|
// {
|
|
// SAFECALL( m_WeaponPenetration1, m_pScaleformUI->Value_SetVisible( m_WeaponPenetration1, pWeaponInfo->GetAttributeFloat( "penetration", pItem ) == 1 ? true : false ); );
|
|
// SAFECALL( m_WeaponPenetration2, m_pScaleformUI->Value_SetVisible( m_WeaponPenetration2, pWeaponInfo->GetAttributeFloat( "penetration", pItem ) == 2 ? true : false ); );
|
|
// SAFECALL( m_WeaponPenetration3, m_pScaleformUI->Value_SetVisible( m_WeaponPenetration3, pWeaponInfo->GetAttributeFloat( "penetration", pItem ) == 3 ? true : false ); );
|
|
// }
|
|
|
|
// update the weapon name
|
|
if ( pWeapon )
|
|
{
|
|
if ( !pItem || !pItem->IsValid() || pItem->GetItemID() <= 0 || !GetItemSchema() || !GetItemSchema()->GetRarityDefinition( pItem->GetRarity() ) )
|
|
{
|
|
SAFECALL( m_WeaponItemName, m_pScaleformUI->Value_SetVisible( m_WeaponItemName, false ); );
|
|
}
|
|
else
|
|
{
|
|
const CEconItemRarityDefinition* pRarity = GetItemSchema()->GetRarityDefinition( pItem->GetRarity() );
|
|
SAFECALL( m_WeaponItemName, m_pScaleformUI->Value_SetVisible( m_WeaponItemName, true ); );
|
|
const int kColorBufSize = 128;
|
|
wchar_t rwchColor[kColorBufSize];
|
|
Q_UTF8ToUnicode( GetHexColorForAttribColor( pRarity->GetAttribColor() ), rwchColor, kColorBufSize );
|
|
|
|
// Update target name
|
|
wchar_t wcTargetWeaponFormatted[128];
|
|
V_snwprintf( wcTargetWeaponFormatted, ARRAYSIZE( wcTargetWeaponFormatted ), L"<font color=\"" PRI_WS_FOR_WS L"\">" PRI_WS_FOR_WS L"</font>", rwchColor, pItem->GetItemName() );
|
|
SAFECALL( m_WeaponItemName, m_pScaleformUI->Value_SetTextHTML( m_WeaponItemName, wcTargetWeaponFormatted ); );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Determine if this weapon has no ammo at all, so the panel should be hidden
|
|
bHideNoAmmo = (( totalAmmo < 0 ) && ( currentClip < 0 )) || !pWeapon;
|
|
|
|
if ( ( bInTRBombMode && CurrTRPoints > 0 ) ||
|
|
m_bCarryingC4 || m_bCarryingDefuse || m_bInBombZone || weaponID == WEAPON_KNIFE )
|
|
{
|
|
// Ensure we still show this when in TR Bomb AND we have kill points to display
|
|
// or if we have bomb/defuse kit or are in the bomb zone
|
|
bHideNoAmmo = false;
|
|
}
|
|
|
|
// Update ammo type/count/animating bullets elements
|
|
|
|
if (
|
|
( totalAmmo != m_PrevAmmoTotalCount ) ||
|
|
( currentClip != m_PrevAmmoClipCount ) ||
|
|
( weaponID != m_PrevWeaponID ) )
|
|
{
|
|
LockSlot( true, bSlotIsLocked );
|
|
|
|
// Display current weapon ammunition (or lack thereof)
|
|
bool bAmmoShown = true;
|
|
if ( totalAmmo < 0 )
|
|
{
|
|
// doesn't use ammo at all (knife, c4, etc)
|
|
cNewStr[0] = 0;
|
|
bAmmoShown = false;
|
|
}
|
|
else
|
|
{
|
|
V_snprintf( cNewStr, sizeof( cNewStr ), "%d", currentClip );
|
|
}
|
|
|
|
if ( bAmmoShown )
|
|
{
|
|
SAFECALL( m_AmmoTextClipHandle, m_pScaleformUI->Value_SetText( m_AmmoTextClipHandle, cNewStr ); );
|
|
V_snprintf( cNewStr, sizeof( cNewStr ), "/ %d", totalAmmo );
|
|
SAFECALL( m_AmmoTextTotalHandle, m_pScaleformUI->Value_SetText( m_AmmoTextTotalHandle, cNewStr ); );
|
|
}
|
|
|
|
SAFECALL( m_AmmoTextClipHandle, m_pScaleformUI->Value_SetVisible( m_AmmoTextClipHandle, bAmmoShown ); );
|
|
SAFECALL( m_AmmoTextTotalHandle, m_pScaleformUI->Value_SetVisible( m_AmmoTextTotalHandle, bAmmoShown ); );
|
|
}
|
|
|
|
bool bShowBurstBurst = (pWeapon && pWeapon->WeaponHasBurst() && pWeapon->IsInBurstMode());
|
|
bool bShowBurstSingle = (pWeapon && pWeapon->WeaponHasBurst() && !pWeapon->IsInBurstMode());
|
|
SAFECALL( m_BurstIcons_Burst, m_pScaleformUI->Value_SetVisible( m_BurstIcons_Burst, bShowBurstBurst ); );
|
|
SAFECALL( m_BurstIcons_Single, m_pScaleformUI->Value_SetVisible( m_BurstIcons_Single, bShowBurstSingle ); );
|
|
|
|
// Show the appropriate ammo for our weapon type
|
|
if ( ( m_PrevAmmoType != ammoType ) ||
|
|
( m_PrevAmmoClipCount != currentClip ) || (ammoType != 0 && weaponID != m_PrevWeaponID) )
|
|
{
|
|
if ( m_FlashAPI )
|
|
{
|
|
LockSlot( true, bSlotIsLocked );
|
|
|
|
WITH_SFVALUEARRAY( data, 4 )
|
|
{
|
|
m_pScaleformUI->ValueArray_SetElement( data, 0, ammoType );
|
|
m_pScaleformUI->ValueArray_SetElement( data, 1, currentClip );
|
|
m_pScaleformUI->ValueArray_SetElement( data, 2, maxClip );
|
|
m_pScaleformUI->ValueArray_SetElement( data, 3, shortWeaponName );
|
|
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "updateAmmo", data, 4 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Notify the HUD when we fire - detected by not changing weapon/observed player, and our ammo count decreases
|
|
if ( entityIndex == m_lastEntityIndex && m_PrevWeaponID == weaponID && (ammoType == 0) && m_PrevAmmoClipCount > 0 && currentClip < m_PrevAmmoClipCount )
|
|
{
|
|
if ( m_FlashAPI )
|
|
{
|
|
LockSlot( true, bSlotIsLocked );
|
|
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "weaponFired", NULL, 0 );
|
|
}
|
|
}
|
|
|
|
// Update previous state so we know which elements need to be refreshed next time
|
|
m_PrevAmmoClipCount = currentClip;
|
|
m_PrevAmmoTotalCount = totalAmmo;
|
|
m_PrevAmmoType = ammoType;
|
|
m_PrevWeaponID = weaponID;
|
|
m_lastEntityIndex = entityIndex;
|
|
|
|
LockSlot( false, bSlotIsLocked );
|
|
|
|
// Now determine if the panel should be entirely hidden, because our current weapon uses no ammo
|
|
if ( bHideNoAmmo != m_bHiddenNoAmmo )
|
|
{
|
|
if ( m_bActive )
|
|
{
|
|
ShowPanel( !bHideNoAmmo );
|
|
}
|
|
|
|
m_bHiddenNoAmmo = bHideNoAmmo;
|
|
}
|
|
}
|
|
|
|
void SFHudWeaponPanel::FireGameEvent( IGameEvent *event )
|
|
{
|
|
const char *type = event->GetName();
|
|
C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
int nPlayerUserID = pLocalPlayer->GetUserID();
|
|
int nEventUserID = event->GetInt( "userid" );
|
|
|
|
if ( StringHasPrefix( type, "round_start" ) ||
|
|
( StringHasPrefix( type, "player_death" ) && nPlayerUserID == nEventUserID ) ||
|
|
( StringHasPrefix( type, "bot_takeover" ) && nEventUserID == nPlayerUserID ) )
|
|
{
|
|
// reset these when the reound restarts of if the player dies
|
|
m_bCarryingC4 = false;
|
|
m_bCarryingDefuse = false;
|
|
SAFECALL( m_BombHandle, m_pScaleformUI->Value_SetVisible( m_BombHandle, false ); );
|
|
SAFECALL( m_DefuseHandle, m_pScaleformUI->Value_SetVisible( m_DefuseHandle, false ); );
|
|
|
|
if ( ( StringHasPrefix( type, "player_death" ) && !CSGameRules()->IsWarmupPeriod() ) )
|
|
{
|
|
int nCurIndex = pLocalPlayer->GetPlayerGunGameWeaponIndex();
|
|
|
|
int nRequiredKills = 0;
|
|
if ( CSGameRules()->IsPlayingGunGameProgressive() )
|
|
nRequiredKills = CSGameRules()->GetGunGameNumKillsRequiredForWeapon( nCurIndex, pLocalPlayer->GetTeamNumber() );
|
|
|
|
WITH_SFVALUEARRAY_SLOT_LOCKED( args, 3 )
|
|
{
|
|
m_pScaleformUI->ValueArray_SetElement( args, 0, 0 );
|
|
m_pScaleformUI->ValueArray_SetElement( args, 1, 0 );
|
|
m_pScaleformUI->ValueArray_SetElement( args, 2, nRequiredKills );
|
|
m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, "setNumberKills", args, 3 );
|
|
}
|
|
}
|
|
|
|
if ( CSGameRules()->IsPlayingGunGameProgressive() )
|
|
{
|
|
m_LastNumRoundKills = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void GetTextBoxForElement( IScaleformUI *pScaleformUI, SFVALUE root, const char *elementName, const char *textElementName, SFVALUE &sfv )
|
|
{
|
|
SFVALUE TempHandle = pScaleformUI->Value_GetMember( root, elementName );
|
|
|
|
if ( TempHandle )
|
|
{
|
|
sfv = pScaleformUI->Value_GetMember( TempHandle, textElementName );
|
|
pScaleformUI->ReleaseValue( TempHandle );
|
|
}
|
|
}
|
|
|
|
void SFHudWeaponPanel::FlashReady( void )
|
|
{
|
|
m_PanelHandle = m_pScaleformUI->Value_GetMember( m_FlashAPI, "HudPanel" );
|
|
|
|
if ( m_PanelHandle )
|
|
{
|
|
SFVALUE AnimatedPanelHandle = m_pScaleformUI->Value_GetMember( m_PanelHandle, "WeaponPanel" );
|
|
|
|
if ( AnimatedPanelHandle )
|
|
{
|
|
m_CurrentWeaponImageHandle = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "CurrentWeapon" );
|
|
GetTextBoxForElement( m_pScaleformUI, AnimatedPanelHandle, "WeaponText", "TextBox", m_CurrentWeaponTextHandle );
|
|
|
|
GetTextBoxForElement( m_pScaleformUI, AnimatedPanelHandle, "AmmoCountClip", "TextBox", m_AmmoTextClipHandle );
|
|
GetTextBoxForElement( m_pScaleformUI, AnimatedPanelHandle, "AmmoCountTotal", "TextBox", m_AmmoTextTotalHandle );
|
|
GetTextBoxForElement( m_pScaleformUI, AnimatedPanelHandle, "WeaponName", "TextBox", m_WeaponItemName );
|
|
m_AmmoAnimationHandle = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "AmmoAnim" );
|
|
|
|
m_BurstIcons_Burst = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "BurstTypeBurst" );
|
|
m_BurstIcons_Single = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "BurstTypeSingle" );
|
|
|
|
m_WeaponPenetration1 = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "Penetration1" );
|
|
m_WeaponPenetration2 = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "Penetration2" );
|
|
m_WeaponPenetration3 = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "Penetration3" );
|
|
m_UpgradeKill1 = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "Kill1" );
|
|
m_UpgradeKill2 = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "Kill2" );
|
|
m_UpgradeKillText = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "UpgradeText" );
|
|
|
|
m_BombHandle = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "BombCarrierIcon" );
|
|
m_DefuseHandle = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "DefuseKitIcon" );
|
|
m_BombZoneHandle = m_pScaleformUI->Value_GetMember( AnimatedPanelHandle, "InBombZoneIcon" );
|
|
|
|
SAFECALL( m_UpgradeKill1, m_pScaleformUI->Value_SetVisible( m_UpgradeKill1, false); );
|
|
SAFECALL( m_UpgradeKill2, m_pScaleformUI->Value_SetVisible( m_UpgradeKill2, false); );
|
|
SAFECALL( m_UpgradeKillText, m_pScaleformUI->Value_SetVisible( m_UpgradeKillText, false); );
|
|
|
|
SAFECALL( m_BombHandle, m_pScaleformUI->Value_SetVisible( m_BombHandle, false ); );
|
|
SAFECALL( m_DefuseHandle, m_pScaleformUI->Value_SetVisible( m_DefuseHandle, false ); );
|
|
SAFECALL( m_BombZoneHandle, m_pScaleformUI->Value_SetVisible( m_BombZoneHandle, false ); );
|
|
|
|
SAFECALL( m_WeaponItemName, m_pScaleformUI->Value_SetVisible( m_WeaponItemName, false ); );
|
|
|
|
m_pScaleformUI->ReleaseValue( AnimatedPanelHandle );
|
|
}
|
|
}
|
|
|
|
if ( m_FlashAPI && m_pScaleformUI )
|
|
{
|
|
ListenForGameEvent( "round_start" );
|
|
ListenForGameEvent( "player_death" );
|
|
ListenForGameEvent( "bot_takeover" );
|
|
}
|
|
|
|
// hide everything initially
|
|
SetVisible( false );
|
|
}
|
|
|
|
bool SFHudWeaponPanel::PreUnloadFlash( void )
|
|
{
|
|
SafeReleaseSFVALUE( m_PanelHandle );
|
|
SafeReleaseSFVALUE( m_CurrentWeaponImageHandle );
|
|
SafeReleaseSFVALUE( m_CurrentWeaponTextHandle );
|
|
SafeReleaseSFVALUE( m_AmmoTextClipHandle );
|
|
SafeReleaseSFVALUE( m_AmmoTextTotalHandle );
|
|
SafeReleaseSFVALUE( m_AmmoAnimationHandle );
|
|
SafeReleaseSFVALUE( m_BurstIcons_Burst );
|
|
SafeReleaseSFVALUE( m_BurstIcons_Single );
|
|
SafeReleaseSFVALUE( m_WeaponPenetration1 );
|
|
SafeReleaseSFVALUE( m_WeaponPenetration2 );
|
|
SafeReleaseSFVALUE( m_WeaponPenetration3 );
|
|
SafeReleaseSFVALUE( m_UpgradeKill1 );
|
|
SafeReleaseSFVALUE( m_UpgradeKill2 );
|
|
SafeReleaseSFVALUE( m_UpgradeKillText );
|
|
SafeReleaseSFVALUE( m_BombHandle );
|
|
SafeReleaseSFVALUE( m_DefuseHandle );
|
|
SafeReleaseSFVALUE( m_BombZoneHandle );
|
|
SafeReleaseSFVALUE( m_WeaponItemName );
|
|
|
|
return true;
|
|
}
|
|
|
|
void SFHudWeaponPanel::LevelInit( void )
|
|
{
|
|
if ( !FlashAPIIsValid() )
|
|
{
|
|
SFUI_REQUEST_ELEMENT( SF_SS_SLOT( GET_ACTIVE_SPLITSCREEN_SLOT() ), g_pScaleformUI, SFHudWeaponPanel, this, WeaponModule );
|
|
}
|
|
else
|
|
{
|
|
// When initially loaded, hide this panel
|
|
SetVisible( false );
|
|
}
|
|
|
|
// Reset all transient data
|
|
m_PrevAmmoClipCount = -1;
|
|
m_PrevAmmoTotalCount = -1;
|
|
m_PrevAmmoType = -1;
|
|
m_PrevWeaponID = -1;
|
|
m_PrevTRGunGameUpgradePoints = 0;
|
|
m_bHiddenNoAmmo = false;
|
|
}
|
|
|
|
void SFHudWeaponPanel::LevelShutdown( void )
|
|
{
|
|
if ( FlashAPIIsValid() )
|
|
{
|
|
RemoveFlashElement();
|
|
}
|
|
}
|
|
|
|
bool SFHudWeaponPanel::ShouldDraw( void )
|
|
{
|
|
return cl_drawhud.GetBool() && cl_draw_only_deathnotices.GetBool() == false && CHudElement::ShouldDraw();
|
|
}
|
|
|
|
|
|
void SFHudWeaponPanel::SetActive( bool bActive )
|
|
{
|
|
// Do not show the panel if we have hidden it because of an ammo-less weapon
|
|
if ( bActive != m_bActive && !m_bHiddenNoAmmo )
|
|
{
|
|
ShowPanel( bActive );
|
|
}
|
|
|
|
CHudElement::SetActive( bActive );
|
|
}
|
|
|