882 lines
24 KiB
C++
882 lines
24 KiB
C++
//========= 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
|