2302 lines
68 KiB
C++
2302 lines
68 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// The copyright to the contents herein is the property of Valve, L.L.C.
|
|
// The contents may be used and/or copied only with the written permission of
|
|
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
|
// the agreement/contract under which the contents have been supplied.
|
|
//
|
|
// $Header: $
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================
|
|
#include "cbase.h"
|
|
#include "hud.h"
|
|
#include "clientmode_tf.h"
|
|
#include "cdll_client_int.h"
|
|
#include "iinput.h"
|
|
#include "iviewrender.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "vgui/IPanel.h"
|
|
#include "GameUI/IGameUI.h"
|
|
#include <vgui_controls/AnimationController.h>
|
|
#include "ivmodemanager.h"
|
|
#include "buymenu.h"
|
|
#include "filesystem.h"
|
|
#include "vgui/IVGui.h"
|
|
#include "hud_chat.h"
|
|
#include "view_shared.h"
|
|
#include "view.h"
|
|
#include "ivrenderview.h"
|
|
#include "model_types.h"
|
|
#include "iefx.h"
|
|
#include "dlight.h"
|
|
#include <imapoverview.h>
|
|
#include "c_playerresource.h"
|
|
#include <KeyValues.h>
|
|
#include "text_message.h"
|
|
#include "panelmetaclassmgr.h"
|
|
#include "c_tf_player.h"
|
|
#include "ienginevgui.h"
|
|
#include "in_buttons.h"
|
|
#include "voice_status.h"
|
|
#include "tf_gamerules.h"
|
|
#include "tf_hud_menu_engy_build.h"
|
|
#include "tf_hud_menu_engy_destroy.h"
|
|
#include "tf_hud_menu_spy_disguise.h"
|
|
#include "tf_statsummary.h"
|
|
#include "tf_hud_freezepanel.h"
|
|
#include "item_quickswitch.h"
|
|
#include "hud_macros.h"
|
|
#include "vgui/ILocalize.h"
|
|
#include "glow_outline_effect.h"
|
|
#include "vgui/IInput.h"
|
|
#include "tf_hud_mainmenuoverride.h"
|
|
#include "tf_controls.h"
|
|
#include "econ_notifications.h"
|
|
#include "rtime.h"
|
|
#include "econ_item_description.h"
|
|
#include "c_tf_playerresource.h"
|
|
#include "c_team.h"
|
|
#include "tf_hud_menu_eureka_teleport.h"
|
|
#include "tf_hud_menu_taunt_selection.h"
|
|
#include "tf_hud_inspectpanel.h"
|
|
#include "engine/IEngineSound.h"
|
|
#ifdef STAGING_ONLY
|
|
#include "tf_hud_menu_spy_build.h"
|
|
#endif // STAGING_ONLY
|
|
|
|
#include "quest_objective_manager.h"
|
|
#include "econ_item_system.h"
|
|
#include "tf_mann_vs_machine_stats.h"
|
|
#include "tf_hud_mann_vs_machine_status.h"
|
|
#include "player_vs_environment/c_tf_upgrades.h"
|
|
|
|
#include "steam/isteamfriends.h"
|
|
#include "steamworks_gamestats.h"
|
|
#include "confirm_dialog.h"
|
|
#include "ServerBrowser/blacklisted_server_manager.h"
|
|
#include "tf_quickplay_shared.h"
|
|
#include "sourcevr/isourcevirtualreality.h"
|
|
#include "client_virtualreality.h"
|
|
|
|
#include "econ_gcmessages.h"
|
|
|
|
#if defined( _X360 )
|
|
#include "tf_clientscoreboard.h"
|
|
#endif
|
|
|
|
#include "gc_clientsystem.h"
|
|
#include "tf_gcmessages.h"
|
|
#include "tf_gc_client.h"
|
|
|
|
#include "tf_wardata.h"
|
|
|
|
#include "debugoverlay_shared.h"
|
|
|
|
#include "hud_vote.h"
|
|
#include "c_tf_notification.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
void __MsgFunc_AutoBalanceVolunteer( bf_read &msg );
|
|
void __MsgFunc_AutoBalanceVolunteer_Cancel( bf_read &msg );
|
|
void __MsgFunc_PlayerIgnitedInv( bf_read &msg );
|
|
void __MsgFunc_PlayerIgnited( bf_read &msg );
|
|
void __MsgFunc_Damage( bf_read &msg );
|
|
void __MsgFunc_HudArenaNotify( bf_read &msg );
|
|
void __MsgFunc_UpdateAchievement( bf_read &msg );
|
|
void __MsgFunc_DamageDodged( bf_read &msg );
|
|
void __MsgFunc_PlayerJarated( bf_read &msg );
|
|
void __MsgFunc_PlayerExtinguished( bf_read &msg );
|
|
void __MsgFunc_BreakModel( bf_read &msg );
|
|
void __MsgFunc_BreakModel_Pumpkin( bf_read &msg );
|
|
void __MsgFunc_BreakModelRocketDud( bf_read &msg );
|
|
void __MsgFunc_CheapBreakModel( bf_read &msg );
|
|
void __MsgFunc_PlayerJaratedFade( bf_read &msg );
|
|
void __MsgFunc_PlayerShieldBlocked( bf_read &msg );
|
|
void __MsgFunc_PlayerBonusPoints( bf_read &msg );
|
|
void __MsgFunc_SpawnFlyingBird( bf_read &msg );
|
|
void __MsgFunc_PlayerGodRayEffect( bf_read &msg );
|
|
void __MsgFunc_PlayerTeleportHomeEffect( bf_read &msg );
|
|
void __MsgFunc_RDTeamPointsChanged( bf_read &msg );
|
|
void __MsgFunc_PlayerLoadoutUpdated( bf_read &msg );
|
|
void __MsgFunc_PlayerTauntSoundLoopStart( bf_read &msg );
|
|
void __MsgFunc_PlayerTauntSoundLoopEnd( bf_read &msg );
|
|
void __MsgFunc_ForcePlayerViewAngles( bf_read &msg );
|
|
void __MsgFunc_BonusDucks( bf_read &msg );
|
|
void __MsgFunc_PlayerPickupWeapon( bf_read &msg );
|
|
void __MsgFunc_QuestObjectiveCompleted( bf_read &msg );
|
|
|
|
#if !defined(NO_STEAM)
|
|
extern ConVar cl_steamscreenshots;
|
|
#endif
|
|
|
|
extern ISoundEmitterSystemBase *soundemitterbase;
|
|
|
|
static Color colorEyeballBossText( 134, 80, 172, 255 );
|
|
static Color colorMerasmusText( 112, 176, 74, 255 );
|
|
|
|
ConVar default_fov( "default_fov", "75", FCVAR_CHEAT );
|
|
ConVar fov_desired( "fov_desired", "75", FCVAR_ARCHIVE | FCVAR_USERINFO, "Sets the base field-of-view.", true, 20.0, true, MAX_FOV );
|
|
|
|
#define TF_HIGHFIVE_HINT_MAXDIST 512.0f
|
|
#define TF_HIGHFIVE_HINT_MAXHINTS 3
|
|
#define TF_HIGHFIVE_HINT_MINTIMEBETWEEN 10.0f
|
|
ConVar tf_highfive_hintcount( "tf_highfive_hintcount", "0", FCVAR_CLIENTDLL | FCVAR_DONTRECORD | FCVAR_ARCHIVE, "Counts the number of times the high five hint has been displayed", true, 0, false, 0 );
|
|
|
|
ConVar tf_taunt_always_show_hint( "tf_taunt_always_show_hint", "1", FCVAR_CLIENTDLL );
|
|
extern ConVar tf_allow_all_team_partner_taunt;
|
|
extern ConVar tf_mvm_buybacks_method;
|
|
extern ConVar tf_autobalance_query_lifetime;
|
|
extern ConVar tf_autobalance_xp_bonus;
|
|
extern ConVar cl_notifications_show_ingame;
|
|
|
|
extern ConVar sc_look_sensitivity_scale;
|
|
|
|
extern bool TournamentHudElementKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
|
|
extern bool ArenaClassLayoutKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
|
|
extern bool CoachingHandlesKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
|
|
extern bool ItemTestHandlesKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
|
|
extern bool ShouldScoreBoardHandleKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
|
|
|
|
static bool TrainingHandlesKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
|
|
{
|
|
if ( TFGameRules() != NULL && TFGameRules()->IsInTraining() && TFGameRules()->IsWaitingForTrainingContinue() )
|
|
{
|
|
if ( down && keynum == KEY_SPACE )
|
|
{
|
|
engine->ClientCmd_Unrestricted( "training_continue" );
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
static bool HalloweenHandlesKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
|
|
{
|
|
C_TFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( pPlayer )
|
|
{
|
|
// don't do anything while dancing
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// only allow +attack
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
|
|
{
|
|
if ( pszCurrentBinding )
|
|
{
|
|
if ( FStrEq( pszCurrentBinding, "+attack" ) )
|
|
{
|
|
engine->ServerCmd( "boo" );
|
|
return true;
|
|
}
|
|
else if ( FStrEq( pszCurrentBinding, "+attack2" ) || FStrEq( pszCurrentBinding, "+attack3" ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
static bool TauntHandlesKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
|
|
{
|
|
static const char *pszStopTauntKeys[] =
|
|
{
|
|
"+jump",
|
|
"+taunt",
|
|
"weapon_taunt",
|
|
};
|
|
|
|
C_TFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( pPlayer )
|
|
{
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
|
|
{
|
|
for ( int i=0; i<ARRAYSIZE( pszStopTauntKeys ); ++i )
|
|
{
|
|
if ( down && pszCurrentBinding && FStrEq( pszCurrentBinding, pszStopTauntKeys[i] ) )
|
|
{
|
|
// Halloween Hackery
|
|
if ( i == 0 && pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
engine->ClientCmd( "stop_taunt" );
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Sets convars to tag the current mapname and the player in your crosshairs.
|
|
// The player tagged will be overridden for killcam shots to be the killer
|
|
static void ScreenshotTaggingKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
|
|
{
|
|
if ( pszCurrentBinding && ( FStrEq( pszCurrentBinding, "screenshot" ) || FStrEq( pszCurrentBinding, "jpeg" ) ) )
|
|
{
|
|
// Tag the player in the crosshairs
|
|
C_TFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( pPlayer )
|
|
{
|
|
C_TFPlayer *pCrosshairs = ToTFPlayer( UTIL_PlayerByIndex( pPlayer->GetIDTarget() ) );
|
|
if ( pCrosshairs )
|
|
{
|
|
CSteamID steamID;
|
|
if ( pCrosshairs->GetSteamID( &steamID ) )
|
|
{
|
|
ConVarRef cl_screenshotusertag( "cl_screenshotusertag" );
|
|
if ( cl_screenshotusertag.IsValid() )
|
|
{
|
|
cl_screenshotusertag.SetValue( (int)steamID.GetAccountID() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tag the current map
|
|
ConVarRef cl_screenshotlocation( "cl_screenshotlocation" );
|
|
if ( cl_screenshotlocation.IsValid() )
|
|
{
|
|
char szMapName[MAX_MAP_NAME];
|
|
Q_FileBase( engine->GetLevelName(), szMapName, sizeof(szMapName) );
|
|
Q_strlower( szMapName );
|
|
cl_screenshotlocation.SetValue( GetMapDisplayName( szMapName ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void EnableSteamScreenshots( bool bEnable )
|
|
{
|
|
#if !defined(NO_STEAM)
|
|
if ( steamapicontext && steamapicontext->SteamScreenshots() )
|
|
{
|
|
ConVarRef cl_savescreenshotstosteam( "cl_savescreenshotstosteam" );
|
|
if ( cl_savescreenshotstosteam.IsValid() )
|
|
{
|
|
cl_savescreenshotstosteam.SetValue( bEnable );
|
|
steamapicontext->SteamScreenshots()->HookScreenshots( bEnable );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !defined(NO_STEAM)
|
|
void SteamScreenshotsCallBack( IConVar *var, const char *pOldString, float flOldValue )
|
|
{
|
|
EnableSteamScreenshots( cl_steamscreenshots.GetBool() );
|
|
}
|
|
ConVar cl_steamscreenshots( "cl_steamscreenshots", "1", FCVAR_ARCHIVE, "Enable/disable saving screenshots to Steam", SteamScreenshotsCallBack );
|
|
#endif
|
|
|
|
|
|
void HUDMinModeChangedCallBack( IConVar *var, const char *pOldString, float flOldValue )
|
|
{
|
|
engine->ExecuteClientCmd( "hud_reloadscheme" );
|
|
}
|
|
ConVar cl_hud_minmode( "cl_hud_minmode", "0", FCVAR_ARCHIVE, "Set to 1 to turn on the advanced minimalist HUD mode.", HUDMinModeChangedCallBack );
|
|
|
|
IClientMode *g_pClientMode = NULL;
|
|
|
|
// --------------------------------------------------------------------------------- //
|
|
// CTFModeManager.
|
|
// --------------------------------------------------------------------------------- //
|
|
|
|
class CTFModeManager : public IVModeManager
|
|
{
|
|
public:
|
|
virtual void Init();
|
|
virtual void SwitchMode( bool commander, bool force ) {}
|
|
virtual void LevelInit( const char *newmap );
|
|
virtual void LevelShutdown( void );
|
|
virtual void ActivateMouse( bool isactive ) {}
|
|
};
|
|
|
|
static CTFModeManager g_ModeManager;
|
|
IVModeManager *modemanager = ( IVModeManager * )&g_ModeManager;
|
|
|
|
|
|
// --------------------------------------------------------------------------------- //
|
|
// CTFModeManager implementation.
|
|
// --------------------------------------------------------------------------------- //
|
|
|
|
#define SCREEN_FILE "scripts/vgui_screens.txt"
|
|
|
|
void CTFModeManager::Init()
|
|
{
|
|
g_pClientMode = GetClientModeNormal();
|
|
|
|
PanelMetaClassMgr()->LoadMetaClassDefinitionFile( SCREEN_FILE );
|
|
|
|
// Load the objects.txt file.
|
|
LoadObjectInfos( ::filesystem );
|
|
|
|
GetClientVoiceMgr()->SetHeadLabelOffset( 40 );
|
|
|
|
EnableSteamScreenshots( true );
|
|
}
|
|
|
|
void CTFModeManager::LevelInit( const char *newmap )
|
|
{
|
|
g_pClientMode->LevelInit( newmap );
|
|
|
|
ConVarRef voice_steal( "voice_steal" );
|
|
|
|
if ( voice_steal.IsValid() )
|
|
{
|
|
voice_steal.SetValue( 1 );
|
|
}
|
|
}
|
|
|
|
void CTFModeManager::LevelShutdown( void )
|
|
{
|
|
g_pClientMode->LevelShutdown();
|
|
|
|
extern void CL_Training_LevelShutdown();
|
|
extern void CL_Coaching_LevelShutdown();
|
|
extern void CL_Consumables_LevelShutdown();
|
|
extern void CL_Halloween_LevelShutdown();
|
|
CL_Training_LevelShutdown();
|
|
CL_Coaching_LevelShutdown();
|
|
CL_Consumables_LevelShutdown();
|
|
CL_Halloween_LevelShutdown();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
ClientModeTFNormal::ClientModeTFNormal()
|
|
{
|
|
m_pMenuEngyBuild = NULL;
|
|
m_pMenuEngyDestroy = NULL;
|
|
m_pMenuSpyDisguise = NULL;
|
|
m_pEurekaTeleportMenu = NULL;
|
|
m_pMenuTauntSelection = NULL;
|
|
#ifdef STAGING_ONLY
|
|
m_pMenuSpyBuild = NULL;
|
|
#endif // STAGING_ONLY
|
|
m_pGameUI = NULL;
|
|
m_pFreezePanel = NULL;
|
|
m_pQuickSwitch = NULL;
|
|
m_pInspectPanel = NULL;
|
|
m_wasConnectedLastUpdate = false;
|
|
m_lastServerIP = 0;
|
|
m_lastServerPort = 0;
|
|
m_lastServerName = NULL;
|
|
m_lastServerConnectTime = 0;
|
|
m_pTeamGoalTournament = NULL;
|
|
|
|
#if defined( _X360 )
|
|
m_pScoreboard = NULL;
|
|
#endif
|
|
|
|
HOOK_MESSAGE( AutoBalanceVolunteer );
|
|
HOOK_MESSAGE( AutoBalanceVolunteer_Cancel );
|
|
|
|
// Hook global message handlers
|
|
HOOK_MESSAGE( PlayerIgnited );
|
|
HOOK_MESSAGE( PlayerIgnitedInv );
|
|
HOOK_MESSAGE( Damage );
|
|
HOOK_MESSAGE( HudArenaNotify );
|
|
HOOK_MESSAGE( UpdateAchievement );
|
|
HOOK_MESSAGE( DamageDodged );
|
|
HOOK_MESSAGE( PlayerJarated );
|
|
HOOK_MESSAGE( PlayerExtinguished );
|
|
HOOK_MESSAGE( BreakModel );
|
|
HOOK_MESSAGE( CheapBreakModel );
|
|
HOOK_MESSAGE( BreakModel_Pumpkin );
|
|
HOOK_MESSAGE( BreakModelRocketDud );
|
|
HOOK_MESSAGE( PlayerJaratedFade );
|
|
HOOK_MESSAGE( PlayerShieldBlocked );
|
|
HOOK_MESSAGE( PlayerBonusPoints );
|
|
HOOK_MESSAGE( SpawnFlyingBird );
|
|
HOOK_MESSAGE( PlayerGodRayEffect );
|
|
HOOK_MESSAGE( PlayerTeleportHomeEffect );
|
|
HOOK_MESSAGE( RDTeamPointsChanged );
|
|
HOOK_MESSAGE( PlayerLoadoutUpdated );
|
|
HOOK_MESSAGE( PlayerTauntSoundLoopStart );
|
|
HOOK_MESSAGE( PlayerTauntSoundLoopEnd );
|
|
HOOK_MESSAGE( ForcePlayerViewAngles );
|
|
HOOK_MESSAGE( BonusDucks );
|
|
HOOK_MESSAGE( PlayerPickupWeapon );
|
|
HOOK_MESSAGE( QuestObjectiveCompleted );
|
|
|
|
#if !defined(NO_STEAM)
|
|
m_CallbackScreenshotRequested.Register( this, &ClientModeTFNormal::OnScreenshotRequested );
|
|
#endif
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: If you don't know what a destructor is by now, you are probably going to get fired
|
|
//-----------------------------------------------------------------------------
|
|
ClientModeTFNormal::~ClientModeTFNormal()
|
|
{
|
|
}
|
|
|
|
// See interface.h/.cpp for specifics: basically this ensures that we actually Sys_UnloadModule the dll and that we don't call Sys_LoadModule
|
|
// over and over again.
|
|
static CDllDemandLoader g_GameUI( "GameUI" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ClientModeTFNormal::Init()
|
|
{
|
|
m_pMenuEngyBuild = ( CHudMenuEngyBuild * )GET_HUDELEMENT( CHudMenuEngyBuild );
|
|
Assert( m_pMenuEngyBuild );
|
|
|
|
m_pMenuEngyDestroy = ( CHudMenuEngyDestroy * )GET_HUDELEMENT( CHudMenuEngyDestroy );
|
|
Assert( m_pMenuEngyDestroy );
|
|
|
|
m_pMenuSpyDisguise = ( CHudMenuSpyDisguise * )GET_HUDELEMENT( CHudMenuSpyDisguise );
|
|
Assert( m_pMenuSpyDisguise );
|
|
|
|
m_pFreezePanel = ( CTFFreezePanel * )GET_HUDELEMENT( CTFFreezePanel );
|
|
Assert( m_pFreezePanel );
|
|
|
|
m_pQuickSwitch = ( CItemQuickSwitchPanel * )GET_HUDELEMENT( CItemQuickSwitchPanel );
|
|
Assert( m_pQuickSwitch );
|
|
|
|
m_pMenuTauntSelection = ( CHudMenuTauntSelection * )GET_HUDELEMENT( CHudMenuTauntSelection );
|
|
Assert( m_pMenuTauntSelection );
|
|
|
|
m_pMenuUpgradePanel = ( CHudUpgradePanel* )GET_HUDELEMENT( CHudUpgradePanel );
|
|
|
|
#ifdef STAGING_ONLY
|
|
m_pMenuSpyBuild = ( CHudMenuSpyBuild * )GET_HUDELEMENT( CHudMenuSpyBuild );
|
|
Assert( m_pMenuSpyBuild );
|
|
#endif // STAGING_ONLY
|
|
|
|
m_pMenuSpell = ( CHudSpellMenu * )GET_HUDELEMENT( CHudSpellMenu);
|
|
Assert( m_pMenuSpell );
|
|
|
|
m_pEurekaTeleportMenu = ( CHudEurekaEffectTeleportMenu * )GET_HUDELEMENT( CHudEurekaEffectTeleportMenu );
|
|
Assert( m_pEurekaTeleportMenu );
|
|
|
|
m_pTeamGoalTournament = (CHudTeamGoalTournament *)GET_HUDELEMENT( CHudTeamGoalTournament );
|
|
Assert( m_pTeamGoalTournament );
|
|
|
|
m_pInspectPanel = (CHudInspectPanel *)GET_HUDELEMENT( CHudInspectPanel );
|
|
Assert( m_pInspectPanel );
|
|
|
|
m_wasConnectedLastUpdate = false;
|
|
|
|
m_lastServerIP = 0;
|
|
m_lastServerPort = 0;
|
|
m_lastServerName = NULL;
|
|
m_lastServerConnectTime = 0;
|
|
|
|
m_flNextAllowedHighFiveHintTime = 0.0f;
|
|
|
|
m_bInfoPanelShown = false;
|
|
m_bRestrictInfoPanel = false;
|
|
|
|
CreateInterfaceFn gameUIFactory = g_GameUI.GetFactory();
|
|
if ( gameUIFactory )
|
|
{
|
|
m_pGameUI = (IGameUI *) gameUIFactory(GAMEUI_INTERFACE_VERSION, NULL );
|
|
if ( NULL != m_pGameUI )
|
|
{
|
|
// insert stats summary panel as the loading background dialog
|
|
CTFStatsSummaryPanel *pPanel = GStatsSummaryPanel();
|
|
pPanel->InvalidateLayout( false, true );
|
|
pPanel->SetVisible( false );
|
|
pPanel->MakePopup( false );
|
|
m_pGameUI->SetLoadingBackgroundDialog( pPanel->GetVPanel() );
|
|
|
|
IViewPortPanel *pMMOverride = ( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
|
|
if ( pMMOverride )
|
|
{
|
|
((CHudMainMenuOverride*)pMMOverride)->AttachToGameUI();
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined( _X360 )
|
|
m_pScoreboard = (CTFClientScoreBoardDialog *)( gViewPortInterface->FindPanelByName( PANEL_SCOREBOARD ) );
|
|
Assert( m_pScoreboard );
|
|
#endif
|
|
|
|
ListenForGameEvent( "localplayer_changeclass" );
|
|
|
|
#ifdef TF_RAID_MODE
|
|
ListenForGameEvent( "raid_spawn_mob" );
|
|
ListenForGameEvent( "raid_spawn_squad" );
|
|
#endif // TF_RAID_MODE
|
|
|
|
ListenForGameEvent( "player_upgraded" );
|
|
ListenForGameEvent( "player_buyback" );
|
|
ListenForGameEvent( "player_death" );
|
|
ListenForGameEvent( "player_used_powerup_bottle" );
|
|
MannVsMachineStats_Init();
|
|
|
|
ListenForGameEvent( "pve_win_panel" );
|
|
|
|
ListenForGameEvent( "arena_win_panel" );
|
|
ListenForGameEvent( "teamplay_win_panel" );
|
|
ListenForGameEvent( "server_spawn" );
|
|
|
|
ListenForGameEvent( "pumpkin_lord_summoned" );
|
|
ListenForGameEvent( "pumpkin_lord_killed" );
|
|
ListenForGameEvent( "eyeball_boss_summoned" );
|
|
ListenForGameEvent( "eyeball_boss_stunned" );
|
|
ListenForGameEvent( "eyeball_boss_killed" );
|
|
ListenForGameEvent( "eyeball_boss_killer" );
|
|
ListenForGameEvent( "eyeball_boss_escape_imminent" );
|
|
ListenForGameEvent( "eyeball_boss_escaped" );
|
|
|
|
ListenForGameEvent( "merasmus_summoned" );
|
|
ListenForGameEvent( "merasmus_killed" );
|
|
ListenForGameEvent( "merasmus_escape_warning" );
|
|
ListenForGameEvent( "merasmus_escaped" );
|
|
|
|
ListenForGameEvent( "player_highfive_start" );
|
|
ListenForGameEvent( "player_highfive_cancel" );
|
|
ListenForGameEvent( "player_highfive_success" );
|
|
|
|
ListenForGameEvent( "client_beginconnect" );
|
|
|
|
ListenForGameEvent( "player_teleported" );
|
|
ListenForGameEvent( "scorestats_accumulated_reset" );
|
|
ListenForGameEvent( "scorestats_accumulated_update" );
|
|
|
|
extern void Training_Init();
|
|
Training_Init();
|
|
|
|
BaseClass::Init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void ClientModeTFNormal::Shutdown()
|
|
{
|
|
DestroyStatsSummaryPanel();
|
|
}
|
|
|
|
void ClientModeTFNormal::InitViewport()
|
|
{
|
|
m_pViewport = new TFViewport();
|
|
m_pViewport->Start( gameuifuncs, gameeventmanager );
|
|
}
|
|
|
|
|
|
void ClientModeTFNormal::LevelInit( const char *newmap )
|
|
{
|
|
BaseClass::LevelInit( newmap );
|
|
|
|
m_bInfoPanelShown = false;
|
|
}
|
|
|
|
IClientMode *GetClientModeNormal()
|
|
{
|
|
static ClientModeTFNormal g_ClientModeNormal;
|
|
|
|
return &g_ClientModeNormal;
|
|
}
|
|
|
|
|
|
ClientModeTFNormal* GetClientModeTFNormal()
|
|
{
|
|
Assert( dynamic_cast< ClientModeTFNormal* >( GetClientModeNormal() ) );
|
|
|
|
return static_cast< ClientModeTFNormal* >( GetClientModeNormal() );
|
|
}
|
|
|
|
extern ConVar v_viewmodel_fov;
|
|
ConVar v_viewmodel_fov_demo( "viewmodel_fov_demo", "54", FCVAR_ARCHIVE );
|
|
float ClientModeTFNormal::GetViewModelFOV( void )
|
|
{
|
|
// If we're playing back a demo, we clamp the viewmodel fov
|
|
if ( engine->IsPlayingDemo() )
|
|
return v_viewmodel_fov_demo.GetFloat();
|
|
|
|
return v_viewmodel_fov.GetFloat();
|
|
}
|
|
|
|
extern ConVar r_drawviewmodel;
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::ShouldDrawViewModel()
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pPlayer )
|
|
{
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
|
|
return false;
|
|
}
|
|
|
|
if ( !r_drawviewmodel.GetBool() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
ConVar tf_hud_no_crosshair_on_scope_zoom( "tf_hud_no_crosshair_on_scope_zoom", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
|
|
|
|
bool ClientModeTFNormal::ShouldDrawCrosshair()
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer )
|
|
return false;
|
|
|
|
if ( pPlayer->GetPlayerClass() &&
|
|
pPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_SNIPER &&
|
|
pPlayer->m_Shared.InCond( TF_COND_ZOOMED ) &&
|
|
tf_hud_no_crosshair_on_scope_zoom.GetBool() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return ClientModeShared::ShouldDrawCrosshair();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns true if VR mode should black out everything outside the HUD.
|
|
// This is used for things like sniper scopes and full screen UI
|
|
//-----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::ShouldBlackoutAroundHUD()
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer )
|
|
return true;
|
|
|
|
return ClientModeShared::ShouldBlackoutAroundHUD();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Allows the client mode to override mouse control stuff in sourcevr
|
|
//-----------------------------------------------------------------------------
|
|
HeadtrackMovementMode_t ClientModeTFNormal::ShouldOverrideHeadtrackControl()
|
|
{
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pPlayer )
|
|
return HMM_NOOVERRIDE;
|
|
|
|
// TODO: check if these actually all work right.
|
|
switch ( pPlayer->GetObserverMode() )
|
|
{
|
|
case OBS_MODE_DEATHCAM : // Turned into OBS_MODE_CHASE in VR
|
|
case OBS_MODE_ROAMING :
|
|
case OBS_MODE_FIXED : // Checked - works.
|
|
case OBS_MODE_CHASE : // Checked - works.
|
|
case OBS_MODE_POI : // PASSTIME NOT CHECKED
|
|
case OBS_MODE_FREEZECAM : // Turned into OBS_MODE_CHASE in VR
|
|
return HMM_SHOOTMOVEMOUSE_LOOKFACE;
|
|
case OBS_MODE_IN_EYE : // Checked - works.
|
|
return HMM_NOOVERRIDE;
|
|
}
|
|
|
|
return ClientModeShared::ShouldOverrideHeadtrackControl();
|
|
}
|
|
|
|
|
|
int ClientModeTFNormal::GetDeathMessageStartHeight( void )
|
|
{
|
|
return m_pViewport->GetDeathMessageStartHeight();
|
|
}
|
|
|
|
void ClientModeTFNormal::FireGameEvent( IGameEvent *event )
|
|
{
|
|
const char *eventname = event->GetName();
|
|
|
|
if ( !eventname || !eventname[0] )
|
|
return;
|
|
|
|
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
|
|
if ( FStrEq( "player_changename", eventname ) )
|
|
{
|
|
return; // server sends a colorized text string for this
|
|
}
|
|
else if ( FStrEq( "localplayer_changeclass", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer && pLocalPlayer->GetPlayerClass() )
|
|
{
|
|
int iClass = pLocalPlayer->GetPlayerClass()->GetClassIndex();
|
|
|
|
// have the player to exec a <class>.cfg file for the class they have selected
|
|
char szCmd[128];
|
|
Q_snprintf( szCmd, sizeof( szCmd ), "exec %s.cfg", GetPlayerClassData( iClass )->m_szClassName );
|
|
engine->ExecuteClientCmd( szCmd );
|
|
}
|
|
}
|
|
|
|
#ifdef TF_RAID_MODE
|
|
else if ( FStrEq( "raid_spawn_mob", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Raid.MobSpawn" );
|
|
}
|
|
}
|
|
else if ( FStrEq( "raid_spawn_squad", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Raid.SquadSpawn" );
|
|
}
|
|
}
|
|
#endif // TF_RAID_MODE
|
|
|
|
else if ( FStrEq( "player_connect_client", eventname ) || FStrEq( "player_disconnect", eventname ) )
|
|
{
|
|
// ignore these
|
|
if ( TFGameRules() && TFGameRules()->IsPVEModeActive() && event->GetInt( "bot" ) != 0 )
|
|
return;
|
|
}
|
|
else if ( FStrEq( "server_cvar", eventname ) )
|
|
{
|
|
if ( TFGameRules() && TFGameRules()->IsPVEModeActive() && !Q_strcmp( event->GetString("cvarname"), "tf_bot_count" ) )
|
|
return;
|
|
}
|
|
else if ( FStrEq( "player_buyback", eventname ) )
|
|
{
|
|
int idxPlayer = event->GetInt( "player" );
|
|
KeyValuesAD pKeyValues( "data" );
|
|
if ( g_TF_PR )
|
|
{
|
|
const char *pszString = tf_mvm_buybacks_method.GetBool() ? "#TF_PVE_Player_BuyBack_Fixed" : "#TF_PVE_Player_BuyBack";
|
|
|
|
pKeyValues->SetString( "player", g_TF_PR->GetPlayerName( idxPlayer ) );
|
|
pKeyValues->SetInt( "credits", event->GetInt( "cost", 0 ) );
|
|
PrintTextToChatPlayer( idxPlayer, pszString, pKeyValues );
|
|
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "MVM.PlayerBoughtIn" );
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "player_death", eventname ) )
|
|
{
|
|
// Make sure they're not doing a dead ringer fake death
|
|
if ( ( event->GetInt( "death_flags" ) & TF_DEATH_FEIGN_DEATH ) == 0 )
|
|
{
|
|
if ( TFGameRules() && ( TFGameRules()->State_Get() == GR_STATE_RND_RUNNING ) && ( TFGameRules()->IsMannVsMachineMode() || TFGameRules()->IsCompetitiveMode() ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
int nVictimIndex = event->GetInt( "victim_entindex" );
|
|
int nVictimTeam = g_TF_PR->GetTeam( nVictimIndex );
|
|
|
|
// See if there are any other players still alive
|
|
bool bSomeAlive = false;
|
|
for ( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
|
|
{
|
|
if ( !g_TF_PR->IsConnected( playerIndex ) )
|
|
continue;
|
|
|
|
if ( nVictimIndex == playerIndex )
|
|
continue;
|
|
|
|
if ( nVictimTeam != g_TF_PR->GetTeam( playerIndex ) )
|
|
continue;
|
|
|
|
if ( g_TF_PR->IsAlive( playerIndex ) )
|
|
{
|
|
// Found one
|
|
bSomeAlive = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bSomeAlive )
|
|
{
|
|
if ( TFGameRules()->IsMannVsMachineMode() )
|
|
{
|
|
if ( nVictimTeam == TF_TEAM_PVE_DEFENDERS )
|
|
{
|
|
// Inform the team that everyone is dead
|
|
pLocalPlayer->EmitSound( "Announcer.MVM_All_Dead" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const char *pszSound = NULL;
|
|
|
|
if ( ( RandomInt( 1, 100 ) <= 20 ) || ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM ) )
|
|
{
|
|
pszSound = ( nVictimTeam == TF_TEAM_RED ) ? "Announcer.TeamWipeRed" : "Announcer.TeamWipeBlu";
|
|
}
|
|
else if ( pLocalPlayer->GetTeamNumber() == nVictimTeam )
|
|
{
|
|
pszSound = "Announcer.YourTeamWiped";
|
|
}
|
|
else
|
|
{
|
|
pszSound = "Announcer.TheirTeamWiped";
|
|
}
|
|
|
|
if ( pszSound )
|
|
{
|
|
pLocalPlayer->EmitSound( pszSound );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "player_used_powerup_bottle", eventname ) )
|
|
{
|
|
int idxPlayer = event->GetInt( "player" );
|
|
KeyValuesAD pKeyValues( "data" );
|
|
if ( g_TF_PR )
|
|
{
|
|
pKeyValues->SetString( "player", g_TF_PR->GetPlayerName( idxPlayer ) );
|
|
const char *pText = NULL;
|
|
switch ( event->GetInt( "type" ) )
|
|
{
|
|
case POWERUP_BOTTLE_CRITBOOST: pText = "#TF_PVE_Player_UsedCritsBottle"; break;
|
|
case POWERUP_BOTTLE_UBERCHARGE: pText = "#TF_PVE_Player_UsedUberBottle"; break;
|
|
case POWERUP_BOTTLE_RECALL: pText = "#TF_PVE_Player_UsedRecallBottle"; break;
|
|
case POWERUP_BOTTLE_REFILL_AMMO: pText = "#TF_PVE_Player_UsedRefillAmmoBottle"; break;
|
|
case POWERUP_BOTTLE_BUILDINGS_INSTANT_UPGRADE: pText = "#TF_PVE_Player_UsedBuildingUpgrade"; break;
|
|
case POWERUP_BOTTLE_RADIUS_STEALTH: pText = "#TF_PVE_Player_UsedRadiusStealth"; break;
|
|
#ifdef STAGING_ONLY
|
|
case POWERUP_BOTTLE_SEE_CASH_THROUGH_WALL: pText = "#TF_PVE_Player_SeeCashThroughWall"; break;
|
|
#endif
|
|
}
|
|
if ( pText != NULL )
|
|
{
|
|
PrintTextToChatPlayer( idxPlayer, pText, pKeyValues );
|
|
}
|
|
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "MVM.PlayerUsedPowerup" );
|
|
}
|
|
}
|
|
}
|
|
else if (
|
|
FStrEq( "pve_win_panel", eventname ) ||
|
|
FStrEq( "arena_win_panel", eventname ) ||
|
|
FStrEq( "teamplay_win_panel", eventname ) )
|
|
{
|
|
#if defined( REPLAY_ENABLED )
|
|
DisplayReplayReminder();
|
|
#endif
|
|
}
|
|
else if ( FStrEq( "server_spawn", eventname ) )
|
|
{
|
|
uint32 newServerIP = 0;
|
|
int newServerPort = event->GetInt( "port" );
|
|
|
|
const char *pzAddress = event->GetString( "address" );
|
|
if ( pzAddress )
|
|
{
|
|
CUtlStringList IPs;
|
|
V_SplitString( pzAddress, ".", IPs );
|
|
|
|
if ( IPs.Count() == 4 )
|
|
{
|
|
byte ip[4];
|
|
for ( int i=0; i<IPs.Count() && i<4; ++i )
|
|
{
|
|
ip[i] = (byte) Q_atoi( IPs[i] );
|
|
}
|
|
newServerIP = (ip[0]<<24) + (ip[1]<<16) + (ip[2]<<8) + ip[3];
|
|
}
|
|
}
|
|
|
|
if ( m_lastServerConnectTime == 0 || newServerIP != m_lastServerIP || newServerPort != m_lastServerPort )
|
|
{
|
|
// we are connecting, or have connected to a different server
|
|
m_lastServerIP = newServerIP;
|
|
m_lastServerPort = newServerPort;
|
|
|
|
const char *hostname = event->GetString( "hostname" );
|
|
if ( hostname )
|
|
{
|
|
if ( m_lastServerName )
|
|
{
|
|
delete [] m_lastServerName;
|
|
m_lastServerName = NULL;
|
|
}
|
|
|
|
int hostnameLength = V_strlen( hostname )+1;
|
|
|
|
m_lastServerName = new char[ hostnameLength ];
|
|
|
|
V_strncpy( m_lastServerName, hostname, hostnameLength );
|
|
}
|
|
|
|
m_lastServerConnectTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
|
|
}
|
|
|
|
m_flNextAllowedHighFiveHintTime = 0.0f;
|
|
|
|
// Play Sound and flash window if joining a game from a lobby
|
|
CTFGSLobby *pLobby = GTFGCClientSystem()->GetLobby();
|
|
if ( pLobby )
|
|
{
|
|
engine->FlashWindow();
|
|
|
|
// If minimized, Blink and play noise
|
|
if ( engine->IsActiveApp() )
|
|
{
|
|
vgui::surface()->PlaySound( "ui/vote_started.wav" );
|
|
}
|
|
else
|
|
{
|
|
char fullpath[ 512 ];
|
|
g_pFullFileSystem->RelativePathToFullPath( "sound/ui/vote_started.wav", "GAME", fullpath, sizeof( fullpath ) );
|
|
PlayOutOfGameSound( fullpath );
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "pumpkin_lord_summoned", eventname ) )
|
|
{
|
|
if ( !TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.HeadlessBossSpawn" );
|
|
}
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
pNotification->SetText( "#TF_Halloween_Boss_Appeared" );
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
}
|
|
else if ( FStrEq( "pumpkin_lord_killed", eventname ) )
|
|
{
|
|
if ( !TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.HeadlessBossDeath" );
|
|
}
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
pNotification->SetText( "#TF_Halloween_Boss_Killed" );
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
}
|
|
else if ( FStrEq( "eyeball_boss_summoned", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.MonoculusBossSpawn" );
|
|
}
|
|
|
|
KeyValuesAD keyValues( "eyeball_boss" );
|
|
keyValues->SetColor( "custom_color", colorEyeballBossText );
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
wchar_t *pszBaseString = g_pVGuiLocalize->Find( "TF_Halloween_Eyeball_Boss_LevelUp_Appeared" );
|
|
if ( pszBaseString )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, pszBaseString, pKeyValues );
|
|
|
|
static char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wTemp, szAnsi, sizeof(szAnsi) );
|
|
|
|
pNotification->SetText( szAnsi );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNotification->SetText( "#TF_Halloween_Eyeball_Boss_Appeared" );
|
|
}
|
|
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
pNotification->SetKeyValues( keyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
else if ( FStrEq( "eyeball_boss_stunned", eventname ) )
|
|
{
|
|
int iPlayerIndex = event->GetInt( "player_entindex" );
|
|
if ( pHUDChat )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
if ( g_TF_PR )
|
|
{
|
|
pKeyValues->SetString( "player", g_TF_PR->GetPlayerName( iPlayerIndex ) );
|
|
|
|
pHUDChat->SetCustomColor( colorEyeballBossText );
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
if ( iLevel > 1 )
|
|
{
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
PrintTextToChatPlayer( iPlayerIndex, "#TF_Halloween_Eyeball_Boss_LevelUp_Stun", pKeyValues );
|
|
}
|
|
else
|
|
{
|
|
PrintTextToChatPlayer( iPlayerIndex, "#TF_Halloween_Eyeball_Boss_Stun", pKeyValues );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "eyeball_boss_killed", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.MonoculusBossDeath" );
|
|
}
|
|
|
|
KeyValuesAD keyValues( "eyeball_boss" );
|
|
keyValues->SetColor( "custom_color", colorEyeballBossText );
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
wchar_t *pszBaseString = g_pVGuiLocalize->Find( "TF_Halloween_Eyeball_Boss_LevelUp_Killed" );
|
|
if ( pszBaseString )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, pszBaseString, pKeyValues );
|
|
|
|
static char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wTemp, szAnsi, sizeof(szAnsi) );
|
|
|
|
pNotification->SetText( szAnsi );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNotification->SetText( "#TF_Halloween_Eyeball_Boss_Killed" );
|
|
}
|
|
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
pNotification->SetKeyValues( keyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
else if ( FStrEq( "eyeball_boss_killer", eventname ) )
|
|
{
|
|
int iPlayerIndex = event->GetInt( "player_entindex" );
|
|
if ( pHUDChat )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
if ( g_TF_PR )
|
|
{
|
|
pKeyValues->SetString( "player", g_TF_PR->GetPlayerName( iPlayerIndex ) );
|
|
|
|
pHUDChat->SetCustomColor( colorEyeballBossText );
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
PrintTextToChatPlayer( iPlayerIndex, "#TF_Halloween_Eyeball_Boss_LevelUp_Killers", pKeyValues );
|
|
}
|
|
else
|
|
{
|
|
PrintTextToChatPlayer( iPlayerIndex, "#TF_Halloween_Eyeball_Boss_Killers", pKeyValues );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "eyeball_boss_escape_imminent", eventname ) )
|
|
{
|
|
int nSecondsRemaining = event->GetInt( "time_remaining" );
|
|
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
if ( nSecondsRemaining <= 10 )
|
|
pLocalPlayer->EmitSound( "Halloween.EyeballBossEscapeImminent" );
|
|
else
|
|
pLocalPlayer->EmitSound( "Halloween.EyeballBossEscapeSoon" );
|
|
}
|
|
|
|
if ( pHUDChat )
|
|
{
|
|
char szEyeballBossEscaping[128];
|
|
pHUDChat->SetCustomColor( colorEyeballBossText );
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
V_sprintf_safe( szEyeballBossEscaping, "#TF_Halloween_Eyeball_Boss_LevelUp_Escaping_In_%i", nSecondsRemaining );
|
|
|
|
PrintTextToChat( szEyeballBossEscaping, pKeyValues );
|
|
}
|
|
else
|
|
{
|
|
V_sprintf_safe( szEyeballBossEscaping, "#TF_Halloween_Eyeball_Boss_Escaping_In_%i", nSecondsRemaining );
|
|
|
|
PrintTextToChat( szEyeballBossEscaping );
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "eyeball_boss_escaped", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.EyeballBossEscaped" );
|
|
}
|
|
|
|
KeyValuesAD keyValues( "eyeball_boss" );
|
|
keyValues->SetColor( "custom_color", colorEyeballBossText );
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
wchar_t *pszBaseString = g_pVGuiLocalize->Find( "TF_Halloween_Eyeball_Boss_LevelUp_Escaped" );
|
|
if ( pszBaseString )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, pszBaseString, pKeyValues );
|
|
|
|
static char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wTemp, szAnsi, sizeof(szAnsi) );
|
|
|
|
pNotification->SetText( szAnsi );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNotification->SetText( "#TF_Halloween_Eyeball_Boss_Escaped" );
|
|
}
|
|
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
pNotification->SetKeyValues( keyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
else if ( FStrEq( "merasmus_summoned", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.MerasmusBossSpawn" );
|
|
}
|
|
|
|
KeyValuesAD keyValues( "merasmus" );
|
|
keyValues->SetColor( "custom_color", colorMerasmusText );
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
wchar_t *pszBaseString = g_pVGuiLocalize->Find( "TF_Halloween_Merasmus_LevelUp_Appeared" );
|
|
if ( pszBaseString )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, pszBaseString, pKeyValues );
|
|
|
|
static char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wTemp, szAnsi, sizeof(szAnsi) );
|
|
|
|
pNotification->SetText( szAnsi );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNotification->SetText( "#TF_Halloween_Merasmus_Appeared" );
|
|
}
|
|
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
pNotification->SetKeyValues( keyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
else if ( FStrEq( "merasmus_killed", eventname ) )
|
|
{
|
|
KeyValuesAD keyValues( "merasmus" );
|
|
keyValues->SetColor( "custom_color", colorMerasmusText );
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
wchar_t *pszBaseString = g_pVGuiLocalize->Find( "TF_Halloween_Merasmus_LevelUp_Killed" );
|
|
if ( pszBaseString )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, pszBaseString, pKeyValues );
|
|
|
|
static char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wTemp, szAnsi, sizeof(szAnsi) );
|
|
|
|
pNotification->SetText( szAnsi );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNotification->SetText( "#TF_Halloween_Merasmus_Killed" );
|
|
}
|
|
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
pNotification->SetKeyValues( keyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
else if ( FStrEq( "merasmus_escape_warning", eventname ) )
|
|
{
|
|
int nSecondsRemaining = event->GetInt( "time_remaining" );
|
|
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
if ( nSecondsRemaining <= 10 )
|
|
pLocalPlayer->EmitSound( "Halloween.EyeballBossEscapeImminent" );
|
|
else
|
|
pLocalPlayer->EmitSound( "Halloween.EyeballBossEscapeSoon" );
|
|
}
|
|
|
|
if ( pHUDChat )
|
|
{
|
|
char szEyeballBossEscaping[128];
|
|
pHUDChat->SetCustomColor( colorMerasmusText );
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
V_sprintf_safe( szEyeballBossEscaping, "#TF_Halloween_Merasmus_LevelUp_Escaping_In_%i", nSecondsRemaining );
|
|
|
|
PrintTextToChat( szEyeballBossEscaping, pKeyValues );
|
|
}
|
|
else
|
|
{
|
|
V_sprintf_safe( szEyeballBossEscaping, "#TF_Halloween_Merasmus_Escaping_In_%i", nSecondsRemaining );
|
|
|
|
PrintTextToChat( szEyeballBossEscaping );
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "merasmus_escaped", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
pLocalPlayer->EmitSound( "Halloween.EyeballBossEscaped" );
|
|
}
|
|
|
|
KeyValuesAD keyValues( "merasmus" );
|
|
keyValues->SetColor( "custom_color", colorMerasmusText );
|
|
|
|
CEconNotification *pNotification = new CEconNotification();
|
|
|
|
const int iLevel = event->GetInt( "level" );
|
|
|
|
if ( iLevel > 1 )
|
|
{
|
|
wchar_t *pszBaseString = g_pVGuiLocalize->Find( "TF_Halloween_Merasmus_LevelUp_Escaped" );
|
|
if ( pszBaseString )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "level", iLevel );
|
|
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, pszBaseString, pKeyValues );
|
|
|
|
static char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wTemp, szAnsi, sizeof(szAnsi) );
|
|
|
|
pNotification->SetText( szAnsi );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNotification->SetText( "#TF_Halloween_Merasmus_Escaped" );
|
|
}
|
|
|
|
pNotification->SetLifetime( 5.0f );
|
|
pNotification->SetSoundFilename( "vo/null.mp3" );
|
|
pNotification->SetKeyValues( keyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
}
|
|
else if ( FStrEq( "player_highfive_start", eventname ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
|
|
// Don't show a hint if we're dead, we've already done it the maximum amount of times, or if it's too soon.
|
|
if ( pLocalPlayer && pLocalPlayer->IsAlive() &&
|
|
( tf_taunt_always_show_hint.GetBool() ||
|
|
( tf_highfive_hintcount.GetInt() < TF_HIGHFIVE_HINT_MAXHINTS && gpGlobals->curtime > m_flNextAllowedHighFiveHintTime ) ) )
|
|
{
|
|
int entindex = event->GetInt( "entindex" );
|
|
C_BasePlayer *pHighFiveInitiator = UTIL_PlayerByIndex( entindex );
|
|
if ( pHighFiveInitiator && pHighFiveInitiator != pLocalPlayer && ( pHighFiveInitiator->GetTeamNumber() == pLocalPlayer->GetTeamNumber() || tf_allow_all_team_partner_taunt.GetBool() ) )
|
|
{
|
|
// check that this player isn't too far away
|
|
Vector vecStart = pLocalPlayer->EyePosition();
|
|
Vector vecEnd = pHighFiveInitiator->EyePosition();
|
|
float flLength = (vecEnd - vecStart).Length();
|
|
|
|
if ( flLength < TF_HIGHFIVE_HINT_MAXDIST )
|
|
{
|
|
// check that we have line of sight to this player
|
|
trace_t tr;
|
|
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, pLocalPlayer, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( !tr.startsolid && tr.m_pEnt != NULL && tr.m_pEnt == pHighFiveInitiator )
|
|
{
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "show_annotation" );
|
|
if ( pEvent )
|
|
{
|
|
Vector location = pHighFiveInitiator->GetAbsOrigin();
|
|
|
|
pEvent->SetString( "text", "#TF_HighFive_Hint" );
|
|
pEvent->SetInt( "id", TF_HIGHFIVE_HINT_MASK | entindex );
|
|
pEvent->SetFloat( "worldPosX", location.x );
|
|
pEvent->SetFloat( "worldPosY", location.y );
|
|
pEvent->SetFloat( "worldPosZ", location.z + 48.0f );
|
|
pEvent->SetFloat( "lifetime", 10.0f );
|
|
pEvent->SetInt( "follow_entindex", entindex );
|
|
|
|
gameeventmanager->FireEventClientSide( pEvent );
|
|
tf_highfive_hintcount.SetValue( tf_highfive_hintcount.GetInt() + 1 );
|
|
|
|
m_flNextAllowedHighFiveHintTime = gpGlobals->curtime + TF_HIGHFIVE_HINT_MINTIMEBETWEEN;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( "player_highfive_cancel", eventname ) )
|
|
{
|
|
int entindex = event->GetInt( "entindex" );
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "hide_annotation" );
|
|
if ( pEvent )
|
|
{
|
|
pEvent->SetInt( "id", TF_HIGHFIVE_HINT_MASK | entindex );
|
|
gameeventmanager->FireEventClientSide( pEvent );
|
|
}
|
|
}
|
|
else if ( FStrEq( "player_highfive_success", eventname ) )
|
|
{
|
|
int entindex = event->GetInt( "initiator_entindex" );
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "hide_annotation" );
|
|
if ( pEvent )
|
|
{
|
|
pEvent->SetInt( "id", TF_HIGHFIVE_HINT_MASK | entindex );
|
|
gameeventmanager->FireEventClientSide( pEvent );
|
|
}
|
|
}
|
|
else if ( FStrEq( "client_beginconnect", eventname ) )
|
|
{
|
|
const char *pchSource = event->GetString( "source" );
|
|
m_bRestrictInfoPanel = pchSource && ( FStrEq( "matchmaking", pchSource ) || !Q_strncmp( pchSource, "quickplay_", 10 ) );
|
|
|
|
m_bInfoPanelShown = false;
|
|
}
|
|
else if ( FStrEq( "player_teleported", eventname ) )
|
|
{
|
|
int iUserID = event->GetInt( "userid" );
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if( pLocalPlayer && pLocalPlayer->GetUserID() == iUserID && UseVR() )
|
|
{
|
|
g_ClientVirtualReality.AlignTorsoAndViewToWeapon();
|
|
}
|
|
}
|
|
else if ( FStrEq( "scorestats_accumulated_reset", eventname ) )
|
|
{
|
|
if ( g_TF_PR && TFGameRules() && !TFGameRules()->IsMannVsMachineMode() )
|
|
{
|
|
g_TF_PR->ResetPlayerScoreStats();
|
|
}
|
|
}
|
|
else if ( FStrEq( "scorestats_accumulated_update", eventname ) )
|
|
{
|
|
if ( g_TF_PR && TFGameRules() && !TFGameRules()->IsMannVsMachineMode() )
|
|
{
|
|
g_TF_PR->UpdatePlayerScoreStats();
|
|
}
|
|
}
|
|
|
|
BaseClass::FireGameEvent( event );
|
|
}
|
|
|
|
void ClientModeTFNormal::PostRenderVGui()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::CreateMove( float flInputSampleTime, CUserCmd *cmd )
|
|
{
|
|
return BaseClass::CreateMove( flInputSampleTime, cmd );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: See if hud elements want key input. Return 0 if the key is swallowed
|
|
//-----------------------------------------------------------------------------
|
|
int ClientModeTFNormal::HudElementKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
|
|
{
|
|
// Let scoreboard handle input first because on X360 we need gamertags and
|
|
// gamercards accessible at all times when gamertag is visible.
|
|
#if defined( _X360 )
|
|
if ( m_pScoreboard )
|
|
{
|
|
if ( !m_pScoreboard->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Applies basic tags if we're going to take a screenshot
|
|
ScreenshotTaggingKeyInput( down, keynum, pszCurrentBinding );
|
|
|
|
if ( TrainingHandlesKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ( CoachingHandlesKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ( ItemTestHandlesKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ( HalloweenHandlesKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ( TauntHandlesKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// check for hud menus
|
|
if ( m_pMenuEngyBuild )
|
|
{
|
|
if ( !m_pMenuEngyBuild->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( m_pMenuEngyDestroy )
|
|
{
|
|
if ( !m_pMenuEngyDestroy->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( m_pMenuSpyDisguise )
|
|
{
|
|
if ( !m_pMenuSpyDisguise->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( m_pFreezePanel )
|
|
{
|
|
m_pFreezePanel->HudElementKeyInput( down, keynum, pszCurrentBinding );
|
|
}
|
|
|
|
if ( m_pQuickSwitch )
|
|
{
|
|
if ( !m_pQuickSwitch->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( m_pMenuTauntSelection )
|
|
{
|
|
if ( !m_pMenuTauntSelection->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
#ifdef STAGING_ONLY
|
|
if ( m_pMenuSpyBuild )
|
|
{
|
|
if ( !m_pMenuSpyBuild->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
#endif // STAGING_ONLY
|
|
|
|
if ( m_pEurekaTeleportMenu )
|
|
{
|
|
if ( !m_pEurekaTeleportMenu->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( m_pInspectPanel )
|
|
{
|
|
if ( !m_pInspectPanel->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( m_pTeamGoalTournament )
|
|
{
|
|
if ( !m_pTeamGoalTournament->HudElementKeyInput( down, keynum, pszCurrentBinding ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if ( TournamentHudElementKeyInput( down, keynum, pszCurrentBinding ) == true )
|
|
return 0;
|
|
|
|
if ( ArenaClassLayoutKeyInput( down, keynum, pszCurrentBinding ) == true )
|
|
return 0;
|
|
|
|
#ifndef _X360
|
|
if ( ShouldScoreBoardHandleKeyInput( down, keynum, pszCurrentBinding ) )
|
|
return 0;
|
|
#endif // !360
|
|
|
|
return BaseClass::HudElementKeyInput( down, keynum, pszCurrentBinding );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: See if spectator input occurred. Return 0 if the key is swallowed.
|
|
//-----------------------------------------------------------------------------
|
|
int ClientModeTFNormal::HandleSpectatorKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
|
|
{
|
|
#if defined( _X360 )
|
|
// On X360 when we have scoreboard up in spectator menu we cannot
|
|
// steal any input because gamertags must be selectable and gamercards
|
|
// must be accessible.
|
|
// We cannot rely on any keybindings in this case since user could have
|
|
// remapped everything.
|
|
if ( m_pScoreboard && m_pScoreboard->IsVisible() )
|
|
{
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
// @note Tom Bui: Coaching, so override all input
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer && pLocalPlayer->m_bIsCoaching )
|
|
{
|
|
if ( down && pszCurrentBinding && Q_strcmp( pszCurrentBinding, "+jump" ) == 0 )
|
|
{
|
|
engine->ClientCmd( "spec_mode" );
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return BaseClass::HandleSpectatorKeyInput( down, keynum, pszCurrentBinding );
|
|
}
|
|
}
|
|
|
|
bool ClientModeTFNormal::DoPostScreenSpaceEffects( const CViewSetup *pSetup )
|
|
{
|
|
if ( !BaseClass::DoPostScreenSpaceEffects( pSetup ) )
|
|
return false;
|
|
|
|
if( IsInFreezeCam() )
|
|
return false;
|
|
|
|
g_GlowObjectManager.RenderGlowEffects( pSetup, 0 );
|
|
|
|
return true;
|
|
}
|
|
|
|
#if !defined(NO_STEAM)
|
|
void ClientModeTFNormal::OnScreenshotRequested( ScreenshotRequested_t *pParam )
|
|
{
|
|
// Steam has requested a screenshot, act as if the key currently bound to screenshots
|
|
// has been pressed (we want tagging and the killcam screenshot behavior if applicable)
|
|
HudElementKeyInput( 0, BUTTON_CODE_INVALID, "screenshot" );
|
|
engine->ClientCmd( "screenshot" );
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------
|
|
ConVar cl_ask_favorite_min_session_duration( "cl_ask_favorite_min_session_duration", "600", 0, "If player stays on a server for longer than this time (in seconds) prompt to add server to favorites" );
|
|
ConVar cl_ask_favorite_opt_out( "cl_ask_favorite_opt_out", "0", FCVAR_ARCHIVE, "If nonzero, don't auto-ask to favorite servers" );
|
|
ConVar cl_ask_favorite_for_any_server( "cl_ask_favorite_for_any_server", "0", 0, "If nonzero, auto-ask for local/LAN servers (for debugging)" );
|
|
|
|
|
|
ConVar cl_ask_blacklist_max_session_duration( "cl_ask_blacklist_max_session_duration", "60", 0, "If player stays on a server for less than this time (in seconds) prompt to add server to blacklist" );
|
|
ConVar cl_ask_blacklist_opt_out( "cl_ask_blacklist_opt_out", "0", FCVAR_ARCHIVE, "If nonzero, don't auto-ask to blacklist servers" );
|
|
ConVar cl_ask_blacklist_for_any_server( "cl_ask_blacklist_for_any_server", "0", 0, "If nonzero, auto-ask for local/LAN servers (for debugging)" );
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void OnAskFavoriteDialogButtonPressed( bool bConfirm, void *pContext )
|
|
{
|
|
if ( bConfirm )
|
|
{
|
|
// add last server to our favorites
|
|
steamapicontext->SteamMatchmaking()->AddFavoriteGame( steamapicontext->SteamUtils()->GetAppID(),
|
|
GetClientModeTFNormal()->GetLastConnectedServerIP(),
|
|
GetClientModeTFNormal()->GetLastConnectedServerPort(),
|
|
GetClientModeTFNormal()->GetLastConnectedServerPort(),
|
|
k_unFavoriteFlagFavorite,
|
|
CRTime::RTime32TimeCur() );
|
|
|
|
// Send it to the GC
|
|
GCSDK::CGCMsg< MsgGCServerBrowser_Server_t > msg( k_EMsgGCServerBrowser_FavoriteServer );
|
|
msg.Body().m_unIP = GetClientModeTFNormal()->GetLastConnectedServerIP();
|
|
msg.Body().m_usPort = GetClientModeTFNormal()->GetLastConnectedServerPort();
|
|
msg.Body().m_ubSource = k_EGCMsgServerBrowser_FromAutoAskDialog;
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void OnAskBlacklistDialogButtonPressed( bool bConfirm, void *pContext )
|
|
{
|
|
if ( bConfirm )
|
|
{
|
|
// add last server to our blacklist
|
|
CBlacklistedServerManager blackList;
|
|
blackList.LoadServersFromFile( BLACKLIST_DEFAULT_SAVE_FILE, false );
|
|
|
|
blackList.AddServer( GetClientModeTFNormal()->GetLastConnectedServerName(),
|
|
GetClientModeTFNormal()->GetLastConnectedServerIP(),
|
|
GetClientModeTFNormal()->GetLastConnectedServerPort() );
|
|
|
|
blackList.SaveToFile( BLACKLIST_DEFAULT_SAVE_FILE );
|
|
|
|
// Send it to the GC
|
|
GCSDK::CGCMsg< MsgGCServerBrowser_Server_t > msg( k_EMsgGCServerBrowser_BlacklistServer );
|
|
msg.Body().m_unIP = GetClientModeTFNormal()->GetLastConnectedServerIP();
|
|
msg.Body().m_usPort = GetClientModeTFNormal()->GetLastConnectedServerPort();
|
|
msg.Body().m_ubSource = k_EGCMsgServerBrowser_FromAutoAskDialog;
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// If conditions are right, prompt the user to either favorite or blacklist
|
|
// the last server they had connected to.
|
|
void ClientModeTFNormal::AskFavoriteOrBlacklist() const
|
|
{
|
|
// based on the time we spent on our last server, ask to favorite or blacklist it
|
|
int sessionDuration = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() - m_lastServerConnectTime;
|
|
|
|
if ( sessionDuration > 0 )
|
|
{
|
|
// favorite?
|
|
if ( !cl_ask_favorite_opt_out.GetBool() && sessionDuration > cl_ask_favorite_min_session_duration.GetFloat() )
|
|
{
|
|
// don't ask to favorite reserved addresses
|
|
if ( !cl_ask_favorite_for_any_server.GetBool() )
|
|
{
|
|
netadr_t netAdr( GetLastConnectedServerIP(), GetLastConnectedServerPort() );
|
|
|
|
if ( !netAdr.IsValid() || netAdr.IsReservedAdr() )
|
|
return;
|
|
|
|
// Don't offer this for Valve servers, either
|
|
if ( GTFGCClientSystem()->BIsIPRecentMatchServer( netAdr ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// is this server already a favorite?
|
|
for( int i=0; i<steamapicontext->SteamMatchmaking()->GetFavoriteGameCount(); ++i )
|
|
{
|
|
AppId_t appID = steamapicontext->SteamUtils()->GetAppID();
|
|
uint32 IP;
|
|
uint16 connPort;
|
|
uint16 queryPort;
|
|
uint32 flags;
|
|
uint32 time32LastPlayedOnServer;
|
|
|
|
if ( steamapicontext->SteamMatchmaking()->GetFavoriteGame( i, &appID, &IP, &connPort, &queryPort, &flags, &time32LastPlayedOnServer ) )
|
|
{
|
|
if ( ( flags & k_unFavoriteFlagFavorite ) == false )
|
|
{
|
|
// not a favorite
|
|
continue;
|
|
}
|
|
|
|
if ( ( appID == 0 || appID == steamapicontext->SteamUtils()->GetAppID() ) &&
|
|
IP == GetLastConnectedServerIP() &&
|
|
connPort == GetLastConnectedServerPort() )
|
|
{
|
|
// already have this server in our favorites - don't ask again
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// new potential favorite - ask
|
|
ShowConfirmOptOutDialog( "#TF_Serverlist_Ask_Favorite_Title", "#TF_Serverlist_Ask_Favorite_Text",
|
|
"#TF_Serverlist_Ask_Yes", "#TF_Serverlist_Ask_No",
|
|
"#TF_ServerList_Ask_Favorite_Opt_Out", "cl_ask_favorite_opt_out",
|
|
OnAskFavoriteDialogButtonPressed, NULL );
|
|
}
|
|
|
|
// blacklist?
|
|
if ( !cl_ask_blacklist_opt_out.GetBool() && sessionDuration < cl_ask_blacklist_max_session_duration.GetFloat() )
|
|
{
|
|
// is this server already blacklisted?
|
|
CBlacklistedServerManager blackList;
|
|
blackList.LoadServersFromFile( BLACKLIST_DEFAULT_SAVE_FILE, false );
|
|
|
|
netadr_t lastServer( GetLastConnectedServerIP(), (unsigned short)GetLastConnectedServerPort() );
|
|
if ( ( !blackList.CanServerBeBlacklisted( lastServer.GetIPHostByteOrder(), lastServer.GetPort(), GetLastConnectedServerName() )
|
|
|| GTFGCClientSystem()->BIsIPRecentMatchServer( lastServer ) )
|
|
&& !cl_ask_blacklist_for_any_server.GetBool() )
|
|
{
|
|
// don't bother - this server is not blacklistable
|
|
return;
|
|
}
|
|
|
|
if ( blackList.IsServerBlacklisted( GetLastConnectedServerIP(), GetLastConnectedServerPort(), GetLastConnectedServerName() ) )
|
|
{
|
|
// already marked as bad
|
|
return;
|
|
}
|
|
|
|
// new potential blacklist - ask
|
|
ShowConfirmOptOutDialog( "#TF_Serverlist_Ask_Blacklist_Title", "#TF_Serverlist_Ask_Blacklist_Text",
|
|
"#TF_Serverlist_Ask_Yes", "#TF_Serverlist_Ask_No",
|
|
"#TF_ServerList_Ask_Blacklist_Opt_Out", "cl_ask_blacklist_opt_out",
|
|
OnAskBlacklistDialogButtonPressed, NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void ClientModeTFNormal::Update()
|
|
{
|
|
BaseClass::Update();
|
|
|
|
TFModalStack()->Update();
|
|
|
|
NotificationQueue_Update();
|
|
|
|
// CHudVote *pHudVote = GET_HUDELEMENT( CHudVote );
|
|
// CTFHudMannVsMachineStatus *pMannVsMachineStatus = GET_HUDELEMENT( CTFHudMannVsMachineStatus );
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
|
|
// Update steam controller stuff if one is active
|
|
if ( ::input->IsSteamControllerActive() )
|
|
{
|
|
// Walk through all the panels and HUD elements, see what kind of action set each one requests.
|
|
bool bNeedMenu = false;
|
|
bool bNeedHUD = false;
|
|
bool bNeedSpectator = false;
|
|
m_pViewport->ForEachPanel( [&] (IViewPortPanel* pPanel) {
|
|
if ( pPanel && pPanel->IsVisible() )
|
|
{
|
|
auto actionset = pPanel->GetPreferredActionSet();
|
|
if ( actionset == GAME_ACTION_SET_MENUCONTROLS )
|
|
{
|
|
bNeedMenu = true;
|
|
}
|
|
else if ( actionset == GAME_ACTION_SET_IN_GAME_HUD )
|
|
{
|
|
bNeedHUD = true;
|
|
}
|
|
else if ( actionset == GAME_ACTION_SET_SPECTATOR )
|
|
{
|
|
bNeedSpectator = true;
|
|
}
|
|
}
|
|
} );
|
|
|
|
gHUD.ForEachHudElement( [&]( CHudElement* pElement ) {
|
|
if ( pElement && pElement->IsActive() )
|
|
{
|
|
auto actionset = pElement->GetPreferredActionSet();
|
|
if ( actionset == GAME_ACTION_SET_MENUCONTROLS )
|
|
{
|
|
bNeedMenu = true;
|
|
}
|
|
else if ( actionset == GAME_ACTION_SET_IN_GAME_HUD )
|
|
{
|
|
bNeedHUD = true;
|
|
}
|
|
else if ( actionset == GAME_ACTION_SET_SPECTATOR )
|
|
{
|
|
bNeedSpectator = true;
|
|
}
|
|
}
|
|
} );
|
|
|
|
// Set the preferred action set. Requesting menu trumps hud, which trumps spectator, which trumps fps.
|
|
if ( !engine->IsInGame() || !engine->IsConnected() || enginevgui->IsGameUIVisible() || bNeedMenu )
|
|
{
|
|
::input->SetPreferredGameActionSet( GAME_ACTION_SET_MENUCONTROLS );
|
|
}
|
|
else if ( bNeedHUD )
|
|
{
|
|
::input->SetPreferredGameActionSet( GAME_ACTION_SET_IN_GAME_HUD );
|
|
}
|
|
else if ( bNeedSpectator || (pLocalPlayer && pLocalPlayer->GetTeamNumber() == TEAM_SPECTATOR) )
|
|
{
|
|
::input->SetPreferredGameActionSet( GAME_ACTION_SET_SPECTATOR );
|
|
}
|
|
else
|
|
{
|
|
::input->SetPreferredGameActionSet( GAME_ACTION_SET_FPSCONTROLS );
|
|
}
|
|
|
|
// Adjust look sensitivity down if the player is current using a zoomed-in weapon (typically sniper rifle).
|
|
float look_sensitivity = 0.125f;
|
|
if ( pLocalPlayer && pLocalPlayer->m_Shared.InCond( TF_COND_ZOOMED ) )
|
|
{
|
|
look_sensitivity = 0.035f;
|
|
}
|
|
|
|
// Set the flag for special action handling if we're taunting
|
|
if ( pLocalPlayer && pLocalPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
|
|
{
|
|
::input->SetGameActionSetFlags( GAME_ACTION_SET_FLAGS_TAUNTING );
|
|
}
|
|
else
|
|
{
|
|
::input->SetGameActionSetFlags( GAME_ACTION_SET_FLAGS_NONE );
|
|
}
|
|
|
|
sc_look_sensitivity_scale.SetValue( look_sensitivity );
|
|
}
|
|
|
|
if ( !engine->IsInGame() )
|
|
{
|
|
// @note Tom Bui: we want this thing to always run, so we get animations at the main menu
|
|
g_pClientMode->GetViewportAnimationController()->UpdateAnimations( gpGlobals->curtime );
|
|
}
|
|
|
|
if ( !engine->IsConnected() )
|
|
{
|
|
if ( m_wasConnectedLastUpdate )
|
|
{
|
|
// just disconnected from a game
|
|
m_wasConnectedLastUpdate = false;
|
|
|
|
AskFavoriteOrBlacklist();
|
|
|
|
m_lastServerConnectTime = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_wasConnectedLastUpdate = true;
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void ClientModeTFNormal::ComputeVguiResConditions( KeyValues *pkvConditions )
|
|
{
|
|
BaseClass::ComputeVguiResConditions( pkvConditions );
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsInfoPanelAllowed()
|
|
{
|
|
if ( !BaseClass::IsInfoPanelAllowed() )
|
|
return false;
|
|
|
|
return !m_bRestrictInfoPanel || !m_bInfoPanelShown;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsHTMLInfoPanelAllowed()
|
|
{
|
|
if ( !BaseClass::IsHTMLInfoPanelAllowed() )
|
|
return false;
|
|
|
|
return !m_bRestrictInfoPanel;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void ClientModeTFNormal::InfoPanelDisplayed()
|
|
{
|
|
BaseClass::InfoPanelDisplayed();
|
|
|
|
m_bInfoPanelShown = true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsEngyBuildVisible() const
|
|
{
|
|
return m_pMenuEngyBuild && m_pMenuEngyBuild->IsVisible();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsEngyDestroyVisible() const
|
|
{
|
|
return m_pMenuEngyDestroy && m_pMenuEngyDestroy->IsVisible();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsEngyEurekaTeleportVisible() const
|
|
{
|
|
return m_pEurekaTeleportMenu && m_pEurekaTeleportMenu->IsVisible();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsSpyDisguiseVisible() const
|
|
{
|
|
return m_pMenuSpyDisguise && m_pMenuSpyDisguise->IsVisible();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsUpgradePanelVisible() const
|
|
{
|
|
return m_pMenuUpgradePanel && m_pMenuUpgradePanel->IsVisible();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool ClientModeTFNormal::IsTauntSelectPanelVisible() const
|
|
{
|
|
return m_pMenuTauntSelection && m_pMenuTauntSelection->IsVisible();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void ClientModeTFNormal::PrintTextToChat( const char *pText, KeyValues *pKeyValues )
|
|
{
|
|
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
|
|
if ( pHUDChat )
|
|
{
|
|
wchar_t wszText[1024]=L"";
|
|
g_pVGuiLocalize->ConstructString_safe( wszText, pText, pKeyValues );
|
|
char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wszText, szAnsi, sizeof(szAnsi) );
|
|
pHUDChat->Printf( CHAT_FILTER_NONE, "%s", szAnsi );
|
|
}
|
|
}
|
|
|
|
void ClientModeTFNormal::PrintTextToChatPlayer( int iPlayerIndex, const char *pText, KeyValues *pKeyValues )
|
|
{
|
|
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
|
|
if ( pHUDChat )
|
|
{
|
|
wchar_t wszText[1024]=L"";
|
|
g_pVGuiLocalize->ConstructString_safe( wszText, pText, pKeyValues );
|
|
char szAnsi[1024];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( wszText, szAnsi, sizeof(szAnsi) );
|
|
pHUDChat->ChatPrintf( iPlayerIndex, CHAT_FILTER_NONE, "%s", szAnsi );
|
|
}
|
|
}
|
|
|
|
void ClientModeTFNormal::OnDemoRecordStart( char const* pDemoBaseName )
|
|
{
|
|
BaseClass::OnDemoRecordStart( pDemoBaseName );
|
|
}
|
|
|
|
void ClientModeTFNormal::OnDemoRecordStop()
|
|
{
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "ds_stop" );
|
|
if ( event )
|
|
{
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
|
|
BaseClass::OnDemoRecordStop();
|
|
}
|
|
|
|
void __MsgFunc_PlayerBonusPoints( bf_read &msg )
|
|
{
|
|
int nPoints = (int) msg.ReadByte();
|
|
int iPlayerEntIndex = (int) msg.ReadByte();
|
|
int iSourceEntIndex = (int) msg.ReadByte();
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_bonuspoints" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "points", nPoints );
|
|
event->SetInt( "player_entindex", iPlayerEntIndex );
|
|
event->SetInt( "source_entindex", iSourceEntIndex );
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_PlayerGodRayEffect( bf_read &msg )
|
|
{
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
|
|
CBasePlayer *player = UTIL_PlayerByIndex( iPlayerEntIndex );
|
|
if ( player )
|
|
{
|
|
player->ParticleProp()->Create( "god_rays", PATTACH_ABSORIGIN_FOLLOW );
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_PlayerTeleportHomeEffect( bf_read &msg )
|
|
{
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayerEntIndex );
|
|
if ( pPlayer )
|
|
{
|
|
pPlayer->ParticleProp()->Create( "drg_wrenchmotron_teleport", PATTACH_ABSORIGIN );
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_RDTeamPointsChanged( bf_read &msg )
|
|
{
|
|
int nPoints = (int)msg.ReadShort();
|
|
int nTeam = (int)msg.ReadByte();
|
|
int nMethod = (int)msg.ReadByte();
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "rd_team_points_changed" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "points", nPoints );
|
|
event->SetInt( "team", nTeam );
|
|
event->SetInt( "method", nMethod );
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_PlayerLoadoutUpdated( bf_read &msg )
|
|
{
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerEntIndex ) );
|
|
if ( pPlayer )
|
|
{
|
|
CTFPlayerInventory *pInv = pPlayer->Inventory();
|
|
if ( pInv )
|
|
{
|
|
pInv->ClearClassLoadoutChangeTracking();
|
|
}
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_PlayerTauntSoundLoopStart( bf_read &msg )
|
|
{
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerEntIndex ) );
|
|
if ( pPlayer )
|
|
{
|
|
char szTauntSoundLoopName[256];
|
|
msg.ReadString( szTauntSoundLoopName, sizeof(szTauntSoundLoopName) );
|
|
pPlayer->PlayTauntSoundLoop( szTauntSoundLoopName );
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_PlayerTauntSoundLoopEnd( bf_read &msg )
|
|
{
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerEntIndex ) );
|
|
if ( pPlayer )
|
|
{
|
|
pPlayer->StopTauntSoundLoop();
|
|
}
|
|
}
|
|
|
|
|
|
void __MsgFunc_ForcePlayerViewAngles( bf_read &msg )
|
|
{
|
|
// Read flag byte. Should be 1 right now.
|
|
int iFlags = (int)msg.ReadByte();
|
|
NOTE_UNUSED( iFlags );
|
|
Assert( iFlags == 0x01 );
|
|
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerEntIndex ) );
|
|
if ( pPlayer )
|
|
{
|
|
QAngle viewangles;
|
|
msg.ReadBitAngles( viewangles );
|
|
|
|
// Set the magic angles here!
|
|
pPlayer->SetLocalAngles( viewangles );
|
|
pPlayer->SetAbsAngles( viewangles );
|
|
pPlayer->SetTauntYaw( viewangles[YAW] );
|
|
pPlayer->m_Shared.SetVehicleMoveAngles( viewangles );
|
|
}
|
|
}
|
|
|
|
ConVar tf_halloween_bonus_ducks_cooldown( "tf_halloween_bonus_ducks_cooldown", "20", FCVAR_ARCHIVE );
|
|
void __MsgFunc_BonusDucks( bf_read &msg )
|
|
{
|
|
static float sflNextBonusDucks = 0.f;
|
|
|
|
int iPlayerEntIndex = (int)msg.ReadByte();
|
|
int iIgnoreTimer = (int)msg.ReadByte();
|
|
|
|
if ( Plat_FloatTime() < sflNextBonusDucks && !iIgnoreTimer )
|
|
return;
|
|
|
|
sflNextBonusDucks = Plat_FloatTime() + tf_halloween_bonus_ducks_cooldown.GetFloat();
|
|
|
|
|
|
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerEntIndex ) );
|
|
if ( pPlayer )
|
|
{
|
|
pPlayer->EmitSound( "sf14.Merasmus.DuckHunt.BonusDucks" );
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_PlayerPickupWeapon( bf_read &msg )
|
|
{
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_pickup_weapon" );
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
|
|
void __MsgFunc_AutoBalanceVolunteer( bf_read &msg )
|
|
{
|
|
KeyValuesAD pKeyValues( "data" );
|
|
pKeyValues->SetInt( "points", tf_autobalance_xp_bonus.GetInt() );
|
|
|
|
CAutobalanceVolunteerNotification *pNotification = new CAutobalanceVolunteerNotification();
|
|
pNotification->SetText( GTFGCClientSystem()->BConnectedToMatchServer( true ) ? "#TF_AutoBalanceVolunteerXPBonus" : "#TF_AutoBalanceVolunteer" );
|
|
pNotification->SetLifetime( tf_autobalance_query_lifetime.GetInt() );
|
|
pNotification->SetKeyValues( pKeyValues );
|
|
NotificationQueue_Add( pNotification );
|
|
|
|
if ( cl_notifications_show_ingame.GetInt() == 0 )
|
|
{
|
|
// player has turned off the in-game notifications so let's throw a chat
|
|
// message to see if they will check their notifications in the main menu
|
|
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
|
|
if ( pPlayer && pHUDChat )
|
|
{
|
|
char szLocalized[100];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI(g_pVGuiLocalize->Find( "#TF_AutoBalanceVolunteer_ChatText" ), szLocalized, sizeof( szLocalized ) );
|
|
pHUDChat->ChatPrintf( pPlayer->entindex(), CHAT_FILTER_NONE, "%s ", szLocalized );
|
|
}
|
|
}
|
|
}
|
|
|
|
void __MsgFunc_AutoBalanceVolunteer_Cancel( bf_read &msg )
|
|
{
|
|
NotificationQueue_Remove( &CAutobalanceVolunteerNotification::IsNotificationType );
|
|
}
|
|
|
|
void __MsgFunc_QuestObjectiveCompleted( bf_read &msg )
|
|
{
|
|
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
|
|
|
|
itemid_t itemID = (itemid_t)msg.ReadLongLong();
|
|
uint16 nStandardPoints = msg.ReadWord();
|
|
uint16 nBonusPoints = msg.ReadWord();
|
|
uint32 nObjectiveDefIndex = msg.ReadWord();
|
|
|
|
QuestObjectiveManager()->UpdateFromServer( itemID, nStandardPoints, nBonusPoints );
|
|
QuestObjectiveManager()->EnsureTrackersForPlayer( steamapicontext->SteamUser()->GetSteamID() );
|
|
|
|
// Passing a -1 means this is a ninja update where we don't want the fanfare
|
|
if ( nObjectiveDefIndex != (uint32)-1 )
|
|
{
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "quest_objective_completed" );
|
|
if ( pEvent )
|
|
{
|
|
pEvent->SetInt( "quest_item_id_low", itemID & 0xFFFFFFFF );
|
|
pEvent->SetInt( "quest_item_id_hi", itemID >> 32 );
|
|
pEvent->SetInt( "quest_objective_id", nObjectiveDefIndex );
|
|
gameeventmanager->FireEventClientSide( pEvent );
|
|
}
|
|
}
|
|
}
|
|
|
|
float PlaySoundEntry( const char* pszSoundEntryName )
|
|
{
|
|
const char *pszSoundName = UTIL_GetRandomSoundFromEntry( pszSoundEntryName );
|
|
if ( pszSoundName && pszSoundName[0] )
|
|
{
|
|
vgui::surface()->PlaySound( pszSoundName );
|
|
return enginesound->GetSoundDuration( pszSoundName );
|
|
}
|
|
|
|
return 0.f;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include "winlite.h"
|
|
#pragma warning (push)
|
|
#pragma warning(disable:4201) // nameless struct/union
|
|
#include <mmsystem.h>
|
|
#pragma warning (pop)
|
|
#endif
|
|
//
|
|
void PlayOutOfGameSound( const char *pszSound )
|
|
{
|
|
#ifdef _WIN32
|
|
PlaySound( pszSound, NULL, SND_FILENAME | SND_ASYNC );
|
|
#endif
|
|
}
|