1225 lines
42 KiB
C++
1225 lines
42 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "hud.h"
|
|
#include "hudelement.h"
|
|
#include "c_tf_player.h"
|
|
#include "iclientmode.h"
|
|
#include "ienginevgui.h"
|
|
#include <vgui/ILocalize.h>
|
|
#include <vgui/ISurface.h>
|
|
#include <vgui/IVGui.h>
|
|
#include <vgui_controls/EditablePanel.h>
|
|
#include <vgui_controls/ProgressBar.h>
|
|
#include "view_scene.h"
|
|
#include "view.h"
|
|
#include "tf_gamerules.h"
|
|
#include "tf_logic_halloween_2014.h"
|
|
#include "tf_weapon_invis.h"
|
|
#include <vgui_controls/AnimationController.h>
|
|
|
|
#include "c_tf_objective_resource.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
using namespace vgui;
|
|
|
|
extern ISoundEmitterSystemBase *soundemitterbase;
|
|
|
|
// Floating delta text items, float off the top of the frame to
|
|
// show changes to the metal account value
|
|
typedef struct
|
|
{
|
|
enum eAccountDeltaType_t
|
|
{
|
|
ACCOUNT_DELTA_INVALID,
|
|
ACCOUNT_DELTA_HEALING,
|
|
ACCOUNT_DELTA_DAMAGE,
|
|
ACCOUNT_DELTA_BONUS_POINTS,
|
|
ACCOUNT_DELTA_ROBOT_DESTRUCTION_POINT_RED,
|
|
ACCOUNT_DELTA_ROBOT_DESTRUCTION_POINT_BLUE,
|
|
};
|
|
|
|
|
|
|
|
// amount of delta
|
|
int m_iAmount;
|
|
|
|
bool m_bLargeFont; // display larger font
|
|
eAccountDeltaType_t m_eDataType;
|
|
|
|
// die time
|
|
float m_flDieTime;
|
|
|
|
// position
|
|
int m_nX; // X Pos in screen space & world space
|
|
int m_nXEnd; // Ending X Pos in screen space and world space
|
|
int m_nHStart; // Starting Y Pos in screen space, Z pos in world space
|
|
int m_nHEnd; // Ending Y Pos in screen space, Z pos in world space
|
|
int m_nY; // Y Coord in world space, not used in screen space
|
|
bool m_bWorldSpace;
|
|
float m_flBatchWindow;
|
|
int m_nSourceID; // Can be entindex, etc
|
|
Color m_color;
|
|
bool m_bShadows;
|
|
|
|
// append a bit of extra text to the end
|
|
wchar_t m_wzText[8];
|
|
|
|
} account_delta_t;
|
|
|
|
#define NUM_ACCOUNT_DELTA_ITEMS 10
|
|
|
|
ConVar hud_combattext( "hud_combattext", "1", FCVAR_USERINFO | FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX );
|
|
ConVar hud_combattext_healing( "hud_combattext_healing", "1", FCVAR_USERINFO | FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX, "Shows health restored per-second over heal targets." );
|
|
ConVar hud_combattext_batching( "hud_combattext_batching", "0", FCVAR_USERINFO | FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX, "If set to 1, numbers that are too close together are merged." );
|
|
ConVar hud_combattext_batching_window( "hud_combattext_batching_window", "0.2", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX, "Maximum delay between damage events in order to batch numbers.", true, 0.1, true, 2.0 );
|
|
ConVar hud_combattext_doesnt_block_overhead_text( "hud_combattext_doesnt_block_overhead_text", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "If set to 1, allow text like \"CRIT\" to still show over a victim's head." );
|
|
|
|
ConVar tf_dingalingaling( "tf_dingalingaling", "0", FCVAR_ARCHIVE, "If set to 1, play a sound everytime you injure an enemy. The sound can be customized by replacing the 'tf/sound/ui/hitsound.wav' file." );
|
|
ConVar tf_dingaling_volume( "tf_dingaling_volume", "0.75", FCVAR_ARCHIVE, "Desired volume of the hit sound.", true, 0.0, true, 1.0 );
|
|
ConVar tf_dingaling_pitchmindmg( "tf_dingaling_pitchmindmg", "100", FCVAR_ARCHIVE, "Desired pitch of the hit sound when a minimal damage hit (<= 10 health) is done.", true, 1, true, 255 );
|
|
ConVar tf_dingaling_pitchmaxdmg( "tf_dingaling_pitchmaxdmg", "100", FCVAR_ARCHIVE, "Desired pitch of the hit sound when a maximum damage hit (>= 150 health) is done.", true, 1, true, 255 );
|
|
ConVar tf_dingaling_pitch_override( "tf_dingaling_pitch_override", "-1", FCVAR_NONE, "If set, pitch for all hit sounds." );
|
|
|
|
ConVar tf_dingalingaling_lasthit( "tf_dingalingaling_lasthit", "0", FCVAR_ARCHIVE, "If set to 1, play a sound whenever one of your attacks kills an enemy. The sound can be customized by replacing the 'tf/sound/ui/killsound.wav' file." );
|
|
ConVar tf_dingaling_lasthit_volume( "tf_dingaling_lasthit_volume", "0.75", FCVAR_ARCHIVE, "Desired volume of the last hit sound.", true, 0.0, true, 1.0 );
|
|
ConVar tf_dingaling_lasthit_pitchmindmg( "tf_dingaling_lasthit_pitchmindmg", "100", FCVAR_ARCHIVE, "Desired pitch of the last hit sound when a minimal damage hit (<= 10 health) is done.", true, 1, true, 255 );
|
|
ConVar tf_dingaling_lasthit_pitchmaxdmg( "tf_dingaling_lasthit_pitchmaxdmg", "100", FCVAR_ARCHIVE, "Desired pitch of the last hit sound when a maximum damage hit (>= 150 health) is done.", true, 1, true, 255 );
|
|
ConVar tf_dingaling_lasthit_pitch_override( "tf_dingaling_lasthit_pitch_override", "-1", FCVAR_NONE, "If set, pitch for last hit sounds." );
|
|
|
|
ConVar tf_dingalingaling_repeat_delay( "tf_dingalingaling_repeat_delay", "0.0", FCVAR_ARCHIVE, "Desired repeat delay of the hit sound. Set to 0 to play a sound for every instance of damage dealt.", true, 0.f, false, 0.f );
|
|
|
|
ConVar hud_damagemeter( "hud_damagemeter", "0", FCVAR_CHEAT, "Display damage-per-second information in the lower right corner of the screen." );
|
|
ConVar hud_damagemeter_period( "hud_damagemeter_period", "0", FCVAR_NONE, "When set to zero, average damage-per-second across all recent damage events, otherwise average damage across defined period (number of seconds)." );
|
|
ConVar hud_damagemeter_ooctimer( "hud_damagemeter_ooctimer", "1", FCVAR_NONE, "How many seconds after the last damage event before we consider the player out of combat." );
|
|
|
|
struct hitsound_params_t
|
|
{
|
|
hitsound_params_t( const char * pszName, int minpitch, int maxpitch )
|
|
{
|
|
m_pszName = pszName;
|
|
m_iMinPitch = minpitch;
|
|
m_iMaxPitch = maxpitch;
|
|
}
|
|
|
|
float GetPitchMin( bool bLastHit ) const
|
|
{
|
|
return bLastHit ? tf_dingaling_lasthit_pitchmindmg.GetInt() : tf_dingaling_pitchmindmg.GetInt();
|
|
//return RemapValClamped( tf_dingaling_pitchmindmg.GetInt(), 0, 100, m_iMinPitch, m_iMaxPitch );
|
|
}
|
|
|
|
float GetPitchMax( bool bLastHit ) const
|
|
{
|
|
return bLastHit ? tf_dingaling_lasthit_pitchmaxdmg.GetInt() : tf_dingaling_pitchmaxdmg.GetInt();
|
|
//return RemapValClamped( tf_dingaling_pitchmaxdmg.GetInt(), 0, 100, m_iMinPitch, m_iMaxPitch );
|
|
}
|
|
|
|
float GetPitchFromDamage( int damage, bool bLastHit ) const
|
|
{
|
|
if ( bLastHit && tf_dingaling_lasthit_pitch_override.GetInt() > 0 )
|
|
{
|
|
return tf_dingaling_lasthit_pitch_override.GetFloat();
|
|
}
|
|
else if ( tf_dingaling_pitch_override.GetInt() > 0 )
|
|
{
|
|
return tf_dingaling_pitch_override.GetFloat();
|
|
}
|
|
|
|
return RemapValClamped( damage, 10, 150, GetPitchMin( bLastHit ), GetPitchMax( bLastHit ) );
|
|
}
|
|
|
|
const char *m_pszName;
|
|
int m_iMinPitch;
|
|
int m_iMaxPitch;
|
|
};
|
|
|
|
static const hitsound_params_t g_HitSounds[] =
|
|
{
|
|
hitsound_params_t( "Player.HitSoundDefaultDing", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundElectro", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundNotes", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundPercussion", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundRetro", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundSpace", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundBeepo", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundVortex", 1, 255 ),
|
|
hitsound_params_t( "Player.HitSoundSquasher", 1, 255 ),
|
|
};
|
|
|
|
static const hitsound_params_t g_LastHitSounds[] =
|
|
{
|
|
hitsound_params_t( "Player.KillSoundDefaultDing", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundElectro", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundNotes", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundPercussion", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundRetro", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundSpace", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundBeepo", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundVortex", 1, 255 ),
|
|
hitsound_params_t( "Player.KillSoundSquasher", 1, 255 ),
|
|
};
|
|
|
|
ConVar tf_dingalingaling_effect( "tf_dingalingaling_effect", "0", FCVAR_ARCHIVE, "Which Dingalingaling sound is used", true, 0, true, ARRAYSIZE( g_HitSounds )-1 );
|
|
ConVar tf_dingalingaling_last_effect( "tf_dingalingaling_last_effect", "0", FCVAR_ARCHIVE, "Which final hit sound to play when the target expires.", true, 0, true, ARRAYSIZE( g_LastHitSounds )-1 );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CAccountPanel : public EditablePanel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CAccountPanel, EditablePanel );
|
|
|
|
public:
|
|
CAccountPanel( Panel *parent, const char *name )
|
|
: EditablePanel( parent, name )
|
|
{
|
|
m_nBGTexture = -1;
|
|
m_bNegativeFlipDir = false;
|
|
SetDialogVariable( "metal", 0 );
|
|
}
|
|
|
|
virtual void ApplySchemeSettings( IScheme *scheme ) OVERRIDE;
|
|
virtual void ApplySettings( KeyValues *inResourceData ) OVERRIDE;
|
|
virtual void Paint( void ) OVERRIDE;
|
|
|
|
virtual account_delta_t *OnAccountValueChanged( int iOldValue, int iNewValue, account_delta_t::eAccountDeltaType_t type );
|
|
|
|
virtual const char *GetResFileName( void ) { return "resource/UI/HudAccountPanel.res"; }
|
|
|
|
protected:
|
|
virtual Color GetColor( const account_delta_t::eAccountDeltaType_t& type );
|
|
|
|
CUtlVector <account_delta_t> m_AccountDeltaItems;
|
|
|
|
int m_nBGTexture;
|
|
bool m_bNegativeFlipDir;
|
|
|
|
CPanelAnimationVarAliasType( float, m_flDeltaItemStartPos, "delta_item_start_y", "100", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flDeltaItemEndPos, "delta_item_end_y", "0", "proportional_float" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flDeltaItemX, "delta_item_x", "0", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flDeltaItemXEndPos, "delta_item_end_x", "0", "proportional_float" );
|
|
|
|
CPanelAnimationVarAliasType( float, m_flBGImageX, "bg_image_x", "0", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flBGImageY, "bg_image_y", "0", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flBGImageWide, "bg_image_wide", "0", "proportional_float" );
|
|
CPanelAnimationVarAliasType( float, m_flBGImageTall, "bg_image_tall", "0", "proportional_float" );
|
|
|
|
CPanelAnimationVar( Color, m_DeltaPositiveColor, "PositiveColor", "0 255 0 255" );
|
|
CPanelAnimationVar( Color, m_DeltaNegativeColor, "NegativeColor", "255 0 0 255" );
|
|
CPanelAnimationVar( Color, m_DeltaEventColor, "EventColor", "255 0 255 255" );
|
|
CPanelAnimationVar( Color, m_DeltaRedRobotScoreColor, "RedRobotScoreColor", "255 0 0 255" );
|
|
CPanelAnimationVar( Color, m_DeltaBlueRobotScoreColor, "BlueRobotScoreColor", "0 166 255 255" );
|
|
|
|
CPanelAnimationVar( float, m_flDeltaLifetime, "delta_lifetime", "2.0" );
|
|
|
|
CPanelAnimationVar( vgui::HFont, m_hDeltaItemFont, "delta_item_font", "Default" );
|
|
CPanelAnimationVar( vgui::HFont, m_hDeltaItemFontBig, "delta_item_font_big", "Default" );
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CHudAccountPanel : public CHudElement, public CAccountPanel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CHudAccountPanel, CAccountPanel );
|
|
|
|
public:
|
|
CHudAccountPanel( const char *pElementName )
|
|
: CHudElement( pElementName )
|
|
, CAccountPanel( NULL, pElementName )
|
|
{
|
|
Panel *pParent = g_pClientMode->GetViewport();
|
|
SetParent( pParent );
|
|
SetHiddenBits( HIDEHUD_MISCSTATUS );
|
|
ListenForGameEvent( "player_account_changed" );
|
|
}
|
|
|
|
virtual void LevelInit( void ) OVERRIDE
|
|
{
|
|
CHudElement::LevelInit();
|
|
}
|
|
|
|
virtual void FireGameEvent( IGameEvent *event ) OVERRIDE
|
|
{
|
|
const char * type = event->GetName();
|
|
|
|
if ( Q_strcmp(type, "player_account_changed") == 0 )
|
|
{
|
|
int iOldValue = event->GetInt( "old_account" );
|
|
int iNewValue = event->GetInt( "new_account" );
|
|
account_delta_t::eAccountDeltaType_t deltaType = ( iNewValue - iOldValue >= 0 ) ? account_delta_t::ACCOUNT_DELTA_HEALING
|
|
: account_delta_t::ACCOUNT_DELTA_DAMAGE;
|
|
|
|
OnAccountValueChanged( iOldValue, iNewValue, deltaType );
|
|
}
|
|
else
|
|
{
|
|
CHudElement::FireGameEvent( event );
|
|
}
|
|
}
|
|
|
|
virtual bool ShouldDraw( void ) OVERRIDE
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer || !pPlayer->IsAlive() || !pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
|
|
{
|
|
m_AccountDeltaItems.RemoveAll();
|
|
return false;
|
|
}
|
|
|
|
CTFPlayer *pTFPlayer = CTFPlayer::GetLocalTFPlayer();
|
|
if ( pTFPlayer && pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
|
|
return false;
|
|
|
|
if ( CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() )
|
|
return false;
|
|
|
|
if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
|
|
return false;
|
|
|
|
return CHudElement::ShouldDraw();
|
|
}
|
|
};
|
|
|
|
DECLARE_HUDELEMENT( CHudAccountPanel );
|
|
|
|
// Derived account panels
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CHealthAccountPanel : public CHudAccountPanel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CHealthAccountPanel, CHudAccountPanel );
|
|
public:
|
|
CHealthAccountPanel( const char *pElementName ) : CHudAccountPanel(pElementName)
|
|
{
|
|
ListenForGameEvent( "player_healonhit" );
|
|
}
|
|
|
|
virtual const char *GetResFileName( void ) { return "resource/UI/HudHealthAccount.res"; }
|
|
|
|
void FireGameEvent( IGameEvent *event )
|
|
{
|
|
const char * type = event->GetName();
|
|
|
|
if ( Q_strcmp(type, "player_healonhit") == 0 )
|
|
{
|
|
int iAmount = event->GetInt( "amount" );
|
|
int iPlayer = event->GetInt( "entindex" );
|
|
CTFPlayer *pEventPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayer ) );
|
|
if ( pEventPlayer && !pEventPlayer->IsDormant() )
|
|
{
|
|
if ( pEventPlayer == C_TFPlayer::GetLocalTFPlayer() )
|
|
{
|
|
OnAccountValueChanged( 0, iAmount, account_delta_t::ACCOUNT_DELTA_HEALING );
|
|
}
|
|
else
|
|
{
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
bool bEnemySpy = !pLocalPlayer->InSameTeam( pEventPlayer ) && pEventPlayer->IsPlayerClass( TF_CLASS_SPY );
|
|
bool bSneakyEnemySpy = bEnemySpy && ( pEventPlayer->m_Shared.IsStealthed() || pLocalPlayer->m_Shared.IsSpyDisguisedAsMyTeam( pEventPlayer ) );
|
|
bool bShouldSpawnRedParticle = ( pEventPlayer->GetTeamNumber() == TF_TEAM_RED );
|
|
if ( bSneakyEnemySpy )
|
|
{
|
|
bShouldSpawnRedParticle = ( GetLocalPlayerTeam() == TF_TEAM_RED );
|
|
}
|
|
|
|
const char *pEffectName;
|
|
if ( iAmount < 0 )
|
|
{
|
|
pEffectName = bShouldSpawnRedParticle ? "healthlost_red" : "healthlost_blu";
|
|
}
|
|
else if ( iAmount >= 100 )
|
|
{
|
|
if ( pEventPlayer->IsMiniBoss() )
|
|
{
|
|
pEffectName = bShouldSpawnRedParticle ? "healthgained_red_giant" : "healthgained_blu_giant";
|
|
|
|
}
|
|
else
|
|
{
|
|
pEffectName = bShouldSpawnRedParticle ? "healthgained_red_large" : "healthgained_blu_large";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEffectName = bShouldSpawnRedParticle ? "healthgained_red" : "healthgained_blu";
|
|
}
|
|
|
|
pEventPlayer->ParticleProp()->Create( pEffectName, PATTACH_POINT, "head" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CHudElement::FireGameEvent( event );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ShouldDraw( void )
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer || !pPlayer->IsAlive() )
|
|
{
|
|
m_AccountDeltaItems.RemoveAll();
|
|
}
|
|
|
|
if ( !m_AccountDeltaItems.Count() )
|
|
return false;
|
|
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
|
|
return false;
|
|
|
|
if ( CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() )
|
|
return false;
|
|
|
|
if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
|
|
return false;
|
|
|
|
return CHudElement::ShouldDraw();
|
|
}
|
|
};
|
|
DECLARE_HUDELEMENT( CHealthAccountPanel );
|
|
|
|
class CScoreAccountPanel : public CAccountPanel, public CGameEventListener
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CScoreAccountPanel, CAccountPanel );
|
|
public:
|
|
CScoreAccountPanel( Panel *parent, const char *name )
|
|
: CAccountPanel( parent, name )
|
|
, m_nTeam( TF_TEAM_COUNT )
|
|
{}
|
|
|
|
virtual const char *GetResFileName( void ) { return "resource/UI/HudScoreAccount.res"; }
|
|
|
|
virtual void FireGameEvent( IGameEvent *event ) OVERRIDE
|
|
{
|
|
const char * pszEventName = event->GetName();
|
|
|
|
if ( Q_strcmp(pszEventName, m_pszEventName) == 0 )
|
|
{
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pLocalPlayer || !pLocalPlayer->IsAlive() )
|
|
return;
|
|
|
|
int nTeam = event->GetInt( "team" );
|
|
if ( m_nTeam != nTeam )
|
|
return;
|
|
|
|
const int nPoints = event->GetInt( "points" );
|
|
if ( !nPoints )
|
|
return;
|
|
|
|
account_delta_t* pNewAccount = OnAccountValueChanged( 0, nPoints, account_delta_t::ACCOUNT_DELTA_BONUS_POINTS );
|
|
if ( pNewAccount )
|
|
{
|
|
pNewAccount->m_bShadows = true;
|
|
pNewAccount->m_flBatchWindow = pNewAccount->m_flDieTime;
|
|
pNewAccount->m_nSourceID = (( nPoints > 0 ) ? 0 : 1 ) + (nTeam * 2);
|
|
|
|
if ( ( GetLocalPlayerTeam() == nTeam && nPoints > 0 ) || ( GetLocalPlayerTeam() != nTeam && nPoints < 0 ) )
|
|
{
|
|
pNewAccount->m_color = m_DeltaPositiveColor;
|
|
}
|
|
else
|
|
{
|
|
pNewAccount->m_color = m_DeltaNegativeColor;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ApplySettings( KeyValues *inResourceData )
|
|
{
|
|
BaseClass::ApplySettings( inResourceData );
|
|
|
|
Q_strncpy( m_pszEventName, inResourceData->GetString( "event" ), sizeof( m_pszEventName ) );
|
|
if ( m_pszEventName )
|
|
{
|
|
ListenForGameEvent( m_pszEventName );
|
|
}
|
|
|
|
const char *pszTeam = inResourceData->GetString( "team" );
|
|
if ( Q_stricmp( pszTeam, "red" ) == 0 )
|
|
{
|
|
m_nTeam = TF_TEAM_RED;
|
|
}
|
|
else
|
|
{
|
|
m_nTeam = TF_TEAM_BLUE;
|
|
}
|
|
}
|
|
|
|
private:
|
|
char m_pszEventName[32]; // max length of event names
|
|
int m_nTeam;
|
|
};
|
|
|
|
DECLARE_BUILD_FACTORY( CScoreAccountPanel );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CDamageAccountPanel : public CHudAccountPanel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CDamageAccountPanel, CHudAccountPanel );
|
|
public:
|
|
CDamageAccountPanel( const char *pElementName ) : CHudAccountPanel(pElementName)
|
|
{
|
|
ListenForGameEvent( "player_hurt" );
|
|
ListenForGameEvent( "npc_hurt" );
|
|
ListenForGameEvent( "player_healed" );
|
|
ListenForGameEvent( "player_bonuspoints" );
|
|
ListenForGameEvent( "building_healed" );
|
|
|
|
ResetDamageVars();
|
|
vgui::ivgui()->AddTickSignal( GetVPanel(), 100 );
|
|
}
|
|
|
|
virtual void OnTick( void );
|
|
virtual const char *GetResFileName( void ) { return "resource/UI/HudDamageAccount.res"; }
|
|
virtual void Paint( void );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ShouldDrawDPSMeter( void )
|
|
{
|
|
return hud_damagemeter.GetBool();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void DisplayDamageFeedback( CTFPlayer *pAttacker, CBaseCombatCharacter *pVictim, int iDamage, int iHealth, bool bIsCrit )
|
|
{
|
|
if ( iDamage <= 0 ) // zero value (invuln?)
|
|
return;
|
|
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pLocalPlayer || !pLocalPlayer->IsAlive() )
|
|
return;
|
|
|
|
if ( !pAttacker || !pVictim )
|
|
return;
|
|
|
|
// Show the attacker, or when healing the player that is
|
|
if ( ( pAttacker == pLocalPlayer ) ||
|
|
( pLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && ( pLocalPlayer->MedicGetHealTarget() == pAttacker ) ) )
|
|
{
|
|
bool bDeadRingerSpy = false;
|
|
C_TFPlayer *pVictimPlayer = ToTFPlayer( pVictim );
|
|
if ( pVictimPlayer )
|
|
{
|
|
// Player hurt self
|
|
if ( pAttacker == pVictimPlayer )
|
|
return;
|
|
|
|
// Don't show damage on stealthed and/or disguised enemy spies
|
|
if ( pVictimPlayer->IsPlayerClass( TF_CLASS_SPY ) && pVictimPlayer->GetTeamNumber() != pLocalPlayer->GetTeamNumber() )
|
|
{
|
|
CTFWeaponInvis *pWpn = (CTFWeaponInvis *)pVictimPlayer->Weapon_OwnsThisID( TF_WEAPON_INVIS );
|
|
if ( pWpn && pWpn->HasFeignDeath() )
|
|
{
|
|
if ( pVictimPlayer->m_Shared.IsFeignDeathReady() )
|
|
{
|
|
bDeadRingerSpy = true;
|
|
}
|
|
}
|
|
|
|
if ( !bDeadRingerSpy )
|
|
{
|
|
if ( pVictimPlayer->m_Shared.GetDisguiseTeam() == pLocalPlayer->GetTeamNumber() || pVictimPlayer->m_Shared.IsStealthed() )
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pAttacker == pLocalPlayer )
|
|
{
|
|
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "DamagedPlayer" );
|
|
|
|
bool bHitEnabled = ( tf_dingalingaling.GetBool() );
|
|
bool bLastHitEnabled = ( tf_dingalingaling_lasthit.GetBool() );
|
|
bool bLastHit = ( iHealth <= 0 ) || bDeadRingerSpy;
|
|
if ( bLastHitEnabled && bLastHit )
|
|
{
|
|
// Always allow the last hit sound
|
|
m_flLastDingTime = 0.f;
|
|
}
|
|
|
|
// Play hitbeeps
|
|
if ( ( bHitEnabled || bLastHitEnabled ) &&
|
|
( gpGlobals->curtime > ( m_flLastDingTime + tf_dingalingaling_repeat_delay.GetFloat() ) || tf_dingalingaling_repeat_delay.GetFloat() == 0.f ) )
|
|
{
|
|
m_flLastDingTime = gpGlobals->curtime;
|
|
|
|
CSoundParameters params;
|
|
CLocalPlayerFilter filter;
|
|
const char *pszSound = NULL;
|
|
const hitsound_params_t *pHitSound = NULL;
|
|
|
|
if ( bLastHit && bLastHitEnabled )
|
|
{
|
|
pszSound = g_LastHitSounds[tf_dingalingaling_last_effect.GetInt()].m_pszName;
|
|
pHitSound = &g_LastHitSounds[tf_dingalingaling_last_effect.GetInt()];
|
|
if ( pszSound && pHitSound && CBaseEntity::GetParametersForSound( pszSound, params, NULL ) )
|
|
{
|
|
EmitSound_t es( params );
|
|
es.m_nPitch = pHitSound->GetPitchFromDamage( iDamage, bLastHit );
|
|
es.m_flVolume = tf_dingaling_lasthit_volume.GetFloat();
|
|
pLocalPlayer->EmitSound( filter, pLocalPlayer->entindex(), es );
|
|
}
|
|
}
|
|
else if ( bHitEnabled )
|
|
{
|
|
pszSound = g_HitSounds[tf_dingalingaling_effect.GetInt()].m_pszName;
|
|
pHitSound = &g_HitSounds[tf_dingalingaling_effect.GetInt()];
|
|
if ( pszSound && pHitSound && CBaseEntity::GetParametersForSound( pszSound, params, NULL ) )
|
|
{
|
|
EmitSound_t es( params );
|
|
es.m_nPitch = pHitSound->GetPitchFromDamage( iDamage, false );
|
|
es.m_flVolume = tf_dingaling_volume.GetFloat();
|
|
pLocalPlayer->EmitSound( filter, pLocalPlayer->entindex(), es );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( hud_combattext.GetBool() )
|
|
{
|
|
// Ignore damage events on targets that we can't see, so it's not a cheat
|
|
trace_t tr;
|
|
UTIL_TraceLine( pVictim->WorldSpaceCenter(), MainViewOrigin(), MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
|
|
if ( tr.fraction >= 1.f )
|
|
{
|
|
account_delta_t *pNewAccount = OnAccountValueChanged( 0, -iDamage, account_delta_t::ACCOUNT_DELTA_DAMAGE );
|
|
if ( pNewAccount )
|
|
{
|
|
Vector vecPos = pVictim->GetAbsOrigin();
|
|
Vector vecDistance = vecPos - pLocalPlayer->GetAbsOrigin();
|
|
int nHeightoffset = RemapValClamped( vecDistance.LengthSqr(), 0.0f, (200.0f * 200.0f), 1, 16 );
|
|
vecPos.z += (VEC_HULL_MAX_SCALED( pVictim ).z + nHeightoffset);
|
|
pNewAccount->m_nX = vecPos.x;
|
|
pNewAccount->m_nXEnd = pNewAccount->m_nX;
|
|
pNewAccount->m_nY = vecPos.y;
|
|
pNewAccount->m_nHStart = vecPos.z;
|
|
pNewAccount->m_nHEnd = pNewAccount->m_nHStart + 32; // How many units to float up
|
|
pNewAccount->m_bWorldSpace = true;
|
|
pNewAccount->m_nSourceID = pVictim->entindex();
|
|
pNewAccount->m_flBatchWindow = hud_combattext_batching.GetBool() ? hud_combattext_batching_window.GetFloat() : 0.f;
|
|
pNewAccount->m_bLargeFont = bIsCrit;
|
|
// V_swprintf_safe( pNewAccount->m_wzText, L" (%d)", m_nQueuedDamageEvents );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_flLastDamageEventTime = gpGlobals->curtime;
|
|
|
|
// Damage meter tracking
|
|
if ( hud_damagemeter_period.GetFloat() > 0.f )
|
|
{
|
|
// Store events and average across a sliding window
|
|
DamageHistory_t damage = { (float)iDamage, m_flLastDamageEventTime };
|
|
m_DamageHistory.AddToTail( damage );
|
|
}
|
|
else
|
|
{
|
|
// Running tally until we hit the out-of-combat timer
|
|
if ( m_flFirstDamageEventTime == 0.f )
|
|
{
|
|
m_flFirstDamageEventTime = m_flLastDamageEventTime;
|
|
m_flDamagePerSecond = 0.f;
|
|
m_flDamageMeterTotal = 0.f;
|
|
}
|
|
|
|
m_flDamageMeterTotal += iDamage;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void FireGameEvent( IGameEvent *event )
|
|
{
|
|
if ( FStrEq( event->GetName(), "player_hurt" ) )
|
|
{
|
|
const int iDamage = event->GetInt( "damageamount" );
|
|
const int iHealth = event->GetInt( "health" );
|
|
|
|
const int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
|
|
C_TFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( iAttacker ) );
|
|
|
|
const int iVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
|
|
C_TFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( iVictim ) );
|
|
|
|
DisplayDamageFeedback( pAttacker, pVictim, iDamage, iHealth, event->GetBool( "crit", 0 ) );
|
|
}
|
|
else if ( FStrEq( event->GetName(), "npc_hurt" ) )
|
|
{
|
|
const int iDamage = event->GetInt( "damageamount" );
|
|
const int iHealth = event->GetInt( "health" );
|
|
|
|
const int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker_player" ) );
|
|
C_TFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( iAttacker ) );
|
|
|
|
C_BaseCombatCharacter *pVictim = (C_BaseCombatCharacter *)ClientEntityList().GetClientEntity( event->GetInt( "entindex" ) );
|
|
|
|
DisplayDamageFeedback( pAttacker, pVictim, iDamage, iHealth, event->GetBool( "crit", 0 ) );
|
|
}
|
|
else if ( FStrEq( event->GetName(), "player_healed" ) )
|
|
{
|
|
if ( hud_combattext.GetBool() && hud_combattext_healing.GetBool() )
|
|
{
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pLocalPlayer || !pLocalPlayer->IsAlive() )
|
|
return;
|
|
|
|
const int iHealer = engine->GetPlayerForUserID( event->GetInt( "healer" ) );
|
|
CBasePlayer *pHealer = UTIL_PlayerByIndex( iHealer );
|
|
if ( pHealer && pHealer == pLocalPlayer )
|
|
{
|
|
const int iPatient = engine->GetPlayerForUserID( event->GetInt( "patient" ) );
|
|
CBasePlayer *pPatient = UTIL_PlayerByIndex( iPatient );
|
|
|
|
if ( pPatient )
|
|
{
|
|
const int iHealedAmt = event->GetInt( "amount" );
|
|
|
|
account_delta_t *pNewAccount = OnAccountValueChanged( 0, iHealedAmt, account_delta_t::ACCOUNT_DELTA_HEALING );
|
|
if ( pNewAccount )
|
|
{
|
|
Vector vecPos = pPatient->GetAbsOrigin();
|
|
Vector vecDistance = vecPos - pLocalPlayer->GetAbsOrigin();
|
|
int nHeightoffset = RemapValClamped( vecDistance.LengthSqr(), 0.0f, (200.0f * 200.0f), 1, 16 );
|
|
vecPos.z += ( VEC_HULL_MAX_SCALED( pPatient ).z + nHeightoffset );
|
|
pNewAccount->m_nX = vecPos.x;
|
|
pNewAccount->m_nXEnd = pNewAccount->m_nX;
|
|
pNewAccount->m_nY = vecPos.y;
|
|
pNewAccount->m_nHStart = vecPos.z;
|
|
pNewAccount->m_nHEnd = pNewAccount->m_nHStart + 32; // Float 32 units up in worldspace
|
|
pNewAccount->m_bWorldSpace = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( event->GetName(), "player_bonuspoints" ) )
|
|
{
|
|
if ( hud_combattext.GetBool() )
|
|
{
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pLocalPlayer || !pLocalPlayer->IsAlive() )
|
|
return;
|
|
|
|
const int nPoints = ( event->GetInt( "points" ) / 10 );
|
|
if ( !nPoints )
|
|
return;
|
|
|
|
const int iPlayer = event->GetInt( "player_entindex" );
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayer );
|
|
if ( pPlayer && pPlayer == pLocalPlayer )
|
|
{
|
|
const int iSource = event->GetInt( "source_entindex" );
|
|
C_BaseEntity *pSource = ClientEntityList().GetBaseEntity( iSource );
|
|
if ( !pSource )
|
|
return;
|
|
|
|
account_delta_t *pNewAccount = OnAccountValueChanged( 0, nPoints, account_delta_t::ACCOUNT_DELTA_BONUS_POINTS );
|
|
if ( pNewAccount )
|
|
{
|
|
Vector vecPos = pSource->GetAbsOrigin();
|
|
Vector vecDistance = vecPos - pLocalPlayer->GetAbsOrigin();
|
|
int nHeightoffset = RemapValClamped( vecDistance.LengthSqr(), 0.0f, (200.0f * 200.0f), 1, 16 );
|
|
vecPos.z += ( pSource->IsPlayer() ) ? (VEC_HULL_MAX_SCALED( pSource->GetBaseAnimating() ).z + nHeightoffset) : 0;
|
|
pNewAccount->m_nX = vecPos.x;
|
|
pNewAccount->m_nXEnd = pNewAccount->m_nX;
|
|
pNewAccount->m_nY = vecPos.y;
|
|
pNewAccount->m_nHStart = vecPos.z;
|
|
pNewAccount->m_nHEnd = pNewAccount->m_nHStart + 16;
|
|
pNewAccount->m_bWorldSpace = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( event->GetName(), "building_healed" ) )
|
|
{
|
|
if ( !hud_combattext.GetBool() || !hud_combattext_healing.GetBool() )
|
|
return;
|
|
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pLocalPlayer || !pLocalPlayer->IsAlive() )
|
|
return;
|
|
|
|
CBaseEntity *pHealer = ClientEntityList().GetEnt( event->GetInt( "healer" ) );
|
|
if ( pHealer && pHealer == pLocalPlayer )
|
|
{
|
|
CBaseEntity *pBuilding = ClientEntityList().GetEnt( event->GetInt( "building" ) );
|
|
if ( !pBuilding )
|
|
return;
|
|
|
|
const int iHealedAmt = event->GetInt( "amount" );
|
|
|
|
account_delta_t *pNewAccount = OnAccountValueChanged( 0, iHealedAmt, account_delta_t::ACCOUNT_DELTA_HEALING );
|
|
if ( pNewAccount )
|
|
{
|
|
Vector vecPos = pBuilding->GetAbsOrigin();
|
|
Vector vecDistance = vecPos - pLocalPlayer->GetAbsOrigin();
|
|
int nHeightoffset = RemapValClamped( vecDistance.LengthSqr(), 0.0f, (200.0f * 200.0f), 1, 16 );
|
|
vecPos.z += ( 64 + nHeightoffset );
|
|
pNewAccount->m_nX = vecPos.x;
|
|
pNewAccount->m_nXEnd = pNewAccount->m_nX;
|
|
pNewAccount->m_nY = vecPos.y;
|
|
pNewAccount->m_nHStart = vecPos.z;
|
|
pNewAccount->m_nHEnd = pNewAccount->m_nHStart + 32; // Float 32 units up in worldspace
|
|
pNewAccount->m_bWorldSpace = true;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ShouldDraw( void )
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer || !pPlayer->IsAlive() )
|
|
{
|
|
m_AccountDeltaItems.RemoveAll();
|
|
}
|
|
|
|
if ( ShouldDrawDPSMeter() )
|
|
return true;
|
|
|
|
if ( !m_AccountDeltaItems.Count() )
|
|
return false;
|
|
|
|
return CHudElement::ShouldDraw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: called whenever a new level is starting
|
|
//-----------------------------------------------------------------------------
|
|
virtual void LevelInit( void ) OVERRIDE
|
|
{
|
|
ResetDamageVars();
|
|
|
|
BaseClass::LevelInit();
|
|
}
|
|
|
|
private:
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ResetDamageVars( void )
|
|
{
|
|
m_flFirstDamageEventTime = 0.f;
|
|
m_flLastDamageEventTime = 0.f;
|
|
m_flDamagePerSecond = 0.f;
|
|
m_flDamageMeterTotal = 0.f;
|
|
m_flLastDingTime = 0.f;
|
|
}
|
|
|
|
private:
|
|
|
|
// DamageMeter
|
|
float m_flFirstDamageEventTime;
|
|
float m_flLastDamageEventTime;
|
|
float m_flDamagePerSecond;
|
|
float m_flDamageMeterTotal;
|
|
struct DamageHistory_t
|
|
{
|
|
float flDamage;
|
|
float flDamageTime;
|
|
};
|
|
CUtlVector< DamageHistory_t > m_DamageHistory;
|
|
|
|
// Dings
|
|
float m_flLastDingTime;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDamageAccountPanel::OnTick( void )
|
|
{
|
|
if ( ShouldDrawDPSMeter() )
|
|
{
|
|
// We're out of combat - nuke everything
|
|
if ( m_flLastDamageEventTime < gpGlobals->curtime - hud_damagemeter_ooctimer.GetFloat() )
|
|
{
|
|
m_DamageHistory.RemoveAll();
|
|
m_flFirstDamageEventTime = 0.f;
|
|
}
|
|
else
|
|
{
|
|
float flPeriod = hud_damagemeter_period.GetFloat();
|
|
|
|
// Period-based calculation (averaged across a defined range)
|
|
if ( flPeriod > 0.f )
|
|
{
|
|
m_flDamageMeterTotal = 0.f;
|
|
|
|
FOR_EACH_VEC_BACK( m_DamageHistory, i )
|
|
{
|
|
if ( flPeriod > 0.f )
|
|
{
|
|
// This method averages across a fixed period, so nuke entires outside the period
|
|
if ( gpGlobals->curtime - flPeriod > m_DamageHistory[i].flDamageTime )
|
|
{
|
|
m_DamageHistory.Remove( i );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// What's left is within the period (sliding window)
|
|
m_flDamageMeterTotal += m_DamageHistory[i].flDamage;
|
|
}
|
|
|
|
m_flDamagePerSecond = m_flDamageMeterTotal / flPeriod;
|
|
}
|
|
// Event-based calculation (absolute dps)
|
|
else if ( m_flFirstDamageEventTime > 0.f )
|
|
{
|
|
flPeriod = Max( m_flLastDamageEventTime - m_flFirstDamageEventTime, 1.f );
|
|
m_flDamagePerSecond = m_flDamageMeterTotal / flPeriod;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDamageAccountPanel::Paint( void )
|
|
{
|
|
BaseClass::Paint();
|
|
|
|
if ( ShouldDrawDPSMeter() )
|
|
{
|
|
int iScreenWide, iScreenTall;
|
|
GetHudSize( iScreenWide, iScreenTall );
|
|
int nX = iScreenWide / 1.15;
|
|
int nY = iScreenTall / 1.20;
|
|
|
|
int r = 255, g = 255, b = 255;
|
|
if ( m_flLastDamageEventTime < gpGlobals->curtime - hud_damagemeter_ooctimer.GetFloat() )
|
|
{
|
|
r = 255, g = 0, b = 0;
|
|
}
|
|
Color cDPS( r, g, b, 255 );
|
|
|
|
vgui::surface()->DrawSetTextFont( m_hDeltaItemFontBig );
|
|
vgui::surface()->DrawSetTextColor( cDPS );
|
|
vgui::surface()->DrawSetTextPos( nX, nY );
|
|
|
|
wchar_t wDPSBuf[20];
|
|
V_swprintf_safe( wDPSBuf, L"%d DPS", (int)m_flDamagePerSecond );
|
|
vgui::surface()->DrawPrintText( wDPSBuf, wcslen( wDPSBuf ), FONT_DRAW_NONADDITIVE );
|
|
}
|
|
}
|
|
|
|
DECLARE_HUDELEMENT( CDamageAccountPanel );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAccountPanel::ApplySchemeSettings( IScheme *pScheme )
|
|
{
|
|
// load control settings...
|
|
LoadControlSettings( GetResFileName() );
|
|
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
}
|
|
|
|
void CAccountPanel::ApplySettings( KeyValues *inResourceData )
|
|
{
|
|
BaseClass::ApplySettings( inResourceData );
|
|
|
|
// Backwards compatibility. If we DONT find "delta_item_end_x" specified in the keyvalues,
|
|
// then just take the starting x-pos as the ending x-pos.
|
|
if ( inResourceData->FindKey( "delta_item_end_x" ) == NULL )
|
|
{
|
|
m_flDeltaItemXEndPos = m_flDeltaItemX;
|
|
}
|
|
|
|
m_bNegativeFlipDir = inResourceData->FindKey( "negative_flip_dir", false );
|
|
|
|
const char *pszBGTextureName = inResourceData->GetString( "bg_texture", NULL );
|
|
if ( m_nBGTexture == -1 && pszBGTextureName && pszBGTextureName[0] )
|
|
{
|
|
m_nBGTexture = vgui::surface()->CreateNewTextureID();
|
|
vgui::surface()->DrawSetTextureFile( m_nBGTexture , pszBGTextureName, true, false);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
account_delta_t *CAccountPanel::OnAccountValueChanged( int iOldValue, int iNewValue, account_delta_t::eAccountDeltaType_t type )
|
|
{
|
|
// update the account value
|
|
SetDialogVariable( "metal", iNewValue );
|
|
|
|
int iDelta = iNewValue - iOldValue;
|
|
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( iDelta != 0 && pPlayer && pPlayer->IsAlive() )
|
|
{
|
|
int index = m_AccountDeltaItems.AddToTail();
|
|
account_delta_t *pNewDeltaItem = &m_AccountDeltaItems[index];
|
|
|
|
pNewDeltaItem->m_flDieTime = gpGlobals->curtime + m_flDeltaLifetime;
|
|
pNewDeltaItem->m_iAmount = iDelta;
|
|
pNewDeltaItem->m_nX = m_flDeltaItemX;
|
|
pNewDeltaItem->m_nXEnd = m_flDeltaItemXEndPos;
|
|
pNewDeltaItem->m_nHStart = m_flDeltaItemStartPos;
|
|
pNewDeltaItem->m_nHEnd = m_flDeltaItemEndPos;
|
|
pNewDeltaItem->m_bWorldSpace = false;
|
|
pNewDeltaItem->m_nSourceID = -1;
|
|
pNewDeltaItem->m_flBatchWindow = 0.f;
|
|
pNewDeltaItem->m_bLargeFont = false;
|
|
pNewDeltaItem->m_eDataType = type;
|
|
pNewDeltaItem->m_wzText[0] = NULL;
|
|
pNewDeltaItem->m_color = GetColor( type );
|
|
pNewDeltaItem->m_bShadows = false;
|
|
return &m_AccountDeltaItems[index];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
Color CAccountPanel::GetColor( const account_delta_t::eAccountDeltaType_t& type )
|
|
{
|
|
if ( type == account_delta_t::ACCOUNT_DELTA_BONUS_POINTS )
|
|
{
|
|
return m_DeltaEventColor;
|
|
}
|
|
else if ( type == account_delta_t::ACCOUNT_DELTA_HEALING )
|
|
{
|
|
return m_DeltaPositiveColor;
|
|
}
|
|
else if ( type == account_delta_t::ACCOUNT_DELTA_DAMAGE )
|
|
{
|
|
return m_DeltaNegativeColor;
|
|
}
|
|
else if ( type == account_delta_t::ACCOUNT_DELTA_ROBOT_DESTRUCTION_POINT_BLUE )
|
|
{
|
|
return m_DeltaBlueRobotScoreColor;
|
|
}
|
|
else if ( type == account_delta_t::ACCOUNT_DELTA_ROBOT_DESTRUCTION_POINT_RED )
|
|
{
|
|
return m_DeltaRedRobotScoreColor;
|
|
}
|
|
|
|
return Color( 255, 255, 255, 255 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Paint the deltas
|
|
//-----------------------------------------------------------------------------
|
|
void CAccountPanel::Paint( void )
|
|
{
|
|
BaseClass::Paint();
|
|
|
|
FOR_EACH_VEC_BACK( m_AccountDeltaItems, i )
|
|
{
|
|
// Reduce lifetime when count grows too high
|
|
float flTimeMod = m_AccountDeltaItems.Count() > NUM_ACCOUNT_DELTA_ITEMS ? RemapValClamped( m_AccountDeltaItems.Count(), 10.f, 15.f, 0.5f, 1.5f ) : 0.f;
|
|
|
|
// update all the valid delta items
|
|
if ( ( m_AccountDeltaItems[i].m_flDieTime - flTimeMod ) > gpGlobals->curtime )
|
|
{
|
|
// position and alpha are determined from the lifetime
|
|
Color c = m_AccountDeltaItems[i].m_color;
|
|
|
|
float flLifetimePercent = ( m_flDeltaLifetime - ( m_AccountDeltaItems[i].m_flDieTime - gpGlobals->curtime ) ) / m_flDeltaLifetime;
|
|
// fade out after half our lifetime
|
|
int nAlpha = flLifetimePercent > 0.5 ? (int)( 255.0f * ( ( 0.5f - flLifetimePercent ) / 0.5f ) ) : 255;
|
|
c[3] = nAlpha;
|
|
|
|
|
|
|
|
// Some items want to be batched together as they're super frequent (i.e. damage events from a flamethrower, or minigun)
|
|
if ( m_AccountDeltaItems[i].m_flBatchWindow > 0.f && m_AccountDeltaItems[i].m_nSourceID != -1 && m_AccountDeltaItems.IsValidIndex( i - 1 ) )
|
|
{
|
|
// If next item is from the same source and too close, merge
|
|
float flDelay = m_AccountDeltaItems[i].m_flBatchWindow;
|
|
if ( m_AccountDeltaItems[i].m_flDieTime - m_AccountDeltaItems[i-1].m_flDieTime <= flDelay &&
|
|
m_AccountDeltaItems[i-1].m_nSourceID == m_AccountDeltaItems[i].m_nSourceID )
|
|
{
|
|
m_AccountDeltaItems[i].m_iAmount += m_AccountDeltaItems[i-1].m_iAmount;
|
|
m_AccountDeltaItems.Remove( i - 1 );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
float flHeight = m_AccountDeltaItems[i].m_nHEnd - m_AccountDeltaItems[i].m_nHStart;
|
|
float flWidth = m_AccountDeltaItems[i].m_nXEnd - m_AccountDeltaItems[i].m_nX;
|
|
|
|
// We can be told to go the opposite direction if we're negative
|
|
if ( m_bNegativeFlipDir && m_AccountDeltaItems[i].m_iAmount < 0 )
|
|
{
|
|
flHeight = -flHeight;
|
|
flWidth = -flWidth;
|
|
}
|
|
|
|
float flYPos = m_AccountDeltaItems[i].m_nHStart + ( flLifetimePercent * flHeight );
|
|
float flXPos = m_AccountDeltaItems[i].m_nX + ( flLifetimePercent * flWidth );
|
|
if ( m_AccountDeltaItems[i].m_bWorldSpace )
|
|
{
|
|
Vector vecWorld( m_AccountDeltaItems[i].m_nX, m_AccountDeltaItems[i].m_nY, flYPos );
|
|
int iX,iY;
|
|
if ( !GetVectorInHudSpace( vecWorld, iX, iY ) ) // Tested - NOT GetVectorInScreenSpace
|
|
continue;
|
|
|
|
flXPos = iX;
|
|
flYPos = iY;
|
|
}
|
|
|
|
// If we have a background texture, then draw it!
|
|
if ( m_nBGTexture != -1 )
|
|
{
|
|
vgui::surface()->DrawSetColor(255,255,255,nAlpha);
|
|
vgui::surface()->DrawSetTexture(m_nBGTexture);
|
|
vgui::surface()->DrawTexturedRect( flXPos + m_flBGImageX, flYPos + m_flBGImageY, flXPos + m_flBGImageX + m_flBGImageWide, flYPos + m_flBGImageY + m_flBGImageTall );
|
|
}
|
|
|
|
wchar_t wBuf[20];
|
|
|
|
if ( m_AccountDeltaItems[i].m_iAmount > 0 )
|
|
{
|
|
V_swprintf_safe( wBuf, L"+%d", m_AccountDeltaItems[i].m_iAmount );
|
|
}
|
|
else
|
|
{
|
|
V_swprintf_safe( wBuf, L"%d", m_AccountDeltaItems[i].m_iAmount );
|
|
}
|
|
|
|
// Append?
|
|
if ( m_AccountDeltaItems[i].m_wzText[0] )
|
|
{
|
|
wchar_t wAppend[8] = { 0 };
|
|
V_swprintf_safe( wAppend, L"%ls", m_AccountDeltaItems[i].m_wzText );
|
|
V_wcscat_safe( wBuf, wAppend );
|
|
}
|
|
|
|
|
|
if ( m_AccountDeltaItems[i].m_bLargeFont )
|
|
{
|
|
vgui::surface()->DrawSetTextFont( m_hDeltaItemFontBig );
|
|
}
|
|
else
|
|
{
|
|
vgui::surface()->DrawSetTextFont( m_hDeltaItemFont );
|
|
}
|
|
|
|
// If we're supposed to have shadows, then draw the text as black and offset a bit first.
|
|
// Things get ugly as we approach 0 alpha, so stop drawing the shadow a bit early.
|
|
if ( m_AccountDeltaItems[i].m_bShadows && c[3] > 10 )
|
|
{
|
|
vgui::surface()->DrawSetTextPos( (int)flXPos + XRES(1), (int)flYPos + YRES(1) );
|
|
vgui::surface()->DrawSetTextColor( COLOR_BLACK );
|
|
vgui::surface()->DrawPrintText( wBuf, wcslen(wBuf), FONT_DRAW_NONADDITIVE );
|
|
}
|
|
|
|
vgui::surface()->DrawSetTextPos( (int)flXPos, (int)flYPos );
|
|
vgui::surface()->DrawSetTextColor( c );
|
|
vgui::surface()->DrawPrintText( wBuf, wcslen(wBuf), FONT_DRAW_NONADDITIVE );
|
|
}
|
|
else
|
|
{
|
|
m_AccountDeltaItems.Remove( i );
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef STAGING_ONLY
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CBountyAccountPanel : public CHudAccountPanel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CBountyAccountPanel, CHudAccountPanel );
|
|
public:
|
|
CBountyAccountPanel( const char *pElementName ) : CHudAccountPanel( pElementName )
|
|
{
|
|
}
|
|
|
|
virtual const char *GetResFileName( void ) { return "resource/UI/HudDamageAccount.res"; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void Paint( void )
|
|
{
|
|
if ( TFGameRules() && ( !TFGameRules()->IsBountyMode() || TFGameRules()->IsMannVsMachineMode() ) )
|
|
return;
|
|
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
int iScreenWide, iScreenTall;
|
|
GetHudSize( iScreenWide, iScreenTall );
|
|
int nX = iScreenWide * 0.06f;
|
|
int nY = iScreenTall * 0.97f;
|
|
|
|
Color cDPS( 25, 255, 25, 255 );
|
|
vgui::surface()->DrawSetTextFont( m_hDeltaItemFontBig );
|
|
vgui::surface()->DrawSetTextColor( cDPS );
|
|
vgui::surface()->DrawSetTextPos( nX, nY );
|
|
|
|
m_nCurrency = pPlayer->GetCurrency();
|
|
wchar_t wCurrency[20];
|
|
V_swprintf_safe( wCurrency, L"$%d", m_nCurrency );
|
|
vgui::surface()->DrawPrintText( wCurrency, wcslen( wCurrency ), FONT_DRAW_NONADDITIVE );
|
|
|
|
if ( pPlayer->GetCurrency() != m_nCurrency )
|
|
{
|
|
pPlayer->EmitSound( "Credits.Updated" );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ShouldDraw( void )
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer || !pPlayer->IsAlive() )
|
|
return false;
|
|
|
|
if ( TFGameRules() && ( !TFGameRules()->IsBountyMode() || TFGameRules()->IsMannVsMachineMode() ) )
|
|
return false;
|
|
|
|
return CHudElement::ShouldDraw();
|
|
}
|
|
private:
|
|
|
|
int m_nCurrency;
|
|
};
|
|
|
|
DECLARE_HUDELEMENT( CBountyAccountPanel );
|
|
#endif // STAGING_ONLY
|