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.
79 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 61302b61e7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '61302b61e7'
${ noResults }
source-engine/game/client/tf/tf_hud_saxxycontest.cpp

882 lines
24 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//=======================================================================================//
#include "cbase.h"
#ifdef SAXXYMAINMENU_ENABLED
#include "tf_hud_saxxycontest.h"
#include "econ_item_inventory.h"
#include "econ/confirm_dialog.h"
#include "econ/econ_controls.h"
#include "vgui/IVGui.h"
#include "vgui/ILocalize.h"
#include "vgui/IInput.h"
#include "vgui/ISurface.h"
#include "vgui_controls/TextEntry.h"
#include "vgui_controls/ComboBox.h"
#include "ienginevgui.h"
#include "replaybrowsermainpanel.h"
#include "gc_clientsystem.h"
#include "rtime.h"
#include "tf_gcmessages.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
DECLARE_BUILD_FACTORY( CSaxxyAwardsPanel );
static void SaxxyAwards_ShowSubmitForm();
//-----------------------------------------------------------------------------
int CSaxxyAwardsPanel::sm_nShowCounter = -1;
//-----------------------------------------------------------------------------
#define FOR_EACH_FLASH( i_ ) for ( int i_ = 0; i_ < MAX_FLASHES; ++i_ )
#define FOR_EACH_GLOW( i_ ) for ( int i_ = 0; i_ < MAX_GLOWS; ++i_ )
#define FOR_EACH_CLAP( i_ ) for ( int i_ = 0; i_ < MAX_CLAPS; ++i_ )
//-----------------------------------------------------------------------------
#define NUM_FLASH_SOUNDS 11
#define NUM_FLASH_MATERIALS 3
#define FREAKOUT_THRESHOLD 0.7f
//-----------------------------------------------------------------------------
inline float SCurve( float t )
{
t = clamp( t, 0.0f, 1.0f );
return t * t * (3 - 2*t);
}
inline float LerpScale( float flIn, float flInMin, float flInMax, float flOutMin, float flOutMax )
{
float flDenom = flInMax - flInMin;
if ( flDenom == 0.0f )
return 0.0f;
float t = clamp( ( flIn - flInMin ) / flDenom, 0.0f, 1.0f );
return Lerp( t, flOutMin, flOutMax );
}
//-----------------------------------------------------------------------------
CSaxxyAwardsPanel::CSaxxyAwardsPanel( Panel *pParent, const char *pName )
: EditablePanel( pParent, pName ),
m_pCameraFlashKv( NULL )
{
ivgui()->AddTickSignal( GetVPanel(), 17 );
Init();
++sm_nShowCounter;
}
CSaxxyAwardsPanel::~CSaxxyAwardsPanel()
{
ivgui()->RemoveTickSignal( GetVPanel() );
}
void CSaxxyAwardsPanel::Init()
{
m_flShowTime = GetCurrentTime();
m_vDialogsParent = (VPANEL)-1;
m_nNumTargetFlashes = 0;
m_flLastTickTime = 0.0f;
m_flEarliestNextFlashTime = 0.0f;
m_flGlowFade = 0.0f;
m_flNextPanelTestTime = 0.0f;
m_pBackgroundPanel = NULL;
m_pSaxxyModelPanel = NULL;
m_pStageBgPanel = NULL;
m_pSubmitButton = NULL;
m_pInfoLabel = NULL;
m_pCurtainPanel = NULL;
m_pContestOverLabel = NULL;
m_pSpotlightPanel = NULL;
m_flCurtainStartAnimTime = -1.0f;
FOR_EACH_CLAP( i )
{
m_aClapPlayTimes[i] = 0.0f;
}
for ( int i = 0; i < 2; ++i )
{
m_aFilteredMousePos[i][0] = ScreenWidth() / 2;
m_aFilteredMousePos[i][1] = ScreenHeight() / 2;
}
FOR_EACH_FLASH( i )
{
CFmtStr fmtPanelName( "FlashPanel_%i", i );
FlashInfo_t *pCurFlashInfo = &m_aFlashes[ i ];
pCurFlashInfo->m_pPanel = new ImagePanel( NULL, fmtPanelName.Access() );
pCurFlashInfo->m_bInUse = false;
}
m_angModelRot.Init();
m_vSaxxyDefaultPos.Init();
}
void CSaxxyAwardsPanel::ApplySettings( KeyValues *pInResourceData )
{
BaseClass::ApplySettings( pInResourceData );
// Delete old KeyValues
if ( m_pCameraFlashKv )
{
m_pCameraFlashKv->deleteThis();
m_pCameraFlashKv = NULL;
}
// Copy camera flash keyvalues for creating instances
KeyValues *pCameraFlash = pInResourceData->FindKey( "CameraFlashSettings" );
Assert( pCameraFlash );
if ( pCameraFlash )
{
m_pCameraFlashKv = pCameraFlash->MakeCopy();
}
}
bool CSaxxyAwardsPanel::CreateFlash()
{
if ( GetActiveFlashCount() == MAX_FLASHES )
return false;
const int iUnusedSlot = GetUnusedFlashSlot(); Assert( iUnusedSlot >= 0 && iUnusedSlot < MAX_FLASHES );
if ( iUnusedSlot < 0 )
return false; // Should never happen, since GetActiveFlashCount() didn't return 0
FlashInfo_t *pFlashInfo = &m_aFlashes[ iUnusedSlot ];
ImagePanel *pPanel = pFlashInfo->m_pPanel;
// Apply base settings
if ( !m_pCameraFlashKv )
return false;
pPanel->ApplySettings( m_pCameraFlashKv );
// Set the image to a random image
const int iImage = 1 + rand() % NUM_FLASH_MATERIALS;
CFmtStr fmtImageName( "../models/effects/camera_flash/camera_flash_%02i", iImage );
pPanel->SetImage( fmtImageName.Access() );
pFlashInfo->m_flStartTime = GetCurrentTime();
pFlashInfo->m_flLifeLength = FRand( m_flFlashLifeLengthMin, m_flFlashLifeLengthMax );
pFlashInfo->m_bInUse = true;
// Put the flash at a random position in the "flash bounds"
pFlashInfo->m_nCenterX = (int)FRand( m_nFlashBoundsX, m_nFlashBoundsX + m_nFlashBoundsW );
pFlashInfo->m_nCenterY = (int)FRand( m_nFlashBoundsY, m_nFlashBoundsY + m_nFlashBoundsH );
pFlashInfo->m_nMinSize = (int)Lerp( FRand( 0.0f, 1.0f ), m_nFlashStartSizeMin, m_nFlashStartSizeMax );
pFlashInfo->m_nMaxSize = pFlashInfo->m_nMinSize * FRand( .5f * m_flFlashMaxScale, m_flFlashMaxScale );
Assert( pFlashInfo->m_nMaxSize > pFlashInfo->m_nMinSize );
pFlashInfo->m_nCurW = pFlashInfo->m_nMinSize;
pFlashInfo->m_nCurH = pFlashInfo->m_nMinSize;
PlaceFlash( pFlashInfo );
// Setup visibility
pPanel->SetAlpha( 0 );
pPanel->SetVisible( true );
// Play a random flash sound
int iSound = rand() % NUM_FLASH_SOUNDS + 1;
Assert( iSound >= 1 && iSound <= NUM_FLASH_SOUNDS );
CFmtStr fmtSoundFilename( "misc/tf_camera_%02i.wav", iSound );
surface()->PlaySound( fmtSoundFilename.Access() );
return true;
}
void CSaxxyAwardsPanel::PlaceFlash( FlashInfo_t *pFlashInfo )
{
pFlashInfo->m_pPanel->SetBounds(
pFlashInfo->m_nCenterX - pFlashInfo->m_nCurW / 2,
pFlashInfo->m_nCenterY - pFlashInfo->m_nCurH / 2,
pFlashInfo->m_nCurW,
pFlashInfo->m_nCurH
);
}
void CSaxxyAwardsPanel::ApplySchemeSettings( IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
LoadControlSettings( "resource/UI/MainMenu_SaxxyAwards.res" );
SetupContestPanels();
m_vDialogsParent = GetDialogsParent();
m_pBackgroundPanel = dynamic_cast< EditablePanel * >( FindChildByName( "Background" ) );
m_pSubmitButton = dynamic_cast< CExButton *>( FindChildByName( "SubmitButton" ) );
m_pInfoLabel = FindChildByName( "InfoLabel" );
m_pContestOverLabel = FindChildByName( "ContestOverLabel" );
m_pSpotlightPanel = dynamic_cast< ImagePanel * >( FindChildByName( "SpotlightPanel" ) );
m_pStageBgPanel = dynamic_cast< ImagePanel * >( FindChildByName( "StageBackground" ) );
m_pCurtainPanel = dynamic_cast< EditablePanel * >( FindChildByName( "CurtainsPanel" ) );
if ( m_pCurtainPanel )
{
m_Curtains[0].m_pPanel = dynamic_cast< ImagePanel * >( m_pCurtainPanel->FindChildByName( "CurtainsLeft" ) );
m_Curtains[1].m_pPanel = dynamic_cast< ImagePanel * >( m_pCurtainPanel->FindChildByName( "CurtainsRight" ) );
// Hide curtains if this isn't the first view
if ( sm_nShowCounter > 0 )
{
for ( int i = 0; i < 2; ++i )
{
if ( !m_Curtains[i].m_pPanel )
continue;
m_Curtains[i].m_pPanel->SetVisible( false );
}
}
// Set all flash parents to background panel
if ( m_pBackgroundPanel )
{
FOR_EACH_FLASH( i )
{
m_aFlashes[ i ].m_pPanel->SetParent( m_pStageBgPanel );
}
}
// Setup Saxxy model
m_pSaxxyModelPanel = dynamic_cast< CBaseModelPanel * >( m_pCurtainPanel->FindChildByName( "SaxxyModelPanel" ) );
if ( m_pSaxxyModelPanel )
{
MDLHandle_t hModel = mdlcache->FindMDL( "models/effects/saxxy_flash/saxxy_flash.mdl" );
m_pSaxxyModelPanel->SetMDL( hModel );
m_pSaxxyModelPanel->SetSequence( ACT_RESET );
mdlcache->Release( hModel ); // counterbalance addref from within FindMDL
m_pSaxxyModelPanel->InvalidateLayout( true, true ); // Updates player position
m_vSaxxyDefaultPos = m_pSaxxyModelPanel->GetPlayerPos();
}
}
}
void CSaxxyAwardsPanel::PerformLayout()
{
BaseClass::PerformLayout();
}
void CSaxxyAwardsPanel::Refresh()
{
Init();
InvalidateLayout( true, true );
}
void CSaxxyAwardsPanel::OnCommand( const char *pCommand )
{
if ( FStrEq( pCommand, "viewdetails" ) )
{
if ( steamapicontext && steamapicontext->SteamFriends() )
{
steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://www.teamfortress.com/saxxyawards/" );
}
}
else if ( FStrEq( pCommand, "submit" ) )
{
SaxxyAwards_ShowSubmitForm();
}
else
{
BaseClass::OnCommand( pCommand );
}
}
void CSaxxyAwardsPanel::OnTick()
{
if ( C_BasePlayer::GetLocalPlayer() )
return;
if ( ReplayUI_GetBrowserPanel() && ReplayUI_GetBrowserPanel()->IsVisible() )
return;
if ( !IsVisible() )
return;
// Calculate elapsed
const float flCurTime = GetCurrentTime();
const float flElapsed = clamp( flCurTime - m_flLastTickTime, 0, 0.1f );
m_flLastTickTime = flCurTime;
// Msg( "initial freakout? %s\n", InInitialFreakoutPeriod() ? "yes" : "no" );
const bool bOtherPanelsOpen = AreOtherPanelsOpen( flCurTime );
UpdateMousePos( flElapsed );
CurtainsThink();
RotateModel( flElapsed );
FlashThink( bOtherPanelsOpen );
SpotlightThink();
ClapsThink( flCurTime, flElapsed, bOtherPanelsOpen );
SetupContestPanels();
}
bool CSaxxyAwardsPanel::AreOtherPanelsOpen( float flCurTime )
{
static bool s_bOtherPanelsOpen = false;
if ( flCurTime < m_flNextPanelTestTime )
return s_bOtherPanelsOpen;
// Setup next think time
m_flNextPanelTestTime = flCurTime + 2.0f;
// Do tests to see if other panels are open
bool bOtherPanelsOpen = false;
{
const int nNumGameUICarePanels = 4;
const char *pCarePanels[nNumGameUICarePanels] = { "GameConsole", "character_info", "store_panel", "BugUIPanel" };
bOtherPanelsOpen = bOtherPanelsOpen || AreNonMainMenuPanelsOpen( enginevgui->GetPanel( PANEL_GAMEUIDLL ), pCarePanels, nNumGameUICarePanels );
}
// Msg( "-----\n" );
if ( m_vDialogsParent != (VPANEL)-1 )
{
const int nNumCarePanels = 2;
const char *pCarePanels[nNumCarePanels] = { "CServerBrowserDialog", "OptionsDialog" };
bOtherPanelsOpen = bOtherPanelsOpen || AreNonMainMenuPanelsOpen( m_vDialogsParent, pCarePanels, nNumCarePanels );
}
// Cache so we don't have to think every frame
s_bOtherPanelsOpen = bOtherPanelsOpen;
return bOtherPanelsOpen;
}
void CSaxxyAwardsPanel::PaintBackground()
{
BaseClass::PaintBackground();
}
void CSaxxyAwardsPanel::UpdateMousePos( float flElapsed )
{
// Set target mouse pos
int x, y;
input()->GetCursorPos( x, y );
m_aFilteredMousePos[1][0] = x;
m_aFilteredMousePos[1][1] = y;
// Move towards target
const float t = flElapsed * 1.5f;
m_aFilteredMousePos[0][0] = Lerp( t, m_aFilteredMousePos[0][0], m_aFilteredMousePos[1][0] );
m_aFilteredMousePos[0][1] = Lerp( t, m_aFilteredMousePos[0][1], m_aFilteredMousePos[1][1] );
// Msg( "mouse pos: current=(%f %f) target=(%f %f)\n", m_aFilteredMousePos[0][0], m_aFilteredMousePos[0][1],
// m_aFilteredMousePos[1][0], m_aFilteredMousePos[1][1] );
}
void CSaxxyAwardsPanel::CurtainsThink()
{
if ( !m_Curtains[0].m_pPanel || !m_Curtains[1].m_pPanel )
return;
// Has enough time passed? Only open the curtains m_flOpenCurtainsTime seconds after m_flShowTime.
const float flElapsedSinceShowTime = GetCurrentTime() - m_flShowTime;
if ( flElapsedSinceShowTime < m_flOpenCurtainsTime )
return;
// Start animating now?
if ( CurtainsClosed() )
{
m_flCurtainStartAnimTime = GetCurrentTime();
// Play crowd the first time the menu is shown
if ( sm_nShowCounter == 0 )
{
surface()->PlaySound( "misc/boring_applause_1.wav" );
}
// Init positions to those set in res file
for ( int i = 0; i < 2; ++i )
{
m_Curtains[i].m_pPanel->GetPos( m_Curtains[i].m_aInitialPos[0], m_Curtains[i].m_aInitialPos[1] );
}
}
else // Already animating?
{
// Set updated positions for both curtains
const float flCurTime = GetCurrentTime();
for ( int i = 0; i < 2; ++i )
{
CurtainInfo_t *pCurCurtain = &m_Curtains[i];
Panel *pPanel = pCurCurtain->m_pPanel;
const int nSign = i == 0 ? -1 : 1;
const float t = SCurve( clamp( ( flCurTime - m_flCurtainStartAnimTime ) / m_flCurtainAnimDuration, 0.0f, 1.0f ) );
int aCurPos[2] = {
Lerp( t, pCurCurtain->m_aInitialPos[0], pCurCurtain->m_aInitialPos[0] + nSign * pPanel->GetWide() ),
pCurCurtain->m_aInitialPos[1]
};
m_Curtains[i].m_pPanel->SetPos( aCurPos[0], aCurPos[1] );
}
}
}
void CSaxxyAwardsPanel::RotateModel( float flElapsed )
{
if ( m_pSaxxyModelPanel )
{
const float flOsc = .28f * sinf( .5f * GetCurrentTime() );
const Vector vCurPos(
Lerp( m_flGlowFade, m_vSaxxyDefaultPos.x, m_vSaxxyDefaultPos.x - 8.0f ),
m_vSaxxyDefaultPos.y,
Lerp( m_flGlowFade, m_vSaxxyDefaultPos.z, m_vSaxxyDefaultPos.z - 3.0f ) + flOsc
);
m_angModelRot.y += flElapsed * 45 * 0.5f * Lerp( m_flGlowFade, 0.5f, 1.0f );
m_pSaxxyModelPanel->SetModelAnglesAndPosition( m_angModelRot, vCurPos );
}
}
void CSaxxyAwardsPanel::FlashThink( bool bOtherPanelsOpen )
{
if ( !m_pSaxxyModelPanel )
return;
// Set the target number of flashes based on how far the mouse is from the saxxy
int aModelBounds[4];
m_pSaxxyModelPanel->GetSize( aModelBounds[2], aModelBounds[3] );
ipanel()->GetAbsPos( m_pSaxxyModelPanel->GetVPanel(), aModelBounds[0], aModelBounds[1] );
const float flDistX = aModelBounds[0] + aModelBounds[2]/2.0f - m_aFilteredMousePos[0][0];
const float flDistY = aModelBounds[1] + aModelBounds[3]/2.0f - m_aFilteredMousePos[0][1];
const float flDistanceToSaxxy = sqrtf( flDistX * flDistX + flDistY * flDistY );
// Msg( "xdist: %f ydist: %f distance: %f\n", flDistX, flDistY, flDistanceToSaxxy );
const float flMaxDistance = 750.0f;
m_flGlowFade = clamp( 1.0f - clamp( flDistanceToSaxxy / flMaxDistance, 0.0f, 1.0f ), 0.0f, 1.0f );
// Msg( "glow fade: %f\n", m_flGlowFade );
const float flCurTime = GetCurrentTime();
// Set alpha for active flashes, kill any that are done animating, update positions of actives
FOR_EACH_FLASH( i )
{
FlashInfo_t *pCurFlashInfo = &m_aFlashes[ i ];
if ( !pCurFlashInfo->m_bInUse )
continue;
const float t = ( flCurTime - pCurFlashInfo->m_flStartTime ) / pCurFlashInfo->m_flLifeLength;
if ( t >= 1.0f )
{
ClearFlash( pCurFlashInfo );
}
else
{
// Set opacity
const float flPhase = M_PI * t;
const float flFade = clamp( sinf( flPhase ), 0.0f, 1.0f );
pCurFlashInfo->m_pPanel->SetAlpha( 255 * flFade );
// Update size
pCurFlashInfo->m_nCurW = (int)Lerp( flFade, pCurFlashInfo->m_nMinSize, pCurFlashInfo->m_nMaxSize );
pCurFlashInfo->m_nCurH = pCurFlashInfo->m_nCurW;
// Update position/size
PlaceFlash( pCurFlashInfo );
}
}
// Create new flashes / freak out
const bool bEnoughTimeHasPassed = flCurTime >= m_flEarliestNextFlashTime;
if ( !bOtherPanelsOpen && bEnoughTimeHasPassed && FlashingStartTimePassed() && GetUnusedFlashCount() )
{
CreateFlash();
const bool bFreakout = InInitialFreakoutPeriod() || InFreakoutMode();
const float flOffset = bFreakout ? FRand( .1f, .2f ) : FRand( 2.0f, 5.0f );
m_flEarliestNextFlashTime = flCurTime + flOffset;
}
}
VPANEL CSaxxyAwardsPanel::GetDialogsParent()
{
VPANEL vGameUI = enginevgui->GetPanel( PANEL_GAMEUIDLL );
const int nNumChildren = ipanel()->GetChildCount( vGameUI );
for ( int i = 0; i < nNumChildren; ++i )
{
VPANEL vChild = ipanel()->GetChild( vGameUI, i );
const char *pDlgName = ipanel()->GetName( vChild );
if ( FStrEq( pDlgName, "BaseGameUIPanel" ) )
{
return vChild;
}
}
return (VPANEL)-1;
}
bool CSaxxyAwardsPanel::AreNonMainMenuPanelsOpen( VPANEL vRoot, const char **pCarePanels, int nNumCarePanels )
{
int nNumChildren = ipanel()->GetChildCount( vRoot );
for ( int i = 0; i < nNumChildren; ++i )
{
VPANEL vChild = ipanel()->GetChild( vRoot, i );
const char *pDlgName = ipanel()->GetName( vChild );
bool bCare = false;
for ( int j = 0; j < nNumCarePanels; ++j )
{
if ( FStrEq( pCarePanels[j], pDlgName ) )
{
// Msg( "CARE: %s\n", pDlgName );
bCare = true;
break;
}
}
if ( !bCare )
{
// Msg( "DONT CARE: %s\n", pDlgName );
continue;
}
if ( ipanel()->IsVisible( vChild ) )
return true;
}
return false;
}
void CSaxxyAwardsPanel::SpotlightThink()
{
if ( !m_pSpotlightPanel )
return;
const float flOscillateAmount = 0.10f;
const float flSpeed = 0.7f;
const float flFade = .1f + flOscillateAmount * ( .5f + .5f * cosf( flSpeed * GetCurrentTime() ) );
m_pSpotlightPanel->SetAlpha( 255 * flFade );
}
void CSaxxyAwardsPanel::PlaySomeClaps()
{
// Play each clap offset by a bit
const float flCurTime = GetCurrentTime();
FOR_EACH_CLAP( i )
{
// If this sound is already playing, continue
float &flCurClapPlayTime = m_aClapPlayTimes[i];
const bool bAlreadyPlaying = flCurClapPlayTime != 0.0f;
if ( bAlreadyPlaying )
continue;
// Some chance that not all claps will be played
if ( rand() % 100 < 30 )
{
SetNextPossibleClapTime( &flCurClapPlayTime );
continue;
}
flCurClapPlayTime = flCurTime + LerpScale( FRand( 0.0f, 1.0f ), 0.0f, 1.0f, .3f, 1.5f );
}
}
void CSaxxyAwardsPanel::ClapsThink( float flCurTime, float flElapsed, bool bOtherPanelsOpen )
{
if ( !bOtherPanelsOpen && InFreakoutMode() && !InInitialFreakoutPeriod() )
{
PlaySomeClaps();
}
FOR_EACH_CLAP( i )
{
float &flCurClapTime = m_aClapPlayTimes[i];
// Msg( "clap %i: %f\n", i, flCurClapTime );
if ( flCurClapTime < 0.0f )
{
// Once enough time has elapsed, this slot will be > 0 and available again.
flCurClapTime = MIN( flCurClapTime + flElapsed, 0.0f );
continue;
}
// Start playing now?
if ( flCurClapTime <= flCurTime && flCurClapTime != 0.0f )
{
// Play.
CFmtStr fmtSound( "misc/clap_single_%i.wav", i + 1 );
surface()->PlaySound( fmtSound.Access() );
SetNextPossibleClapTime( &flCurClapTime );
}
}
}
void CSaxxyAwardsPanel::SetNextPossibleClapTime( float *pClapTime )
{
// Set the next possible time to the duration of the sound + some randomn offset
const float flExtraOffset = LerpScale( FRand( 0.0f, 1.0f ), 0.0f, 1.0f, 1.0f, 5.0f );
*pClapTime = -( m_flClapSoundDuration + flExtraOffset );
}
void CSaxxyAwardsPanel::ClearFlash( FlashInfo_t *pFlashInfo )
{
pFlashInfo->m_bInUse = false;
pFlashInfo->m_pPanel->SetAlpha( 0 );
pFlashInfo->m_pPanel->SetVisible( false );
}
void CSaxxyAwardsPanel::ClearFlashes()
{
FOR_EACH_FLASH( i )
{
ClearFlash( &m_aFlashes[i] );
}
}
int CSaxxyAwardsPanel::GetActiveFlashCount() const
{
int nResult = 0;
FOR_EACH_FLASH( i )
{
if ( m_aFlashes[ i ].m_bInUse )
++nResult;
}
return nResult;
}
int CSaxxyAwardsPanel::GetUnusedFlashCount() const
{
return MAX_FLASHES - GetActiveFlashCount();
}
int CSaxxyAwardsPanel::GetUnusedFlashSlot() const
{
FOR_EACH_FLASH( i )
{
if ( !m_aFlashes[ i ].m_bInUse )
return i;
}
return -1;
}
float CSaxxyAwardsPanel::GetCurrentTime() const
{
return gpGlobals->curtime;
}
bool CSaxxyAwardsPanel::InInitialFreakoutPeriod() const
{
return ( GetCurrentTime() - m_flShowTime ) <= m_flInitialFreakoutDuration;
}
bool CSaxxyAwardsPanel::InFreakoutMode() const
{
return m_flGlowFade > FREAKOUT_THRESHOLD;
}
bool CSaxxyAwardsPanel::CurtainsClosed() const
{
return m_flCurtainStartAnimTime < 0.0f;
}
bool CSaxxyAwardsPanel::FlashingStartTimePassed() const
{
return ( GetCurrentTime() - m_flShowTime ) >= m_flFlashStartTime;
}
void CSaxxyAwardsPanel::SetupContestPanels()
{
CRTime now;
now.SetToCurrentTime();
now.SetToGMT( true );
CRTime deadline = CRTime::RTime32FromString( "2011-05-21 00:00:00" );
deadline.SetToGMT( true );
if ( now > deadline )
{
if ( m_pInfoLabel && m_pInfoLabel->IsVisible() )
{
m_pInfoLabel->SetVisible( false );
}
if ( m_pSubmitButton && m_pSubmitButton->IsVisible() )
{
m_pSubmitButton->SetVisible( false );
}
if ( m_pContestOverLabel && !m_pContestOverLabel->IsVisible() )
{
m_pContestOverLabel->SetVisible( true );
}
}
}
CSaxxyAwardsSubmitForm::CSaxxyAwardsSubmitForm( Panel *pParent )
: BaseClass( pParent, "SaxxySubmitForm" ),
m_pURLInput( NULL ),
m_pCategoryCombo( NULL )
{
}
void CSaxxyAwardsSubmitForm::ApplySchemeSettings( IScheme *pScheme )
{
// Link in TF scheme
extern IEngineVGui *enginevgui;
vgui::HScheme pTFScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme" );
SetScheme( pTFScheme );
SetProportional( true );
BaseClass::ApplySchemeSettings( vgui::scheme()->GetIScheme( pTFScheme ) );
LoadControlSettings( "resource/UI/SaxxyAwards_SubmitForm.res" );
m_pURLInput = dynamic_cast< TextEntry * >( FindChildByName( "URLInput" ) );
if ( m_pURLInput )
{
m_pURLInput->SetText( "#Replay_YouTubeURL" );
}
m_pCategoryCombo = dynamic_cast< ComboBox * >( FindChildByName( "CategoryCombo" ) );
if ( m_pCategoryCombo )
{
// Add "Categories" text
const int nDefaultItemID = m_pCategoryCombo->AddItem( "#Replay_Category", NULL );
m_pCategoryCombo->ActivateItem( nDefaultItemID );
// Add all categories
const wchar_t *pCategoryText = L"";
int i = 0;
while ( true )
{
CFmtStr fmtCategoryToken( "#Replay_Contest_Category%i", i++ );
pCategoryText = g_pVGuiLocalize->Find( fmtCategoryToken.Access() );
if ( !pCategoryText || !pCategoryText[0] )
break;
m_pCategoryCombo->AddItem( pCategoryText, NULL );
}
m_pCategoryCombo->SetNumberOfEditLines( i );
}
}
void CSaxxyAwardsSubmitForm::PerformLayout()
{
BaseClass::PerformLayout();
}
void CSaxxyAwardsSubmitForm::OnCommand( const char *pCommand )
{
if ( FStrEq( pCommand, "submit" ) )
{
// need a category
if ( m_pCategoryCombo->GetActiveItem() == 0 )
{
ShowMessageBox( "#Replay_Contest_StatusTitle", "#Replay_Contest_ChooseCategory", "#GameUI_OK" );
return;
}
// need a non-empty string
char szText[256];
m_pURLInput->GetText( szText, sizeof( szText ) );
if ( Q_strlen( szText ) == 0 )
{
ShowMessageBox( "#Replay_Contest_StatusTitle", "#Replay_Contest_EnterURL", "#GameUI_OK" );
return;
}
// waiting dialog
ShowWaitingDialog( new CGenericWaitingDialog( this ), "#Replay_Contest_Waiting", true, true, 30.0f );
// send the url
GCSDK::CProtoBufMsg< CMsgReplaySubmitContestEntry > msg( k_EMsgGCReplay_SubmitContestEntry );
msg.Body().set_youtube_url( szText );
msg.Body().set_category( m_pCategoryCombo->GetActiveItem() - 1 );
GCClientSystem()->GetGCClient()->BSendMessage( msg );
// close the submit dialog
Close();
}
else if ( FStrEq( pCommand, "cancel" ) )
{
Close();
}
else if ( FStrEq( pCommand, "rules" ) )
{
if ( steamapicontext && steamapicontext->SteamFriends() )
{
steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( "http://www.teamfortress.com/saxxyawards/#rules" );
}
}
else
{
BaseClass::OnCommand( pCommand );
}
}
void CSaxxyAwardsSubmitForm::Close()
{
TFModalStack()->PopModal( this );
MarkForDeletion();
}
void CSaxxyAwardsSubmitForm::OnKeyCodeTyped( vgui::KeyCode nCode )
{
if ( nCode == KEY_ESCAPE )
{
Close();
}
else
{
BaseClass::OnKeyCodeTyped( nCode );
}
}
static void SaxxyAwards_ShowSubmitForm()
{
CSaxxyAwardsSubmitForm *pSubmitDialog = vgui::SETUP_PANEL( new CSaxxyAwardsSubmitForm( NULL ) );
pSubmitDialog->SetVisible( true );
pSubmitDialog->MakePopup();
pSubmitDialog->MoveToFront();
pSubmitDialog->SetKeyBoardInputEnabled( true );
pSubmitDialog->SetMouseInputEnabled( true );
TFModalStack()->PushModal( pSubmitDialog );
}
//-----------------------------------------------------------------------------
// Purpose: Refresh the saxxy awards portion of the main menu
//-----------------------------------------------------------------------------
class CGC_Replay_SubmitContestEntryResponse_Status : public GCSDK::CGCClientJob
{
public:
CGC_Replay_SubmitContestEntryResponse_Status( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg< CMsgReplaySubmitContestEntryResponse > msg( pNetPacket );
CloseWaitingDialog();
if ( msg.Body().success() )
{
ShowMessageBox( "#Replay_Contest_StatusTitle", "#Replay_Contest_StatusSuccess", "#GameUI_OK" );
}
else
{
ShowMessageBox( "#Replay_Contest_StatusTitle", "#Replay_Contest_StatusFailure", "#GameUI_OK" );
}
return true;
}
protected:
};
GC_REG_JOB( GCSDK::CGCClient, CGC_Replay_SubmitContestEntryResponse_Status, "CGC_Replay_SubmitContestEntryResponse_Status", k_EMsgGCReplay_SubmitContestEntryResponse, GCSDK::k_EServerTypeGCClient );
#endif // #ifdef SAXXYMAINMENU_ENABLED