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

667 lines
19 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "dod_hud_freezepanel.h"
#include "vgui_controls/AnimationController.h"
#include "iclientmode.h"
#include "c_dod_player.h"
#include "c_dod_playerresource.h"
#include <vgui_controls/Label.h>
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include "fmtstr.h"
#include "dod_gamerules.h"
#include "view.h"
#include "ivieweffects.h"
#include "viewrender.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
DECLARE_HUDELEMENT_DEPTH( CDODFreezePanel, 1 );
#define CALLOUT_WIDE (XRES(100))
#define CALLOUT_TALL (XRES(50))
extern float g_flFreezeFlash;
ConVar cl_dod_freezecam( "cl_dod_freezecam", "1", FCVAR_ARCHIVE, "Client option to not show freeze camera on death" );
#define FREEZECAM_SCREENSHOT_STRING "is looking good!"
bool IsTakingAFreezecamScreenshot( void )
{
// Don't draw in freezecam, or when the game's not running
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
bool bInFreezeCam = ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM );
if ( bInFreezeCam == true && engine->IsTakingScreenshot() )
return true;
CDODFreezePanel *pPanel = GET_HUDELEMENT( CDODFreezePanel );
if ( pPanel )
{
if ( pPanel->IsHoldingAfterScreenShot() )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CDODFreezePanel::CDODFreezePanel( const char *pElementName )
: EditablePanel( NULL, "FreezePanel" ), CHudElement( pElementName )
{
vgui::Panel *pParent = g_pClientMode->GetViewport();
SetParent( pParent );
SetVisible( false );
SetScheme( "ClientScheme" );
m_iKillerIndex = 0;
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
m_iYBase = -1;
m_flShowCalloutsAt = 0;
m_iBasePanelOriginalX = -1;
m_iBasePanelOriginalY = -1;
RegisterForRenderGroup( "winpanel" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::Reset()
{
Hide();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::Init()
{
// listen for events
ListenForGameEvent( "show_freezepanel" );
ListenForGameEvent( "hide_freezepanel" );
ListenForGameEvent( "freezecam_started" );
ListenForGameEvent( "player_death" );
ListenForGameEvent( "dod_win_panel" );
Hide();
CHudElement::Init();
}
//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CDODFreezePanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "resource/UI/FreezePanel_Basic.res" );
m_pBasePanel = dynamic_cast<EditablePanel *>( FindChildByName("FreezePanelBase") );
Assert( m_pBasePanel );
if ( m_pBasePanel )
{
m_pFreezeLabel = dynamic_cast<Label *>( m_pBasePanel->FindChildByName("FreezeLabel") );
m_pFreezePanelBG = m_pBasePanel->FindChildByName( "FreezePanelBG" );
m_pNemesisSubPanel = dynamic_cast<EditablePanel *>( m_pBasePanel->FindChildByName( "NemesisSubPanel" ) );
m_pHealthStatus = dynamic_cast<CDoDHudHealth *>( m_pBasePanel->FindChildByName( "PlayerStatusHealth" ) );
m_pAvatar = dynamic_cast<CAvatarImagePanel *>( m_pBasePanel->FindChildByName("AvatarImage") );
if ( m_pAvatar )
{
m_pAvatar->SetShouldScaleImage( true );
m_pAvatar->SetShouldDrawFriendIcon( false );
}
}
m_pScreenshotPanel = dynamic_cast<EditablePanel *>( FindChildByName( "ScreenshotPanel" ) );
Assert( m_pScreenshotPanel );
// Move killer panels when the win panel is up
int xp,yp;
GetPos( xp, yp );
m_iYBase = yp;
int w, h;
m_pBasePanel->GetBounds( m_iBasePanelOriginalX, m_iBasePanelOriginalY, w, h );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::FireGameEvent( IGameEvent * event )
{
if ( !cl_dod_freezecam.GetBool() )
{
if ( IsVisible() )
{
Hide();
}
return;
}
const char *pEventName = event->GetName();
if ( Q_strcmp( "player_death", pEventName ) == 0 )
{
// see if the local player died
int iPlayerIndexVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pLocalPlayer && iPlayerIndexVictim == pLocalPlayer->entindex() )
{
// the local player is dead, see if this is a new nemesis or a revenge
if ( event->GetInt( "dominated" ) > 0 )
{
m_iShowNemesisPanel = SHOW_NEW_NEMESIS;
}
else if ( event->GetInt( "revenge" ) > 0 )
{
m_iShowNemesisPanel = SHOW_REVENGE;
}
else
{
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
}
}
}
else if ( Q_strcmp( "hide_freezepanel", pEventName ) == 0 )
{
Hide();
}
else if ( Q_strcmp( "freezecam_started", pEventName ) == 0 )
{
ShowCalloutsIn( 1.0 );
ShowSnapshotPanelIn( 1.0 );
}
else if ( Q_strcmp( "dod_win_panel", pEventName ) == 0 )
{
Hide();
}
else if ( Q_strcmp( "show_freezepanel", pEventName ) == 0 )
{
C_DOD_PlayerResource *tf_PR = dynamic_cast<C_DOD_PlayerResource *>(g_PR);
if ( !tf_PR )
{
m_pNemesisSubPanel->SetDialogVariable( "nemesisname", NULL );
return;
}
Show();
ShowSnapshotPanel( false );
m_bHoldingAfterScreenshot = false;
if ( m_iBasePanelOriginalX > -1 && m_iBasePanelOriginalY > -1 )
{
m_pBasePanel->SetPos( m_iBasePanelOriginalX, m_iBasePanelOriginalY );
}
// Get the entity who killed us
m_iKillerIndex = event->GetInt( "killer" );
C_BaseEntity *pKiller = ClientEntityList().GetBaseEntity( m_iKillerIndex );
int xp,yp;
GetPos( xp, yp );
SetPos( xp, m_iYBase );
bool bShowHealth = pKiller && pKiller->IsPlayer();
m_pHealthStatus->SetVisible( bShowHealth );
if ( bShowHealth )
{
m_pHealthStatus->SetHealthDelegatePlayer( ToDODPlayer(pKiller) );
}
if ( pKiller )
{
if ( pKiller->IsPlayer() )
{
C_DODPlayer *pVictim = C_DODPlayer::GetLocalDODPlayer();
C_DODPlayer *pDODKiller = ToDODPlayer( pKiller );
//If this was just a regular kill but this guy is our nemesis then just show it.
if ( pVictim && pDODKiller && pDODKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Nemesis_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Nemesis" );
}
}
else
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer" );
}
}
m_pBasePanel->SetDialogVariable( "killername", g_PR->GetPlayerName( m_iKillerIndex ) );
if ( m_pAvatar )
{
m_pAvatar->SetPlayer( (C_BasePlayer*)pKiller );
}
}
else if ( m_pFreezeLabel )
{
if ( !pKiller->IsAlive() )
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer_Dead" );
}
else
{
m_pFreezeLabel->SetText( "#FreezePanel_Killer" );
}
}
}
// see if we should show nemesis panel
const wchar_t *pchNemesisText = NULL;
switch ( m_iShowNemesisPanel )
{
case SHOW_NO_NEMESIS:
{
C_DODPlayer *pVictim = C_DODPlayer::GetLocalDODPlayer();
C_DODPlayer *pTFKiller = ToDODPlayer( pKiller );
//If this was just a regular kill but this guy is our nemesis then just show it.
if ( pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
pchNemesisText = g_pVGuiLocalize->Find( "#FreezePanel_FreezeNemesis" );
}
}
break;
case SHOW_NEW_NEMESIS:
{
C_DODPlayer *pVictim = C_DODPlayer::GetLocalDODPlayer();
C_DODPlayer *pTFKiller = ToDODPlayer( pKiller );
// check to see if killer is still the nemesis of victim; victim may have managed to kill him after victim's
// death by grenade or some such, extracting revenge and clearing nemesis condition
if ( pTFKiller && pTFKiller->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
pchNemesisText = g_pVGuiLocalize->Find( "#FreezePanel_NewNemesis" );
}
}
break;
case SHOW_REVENGE:
pchNemesisText = g_pVGuiLocalize->Find( "#FreezePanel_GotRevenge" );
break;
default:
Assert( false ); // invalid value
break;
}
m_pNemesisSubPanel->SetDialogVariable( "nemesisname", pchNemesisText );
ShowNemesisPanel( NULL != pchNemesisText );
m_iShowNemesisPanel = SHOW_NO_NEMESIS;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::ShowCalloutsIn( float flTime )
{
m_flShowCalloutsAt = gpGlobals->curtime + flTime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CDODFreezePanelCallout *CDODFreezePanel::TestAndAddCallout( Vector &origin, Vector &vMins, Vector &vMaxs, CUtlVector<Vector> *vecCalloutsTL,
CUtlVector<Vector> *vecCalloutsBR, Vector &vecFreezeTL, Vector &vecFreezeBR, Vector &vecStatTL, Vector &vecStatBR, int *iX, int *iY )
{
// This is the offset from the topleft of the callout to the arrow tip
const int iXOffset = XRES(25);
const int iYOffset = YRES(50);
//if ( engine->IsBoxInViewCluster( vMins + origin, vMaxs + origin) && !engine->CullBox( vMins + origin, vMaxs + origin ) )
{
if ( GetVectorInHudSpace( origin, *iX, *iY ) ) // TODO: GetVectorInHudSpace or GetVectorInScreenSpace?
{
*iX -= iXOffset;
*iY -= iYOffset;
int iRight = *iX + CALLOUT_WIDE;
int iBottom = *iY + CALLOUT_TALL;
if ( *iX > 0 && *iY > 0 && (iRight < ScreenWidth()) && (iBottom < (ScreenHeight()-YRES(40))) )
{
// Make sure it wouldn't be over the top of the freezepanel or statpanel
Vector vecCalloutTL( *iX, *iY, 0 );
Vector vecCalloutBR( iRight, iBottom, 1 );
if ( !QuickBoxIntersectTest( vecCalloutTL, vecCalloutBR, vecFreezeTL, vecFreezeBR ) &&
!QuickBoxIntersectTest( vecCalloutTL, vecCalloutBR, vecStatTL, vecStatBR ) )
{
// Make sure it doesn't intersect any other callouts
bool bClear = true;
for ( int iCall = 0; iCall < vecCalloutsTL->Count(); iCall++ )
{
if ( QuickBoxIntersectTest( vecCalloutTL, vecCalloutBR, vecCalloutsTL->Element(iCall), vecCalloutsBR->Element(iCall) ) )
{
bClear = false;
break;
}
}
if ( bClear )
{
// Verify that we have LOS to the gib
trace_t tr;
UTIL_TraceLine( origin, MainViewOrigin(), MASK_OPAQUE, NULL, COLLISION_GROUP_NONE, &tr );
bClear = ( tr.fraction >= 1.0f );
}
if ( bClear )
{
CDODFreezePanelCallout *pCallout = new CDODFreezePanelCallout( g_pClientMode->GetViewport(), "FreezePanelCallout" );
m_pCalloutPanels.AddToTail( vgui::SETUP_PANEL(pCallout) );
vecCalloutsTL->AddToTail( vecCalloutTL );
vecCalloutsBR->AddToTail( vecCalloutBR );
pCallout->SetVisible( true );
pCallout->SetBounds( *iX, *iY, CALLOUT_WIDE, CALLOUT_TALL );
return pCallout;
}
}
}
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::UpdateCallout( void )
{
CDODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( !pPlayer )
return;
// Abort early if we have no ragdoll
IRagdoll *pRagdoll = pPlayer->GetRepresentativeRagdoll();
if ( !pRagdoll )
return;
if ( m_pFreezePanelBG == NULL )
return;
// Precalc the vectors of the freezepanel & statpanel
int iX, iY;
m_pFreezePanelBG->GetPos( iX, iY );
Vector vecFreezeTL( iX, iY, 0 );
Vector vecFreezeBR( iX + m_pFreezePanelBG->GetWide(), iY + m_pFreezePanelBG->GetTall(), 1 );
CUtlVector<Vector> vecCalloutsTL;
CUtlVector<Vector> vecCalloutsBR;
Vector vecStatTL(0,0,0);
Vector vecStatBR(0,0,1);
Vector vMins, vMaxs;
if ( pRagdoll )
{
Vector origin = pRagdoll->GetRagdollOrigin();
pRagdoll->GetRagdollBounds( vMins, vMaxs );
// Try and add the callout
//CDODFreezePanelCallout *pCallout =
TestAndAddCallout( origin, vMins, vMaxs, &vecCalloutsTL, &vecCalloutsBR,
vecFreezeTL, vecFreezeBR, vecStatTL, vecStatBR, &iX, &iY );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::Show()
{
m_flShowCalloutsAt = 0;
SetVisible( true );
int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "freezepanel" );
if ( iRenderGroup >= 0 )
{
gHUD.LockRenderGroup( iRenderGroup );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::Hide()
{
SetVisible( false );
m_bHoldingAfterScreenshot = false;
// Delete all our callout panels
for ( int i = m_pCalloutPanels.Count()-1; i >= 0; i-- )
{
m_pCalloutPanels[i]->MarkForDeletion();
}
m_pCalloutPanels.RemoveAll();
int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "winpanel" );
if ( iRenderGroup >= 0 )
{
gHUD.UnlockRenderGroup( iRenderGroup );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CDODFreezePanel::ShouldDraw( void )
{
if ( !CHudElement::ShouldDraw() )
return false;
return ( IsVisible() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::OnThink( void )
{
BaseClass::OnThink();
if ( m_flShowCalloutsAt && m_flShowCalloutsAt < gpGlobals->curtime )
{
if ( ShouldDraw() )
{
UpdateCallout();
}
m_flShowCalloutsAt = 0;
}
if ( m_flShowSnapshotReminderAt && m_flShowSnapshotReminderAt < gpGlobals->curtime )
{
if ( ShouldDraw() )
{
ShowSnapshotPanel( true );
}
m_flShowSnapshotReminderAt = 0;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::ShowSnapshotPanelIn( float flTime )
{
m_flShowSnapshotReminderAt = gpGlobals->curtime + flTime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDODFreezePanel::ShowSnapshotPanel( bool bShow )
{
if ( !m_pScreenshotPanel )
return;
const char *key = engine->Key_LookupBinding( "screenshot" );
if ( key == NULL || FStrEq( key, "(null)" ) )
{
bShow = false;
key = " ";
}
if ( bShow )
{
char szKey[16];
Q_snprintf( szKey, sizeof(szKey), "%s", key );
wchar_t wKey[16];
wchar_t wLabel[256];
g_pVGuiLocalize->ConvertANSIToUnicode(szKey, wKey, sizeof(wKey));
g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find("#TF_freezecam_snapshot" ), 1, wKey );
m_pScreenshotPanel->SetDialogVariable( "text", wLabel );
g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( this, "HudSnapShotReminderIn" );
}
m_pScreenshotPanel->SetVisible( bShow );
}
int CDODFreezePanel::HudElementKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
{
if ( ShouldDraw() && pszCurrentBinding )
{
if ( FStrEq( pszCurrentBinding, "screenshot" ) || FStrEq( pszCurrentBinding, "jpeg" ) )
{
// move the target id to the corner
if ( m_pBasePanel )
{
int w, h;
m_pBasePanel->GetSize( w, h );
m_pBasePanel->SetPos( ScreenWidth() - w, ScreenHeight() - h );
}
// Get the local player.
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( pPlayer )
{
//Do effects
g_flFreezeFlash = gpGlobals->curtime + 0.75f;
pPlayer->EmitSound( "Camera.SnapShot" );
//Extend Freezecam by a couple more seconds.
engine->ClientCmd( "extendfreeze" );
view->FreezeFrame( 3.0f );
//Hide the reminder panel
m_flShowSnapshotReminderAt = 0;
ShowSnapshotPanel( false );
m_bHoldingAfterScreenshot = true;
//Set the screenshot name
if ( m_iKillerIndex <= MAX_PLAYERS )
{
const char *pszKillerName = g_PR->GetPlayerName( m_iKillerIndex );
if ( pszKillerName )
{
ConVarRef cl_screenshotname( "cl_screenshotname" );
if ( cl_screenshotname.IsValid() )
{
char szScreenShotName[512];
Q_snprintf( szScreenShotName, sizeof( szScreenShotName ), "%s %s", pszKillerName, FREEZECAM_SCREENSHOT_STRING );
cl_screenshotname.SetValue( szScreenShotName );
}
}
}
}
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Shows or hides the nemesis part of the panel
//-----------------------------------------------------------------------------
void CDODFreezePanel::ShowNemesisPanel( bool bShow )
{
m_pNemesisSubPanel->SetVisible( bShow );
if ( bShow )
{
vgui::Label *pLabel = dynamic_cast< vgui::Label *>( m_pNemesisSubPanel->FindChildByName( "NemesisLabel" ) );
vgui::Panel *pBG = m_pNemesisSubPanel->FindChildByName( "NemesisPanelBG" );
vgui::ImagePanel *pIcon = dynamic_cast< vgui::ImagePanel *>( m_pNemesisSubPanel->FindChildByName( "NemesisIcon" ) );
// check that our Nemesis panel and resize it to the length of the string (the right side is pinned and doesn't move)
if ( pLabel && pBG && pIcon )
{
int wide, tall;
pLabel->GetContentSize( wide, tall );
int nDiff = wide - pLabel->GetWide();
if ( nDiff != 0 )
{
int x, y, w, t;
// move the icon
pIcon->GetBounds( x, y, w, t );
pIcon->SetBounds( x - nDiff, y, w, t );
// move/resize the label
pLabel->GetBounds( x, y, w, t );
pLabel->SetBounds( x - nDiff, y, w + nDiff, t );
// move/resize the background
pBG->GetBounds( x, y, w, t );
pBG->SetBounds( x - nDiff, y, w + nDiff, t );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CDODFreezePanelCallout::CDODFreezePanelCallout( Panel *parent, const char *name ) : EditablePanel(parent,name)
{
}
//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CDODFreezePanelCallout::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "resource/UI/FreezePanelCallout.res" );
}