FWGS/hlsdk-xash3d
2
0
Fork 0
mirror of https://github.com/FWGS/hlsdk-xash3d synced 2024-11-28 13:09:13 +01:00
Code Issues Projects Releases Wiki Activity
2b031dd585
hlsdk-xash3d/game_shared/voice_status.cpp

851 lines
21 KiB
C++
Raw Blame History

//========= Copyright (c) 1996-2002, Valve LLC, All rights reserved. ============
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
// There are hud.h's coming out of the woodwork so this ensures that we get the right one.
#include "../cl_dll/hud.h"
#include "../cl_dll/cl_util.h"
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include "../cl_dll/parsemsg.h"
#include "../cl_dll/hud_servers.h"
#include "../cl_dll/demo.h"
#include "demo_api.h"
#include "voice_status.h"
#include "r_efx.h"
#include "entity_types.h"
#include "VGUI_ActionSignal.h"
#include "VGUI_Scheme.h"
#include "VGUI_TextImage.h"
#include "vgui_loadtga.h"
#include "vgui_helpers.h"
#include "vgui_mousecode.h"
using namespace vgui;
extern int cam_thirdperson;
#define VOICE_MODEL_INTERVAL 0.3
#define SCOREBOARD_BLINK_FREQUENCY 0.3 // How often to blink the scoreboard icons.
#define SQUELCHOSCILLATE_PER_SECOND 2.0f
extern BitmapTGA *LoadTGA( const char* pImageName );
// ---------------------------------------------------------------------- //
// The voice manager for the client.
// ---------------------------------------------------------------------- //
CVoiceStatus g_VoiceStatus;
CVoiceStatus* GetClientVoiceMgr()
{
return &g_VoiceStatus;
}
// ---------------------------------------------------------------------- //
// CVoiceStatus.
// ---------------------------------------------------------------------- //
static CVoiceStatus *g_pInternalVoiceStatus = NULL;
int __MsgFunc_VoiceMask( const char *pszName, int iSize, void *pbuf )
{
if( g_pInternalVoiceStatus )
g_pInternalVoiceStatus->HandleVoiceMaskMsg( iSize, pbuf );
return 1;
}
int __MsgFunc_ReqState( const char *pszName, int iSize, void *pbuf )
{
if( g_pInternalVoiceStatus )
g_pInternalVoiceStatus->HandleReqStateMsg( iSize, pbuf );
return 1;
}
int g_BannedPlayerPrintCount;
void ForEachBannedPlayer( char id[16] )
{
char str[256];
sprintf( str, "Ban %d: %2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x\n",
g_BannedPlayerPrintCount++,
id[0], id[1], id[2], id[3],
id[4], id[5], id[6], id[7],
id[8], id[9], id[10], id[11],
id[12], id[13], id[14], id[15]
);
strupr( str );
gEngfuncs.pfnConsolePrint(str);
}
void ShowBannedCallback()
{
if( g_pInternalVoiceStatus )
{
g_BannedPlayerPrintCount = 0;
gEngfuncs.pfnConsolePrint("------- BANNED PLAYERS -------\n");
g_pInternalVoiceStatus->m_BanMgr.ForEachBannedPlayer( ForEachBannedPlayer );
gEngfuncs.pfnConsolePrint("------------------------------\n");
}
}
// ---------------------------------------------------------------------- //
// CVoiceStatus.
// ---------------------------------------------------------------------- //
CVoiceStatus::CVoiceStatus()
{
m_bBanMgrInitialized = false;
m_LastUpdateServerState = 0;
m_pSpeakerLabelIcon = NULL;
m_pScoreboardNeverSpoken = NULL;
m_pScoreboardNotSpeaking = NULL;
m_pScoreboardSpeaking = NULL;
m_pScoreboardSpeaking2 = NULL;
m_pScoreboardSquelch = NULL;
m_pScoreboardBanned = NULL;
m_pLocalBitmap = NULL;
m_pAckBitmap = NULL;
m_bTalking = m_bServerAcked = false;
memset( m_pBanButtons, 0, sizeof(m_pBanButtons) );
m_bServerModEnable = -1;
m_pchGameDir = NULL;
}
CVoiceStatus::~CVoiceStatus()
{
g_pInternalVoiceStatus = NULL;
for( int i = 0; i < MAX_VOICE_SPEAKERS; i++ )
{
delete m_Labels[i].m_pLabel;
m_Labels[i].m_pLabel = NULL;
delete m_Labels[i].m_pIcon;
m_Labels[i].m_pIcon = NULL;
delete m_Labels[i].m_pBackground;
m_Labels[i].m_pBackground = NULL;
}
delete m_pLocalLabel;
m_pLocalLabel = NULL;
FreeBitmaps();
if( m_pchGameDir )
{
if( m_bBanMgrInitialized )
{
m_BanMgr.SaveState( m_pchGameDir );
}
free( m_pchGameDir );
}
}
int CVoiceStatus::Init( IVoiceStatusHelper *pHelper, Panel **pParentPanel )
{
// Setup the voice_modenable cvar.
gEngfuncs.pfnRegisterVariable( "voice_modenable", "1", FCVAR_ARCHIVE );
gEngfuncs.pfnRegisterVariable( "voice_clientdebug", "0", 0 );
gEngfuncs.pfnAddCommand( "voice_showbanned", ShowBannedCallback );
if( gEngfuncs.pfnGetGameDirectory() )
{
m_BanMgr.Init( gEngfuncs.pfnGetGameDirectory() );
m_bBanMgrInitialized = true;
}
assert( !g_pInternalVoiceStatus );
g_pInternalVoiceStatus = this;
m_BlinkTimer = 0;
m_VoiceHeadModel = NULL;
memset( m_Labels, 0, sizeof(m_Labels) );
for( int i = 0; i < MAX_VOICE_SPEAKERS; i++ )
{
CVoiceLabel *pLabel = &m_Labels[i];
pLabel->m_pBackground = new Label( "" );
if( pLabel->m_pLabel = new Label( "" ) )
{
pLabel->m_pLabel->setVisible( true );
pLabel->m_pLabel->setFont( Scheme::sf_primary2 );
pLabel->m_pLabel->setTextAlignment( Label::a_east );
pLabel->m_pLabel->setContentAlignment( Label::a_east );
pLabel->m_pLabel->setParent( pLabel->m_pBackground );
}
if( pLabel->m_pIcon = new ImagePanel( NULL ) )
{
pLabel->m_pIcon->setVisible( true );
pLabel->m_pIcon->setParent( pLabel->m_pBackground );
}
pLabel->m_clientindex = -1;
}
m_pLocalLabel = new ImagePanel( NULL );
m_bInSquelchMode = false;
m_pHelper = pHelper;
m_pParentPanel = pParentPanel;
gHUD.AddHudElem( this );
m_iFlags = HUD_ACTIVE;
HOOK_MESSAGE( VoiceMask );
HOOK_MESSAGE( ReqState );
// Cache the game directory for use when we shut down
const char *pchGameDirT = gEngfuncs.pfnGetGameDirectory();
m_pchGameDir = (char *)malloc( strlen( pchGameDirT ) + 1 );
strcpy( m_pchGameDir, pchGameDirT );
return 1;
}
int CVoiceStatus::VidInit()
{
FreeBitmaps();
if( m_pLocalBitmap = vgui_LoadTGA( "gfx/vgui/icntlk_pl.tga" ) )
{
m_pLocalBitmap->setColor( Color( 255, 255, 255, 135 ) );
}
if( m_pAckBitmap = vgui_LoadTGA( "gfx/vgui/icntlk_sv.tga" ) )
{
m_pAckBitmap->setColor( Color( 255, 255, 255, 135 ) ); // Give just a tiny bit of translucency so software draws correctly.
}
m_pLocalLabel->setImage( m_pLocalBitmap );
m_pLocalLabel->setVisible( false );
if( m_pSpeakerLabelIcon = vgui_LoadTGANoInvertAlpha( "gfx/vgui/speaker4.tga" ) )
m_pSpeakerLabelIcon->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
if( m_pScoreboardNeverSpoken = vgui_LoadTGANoInvertAlpha( "gfx/vgui/640_speaker1.tga" ) )
m_pScoreboardNeverSpoken->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
if( m_pScoreboardNotSpeaking = vgui_LoadTGANoInvertAlpha( "gfx/vgui/640_speaker2.tga" ) )
m_pScoreboardNotSpeaking->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
if( m_pScoreboardSpeaking = vgui_LoadTGANoInvertAlpha( "gfx/vgui/640_speaker3.tga" ) )
m_pScoreboardSpeaking->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
if( m_pScoreboardSpeaking2 = vgui_LoadTGANoInvertAlpha( "gfx/vgui/640_speaker4.tga" ) )
m_pScoreboardSpeaking2->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
if( m_pScoreboardSquelch = vgui_LoadTGA( "gfx/vgui/icntlk_squelch.tga" ) )
m_pScoreboardSquelch->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
if( m_pScoreboardBanned = vgui_LoadTGA( "gfx/vgui/640_voiceblocked.tga" ) )
m_pScoreboardBanned->setColor( Color( 255, 255, 255, 1 ) ); // Give just a tiny bit of translucency so software draws correctly.
// Figure out the voice head model height.
m_VoiceHeadModelHeight = 45;
char *pFile = (char *)gEngfuncs.COM_LoadFile( "scripts/voicemodel.txt", 5, NULL );
if( pFile )
{
char token[4096];
gEngfuncs.COM_ParseFile( pFile, token );
if( token[0] >= '0' && token[0] <= '9' )
{
m_VoiceHeadModelHeight = (float)atof( token );
}
gEngfuncs.COM_FreeFile( pFile );
}
m_VoiceHeadModel = gEngfuncs.pfnSPR_Load( "sprites/voiceicon.spr" );
return TRUE;
}
void CVoiceStatus::Frame( double frametime )
{
// check server banned players once per second
if( gEngfuncs.GetClientTime() - m_LastUpdateServerState > 1 )
{
UpdateServerState( false );
}
m_BlinkTimer += frametime;
// Update speaker labels.
if( m_pHelper->CanShowSpeakerLabels() )
{
for( int i = 0; i < MAX_VOICE_SPEAKERS; i++ )
m_Labels[i].m_pBackground->setVisible( m_Labels[i].m_clientindex != -1 );
}
else
{
for( int i = 0; i < MAX_VOICE_SPEAKERS; i++ )
m_Labels[i].m_pBackground->setVisible( false );
}
for( int i = 0; i < VOICE_MAX_PLAYERS; i++ )
UpdateBanButton(i);
}
void CVoiceStatus::CreateEntities()
{
if( !m_VoiceHeadModel )
return;
cl_entity_t *localPlayer = gEngfuncs.GetLocalPlayer();
int iOutModel = 0;
for( int i = 0; i < VOICE_MAX_PLAYERS; i++ )
{
if( !m_VoicePlayers[i] )
continue;
cl_entity_s *pClient = gEngfuncs.GetEntityByIndex( i + 1 );
// Don't show an icon if the player is not in our PVS.
if( !pClient || pClient->curstate.messagenum < localPlayer->curstate.messagenum )
continue;
// Don't show an icon for dead or spectating players (ie: invisible entities).
if( pClient->curstate.effects & EF_NODRAW )
continue;
// Don't show an icon for the local player unless we're in thirdperson mode.
if( pClient == localPlayer && !cam_thirdperson )
continue;
cl_entity_s *pEnt = &m_VoiceHeadModels[iOutModel];
++iOutModel;
memset( pEnt, 0, sizeof(*pEnt) );
pEnt->curstate.rendermode = kRenderTransAdd;
pEnt->curstate.renderamt = 255;
pEnt->baseline.renderamt = 255;
pEnt->curstate.renderfx = kRenderFxNoDissipation;
pEnt->curstate.framerate = 1;
pEnt->curstate.frame = 0;
pEnt->model = (struct model_s*)gEngfuncs.GetSpritePointer( m_VoiceHeadModel );
pEnt->angles[0] = pEnt->angles[1] = pEnt->angles[2] = 0;
pEnt->curstate.scale = 0.5f;
pEnt->origin[0] = pEnt->origin[1] = 0;
pEnt->origin[2] = 45;
VectorAdd( pEnt->origin, pClient->origin, pEnt->origin );
// Tell the engine.
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, pEnt );
}
}
void CVoiceStatus::UpdateSpeakerStatus( int entindex, qboolean bTalking )
{
if( !*m_pParentPanel )
return;
if( gEngfuncs.pfnGetCvarFloat("voice_clientdebug") )
{
char msg[256];
sprintf( msg, "CVoiceStatus::UpdateSpeakerStatus: ent %d talking = %d\n", entindex, bTalking );
gEngfuncs.pfnConsolePrint( msg );
}
// Is it the local player talking?
if( entindex == -1 )
{
m_bTalking = !!bTalking;
if( bTalking )
{
// Enable voice for them automatically if they try to talk.
gEngfuncs.pfnClientCmd( "voice_modenable 1" );
}
}
else if( entindex == -2 )
{
m_bServerAcked = !!bTalking;
}
else if( entindex >= 0 && entindex <= VOICE_MAX_PLAYERS )
{
int iClient = entindex - 1;
if( iClient < 0 )
return;
CVoiceLabel *pLabel = FindVoiceLabel( iClient );
if( bTalking )
{
m_VoicePlayers[iClient] = true;
m_VoiceEnabledPlayers[iClient] = true;
// If we don't have a label for this guy yet, then create one.
if( !pLabel )
{
if( pLabel = GetFreeVoiceLabel() )
{
// Get the name from the engine.
hud_player_info_t info = {0};
GetPlayerInfo( entindex, &info );
char paddedName[512];
sprintf( paddedName, "%s ", info.name );
int color[3];
m_pHelper->GetPlayerTextColor( entindex, color );
if( pLabel->m_pBackground )
{
pLabel->m_pBackground->setBgColor( color[0], color[1], color[2], 135 );
pLabel->m_pBackground->setParent( *m_pParentPanel );
pLabel->m_pBackground->setVisible( m_pHelper->CanShowSpeakerLabels() );
}
if( pLabel->m_pLabel )
{
pLabel->m_pLabel->setFgColor( 255, 255, 255, 0 );
pLabel->m_pLabel->setBgColor( 0, 0, 0, 255 );
pLabel->m_pLabel->setText( paddedName );
}
pLabel->m_clientindex = iClient;
}
}
}
else
{
m_VoicePlayers[iClient] = false;
// If we have a label for this guy, kill it.
if( pLabel )
{
pLabel->m_pBackground->setVisible( false );
pLabel->m_clientindex = -1;
}
}
}
RepositionLabels();
}
void CVoiceStatus::UpdateServerState( bool bForce )
{
// Can't do anything when we're not in a level.
char const *pLevelName = gEngfuncs.pfnGetLevelName();
if( pLevelName[0] == 0 )
{
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::UpdateServerState: pLevelName[0]==0\n" );
}
return;
}
int bCVarModEnable = !!gEngfuncs.pfnGetCvarFloat( "voice_modenable" );
if( bForce || m_bServerModEnable != bCVarModEnable )
{
m_bServerModEnable = bCVarModEnable;
char str[256];
sprintf( str, "VModEnable %d", m_bServerModEnable );
ServerCmd( str );
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
char msg[256];
sprintf( msg, "CVoiceStatus::UpdateServerState: Sending '%s'\n", str );
gEngfuncs.pfnConsolePrint( msg );
}
}
char str[2048] = "vban";
bool bChange = false;
for( unsigned long dw = 0; dw < VOICE_MAX_PLAYERS_DW; dw++ )
{
unsigned long serverBanMask = 0;
unsigned long banMask = 0;
for( unsigned long i = 0; i < 32; i++ )
{
char playerID[16];
if( !gEngfuncs.GetPlayerUniqueID( i + 1, playerID ) )
continue;
if( m_BanMgr.GetPlayerBan( playerID ) )
banMask |= 1 << i;
if( m_ServerBannedPlayers[dw * 32 + i] )
serverBanMask |= 1 << i;
}
if( serverBanMask != banMask )
bChange = true;
// Ok, the server needs to be updated.
char numStr[512];
sprintf(numStr, " %x", banMask);
strcat(str, numStr);
}
if( bChange || bForce )
{
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
char msg[256];
sprintf( msg, "CVoiceStatus::UpdateServerState: Sending '%s'\n", str );
gEngfuncs.pfnConsolePrint( msg );
}
gEngfuncs.pfnServerCmdUnreliable( str ); // Tell the server..
}
else
{
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::UpdateServerState: no change\n" );
}
}
m_LastUpdateServerState = gEngfuncs.GetClientTime();
}
void CVoiceStatus::UpdateSpeakerImage( Label *pLabel, int iPlayer )
{
m_pBanButtons[iPlayer - 1] = pLabel;
UpdateBanButton(iPlayer - 1);
}
void CVoiceStatus::UpdateBanButton( int iClient )
{
Label *pPanel = m_pBanButtons[iClient];
if( !pPanel )
return;
char playerID[16];
extern bool HACK_GetPlayerUniqueID( int iPlayer, char playerID[16] );
if( !HACK_GetPlayerUniqueID( iClient + 1, playerID ) )
return;
// Figure out if it's blinking or not.
bool bBlink = fmod( m_BlinkTimer, SCOREBOARD_BLINK_FREQUENCY * 2 ) < SCOREBOARD_BLINK_FREQUENCY;
bool bTalking = !!m_VoicePlayers[iClient];
bool bBanned = m_BanMgr.GetPlayerBan( playerID );
bool bNeverSpoken = !m_VoiceEnabledPlayers[iClient];
// Get the appropriate image to display on the panel.
if( bBanned )
{
pPanel->setImage( m_pScoreboardBanned );
}
else if( bTalking )
{
if( bBlink )
{
pPanel->setImage( m_pScoreboardSpeaking2 );
}
else
{
pPanel->setImage( m_pScoreboardSpeaking );
}
pPanel->setFgColor( 255, 170, 0, 1 );
}
else if( bNeverSpoken )
{
pPanel->setImage( m_pScoreboardNeverSpoken );
pPanel->setFgColor( 100, 100, 100, 1 );
}
else
{
pPanel->setImage( m_pScoreboardNotSpeaking );
}
}
void CVoiceStatus::HandleVoiceMaskMsg( int iSize, void *pbuf )
{
BEGIN_READ( pbuf, iSize );
unsigned long dw;
for( dw = 0; dw < VOICE_MAX_PLAYERS_DW; dw++ )
{
m_AudiblePlayers.SetDWord( dw, (unsigned long)READ_LONG() );
m_ServerBannedPlayers.SetDWord( dw, (unsigned long)READ_LONG() );
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
char str[256];
gEngfuncs.pfnConsolePrint( "CVoiceStatus::HandleVoiceMaskMsg\n" );
sprintf( str, " - m_AudiblePlayers[%d] = %lu\n", dw, m_AudiblePlayers.GetDWord( dw ) );
gEngfuncs.pfnConsolePrint( str );
sprintf( str, " - m_ServerBannedPlayers[%d] = %lu\n", dw, m_ServerBannedPlayers.GetDWord( dw ) );
gEngfuncs.pfnConsolePrint( str );
}
}
m_bServerModEnable = READ_BYTE();
}
void CVoiceStatus::HandleReqStateMsg( int iSize, void *pbuf )
{
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::HandleReqStateMsg\n" );
}
UpdateServerState( true );
}
void CVoiceStatus::StartSquelchMode()
{
if( m_bInSquelchMode )
return;
m_bInSquelchMode = true;
m_pHelper->UpdateCursorState();
}
void CVoiceStatus::StopSquelchMode()
{
m_bInSquelchMode = false;
m_pHelper->UpdateCursorState();
}
bool CVoiceStatus::IsInSquelchMode()
{
return m_bInSquelchMode;
}
CVoiceLabel *CVoiceStatus::FindVoiceLabel( int clientindex )
{
for( int i = 0; i < MAX_VOICE_SPEAKERS; i++ )
{
if( m_Labels[i].m_clientindex == clientindex )
return &m_Labels[i];
}
return NULL;
}
CVoiceLabel *CVoiceStatus::GetFreeVoiceLabel()
{
return FindVoiceLabel( -1 );
}
void CVoiceStatus::RepositionLabels()
{
// find starting position to draw from, along right-hand side of screen
int y = ScreenHeight / 2;
int iconWide = 8, iconTall = 8;
if( m_pSpeakerLabelIcon )
{
m_pSpeakerLabelIcon->getSize( iconWide, iconTall );
}
// Reposition active labels.
for( int i = 0; i < MAX_VOICE_SPEAKERS; i++ )
{
CVoiceLabel *pLabel = &m_Labels[i];
if( pLabel->m_clientindex == -1 || !pLabel->m_pLabel )
{
if( pLabel->m_pBackground )
pLabel->m_pBackground->setVisible( false );
continue;
}
int textWide, textTall;
pLabel->m_pLabel->getContentSize( textWide, textTall );
// Don't let it stretch too far across their screen.
if( textWide > ( ScreenWidth * 2 ) / 3 )
textWide = ( ScreenWidth * 2 ) / 3;
// Setup the background label to fit everything in.
int border = 2;
int bgWide = textWide + iconWide + border * 3;
int bgTall = max( textTall, iconTall ) + border * 2;
pLabel->m_pBackground->setBounds( ScreenWidth - bgWide - 8, y, bgWide, bgTall );
// Put the text at the left.
pLabel->m_pLabel->setBounds( border, ( bgTall - textTall ) / 2, textWide, textTall );
// Put the icon at the right.
int iconLeft = border + textWide + border;
int iconTop = ( bgTall - iconTall ) / 2;
if( pLabel->m_pIcon )
{
pLabel->m_pIcon->setImage( m_pSpeakerLabelIcon );
pLabel->m_pIcon->setBounds( iconLeft, iconTop, iconWide, iconTall );
}
y += bgTall + 2;
}
if( m_pLocalBitmap && m_pAckBitmap && m_pLocalLabel && ( m_bTalking || m_bServerAcked ) )
{
m_pLocalLabel->setParent( *m_pParentPanel );
m_pLocalLabel->setVisible( true );
if( m_bServerAcked && !!gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
m_pLocalLabel->setImage( m_pAckBitmap );
else
m_pLocalLabel->setImage( m_pLocalBitmap );
int sizeX, sizeY;
m_pLocalBitmap->getSize( sizeX, sizeY );
int local_xPos = ScreenWidth - sizeX - 10;
int local_yPos = m_pHelper->GetAckIconHeight() - sizeY;
m_pLocalLabel->setPos( local_xPos, local_yPos );
}
else
{
m_pLocalLabel->setVisible( false );
}
}
void CVoiceStatus::FreeBitmaps()
{
// Delete all the images we have loaded.
delete m_pLocalBitmap;
m_pLocalBitmap = NULL;
delete m_pAckBitmap;
m_pAckBitmap = NULL;
delete m_pSpeakerLabelIcon;
m_pSpeakerLabelIcon = NULL;
delete m_pScoreboardNeverSpoken;
m_pScoreboardNeverSpoken = NULL;
delete m_pScoreboardNotSpeaking;
m_pScoreboardNotSpeaking = NULL;
delete m_pScoreboardSpeaking;
m_pScoreboardSpeaking = NULL;
delete m_pScoreboardSpeaking2;
m_pScoreboardSpeaking2 = NULL;
delete m_pScoreboardSquelch;
m_pScoreboardSquelch = NULL;
delete m_pScoreboardBanned;
m_pScoreboardBanned = NULL;
// Clear references to the images in panels.
for( int i = 0; i < VOICE_MAX_PLAYERS; i++ )
{
if( m_pBanButtons[i] )
{
m_pBanButtons[i]->setImage( NULL );
}
}
if( m_pLocalLabel )
m_pLocalLabel->setImage( NULL );
}
//-----------------------------------------------------------------------------
// Purpose: returns true if the target client has been banned
// Input : playerID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CVoiceStatus::IsPlayerBlocked( int iPlayer )
{
char playerID[16];
if( !gEngfuncs.GetPlayerUniqueID( iPlayer, playerID ) )
return false;
return m_BanMgr.GetPlayerBan( playerID );
}
//-----------------------------------------------------------------------------
// Purpose: returns true if the player can't hear the other client due to game rules (eg. the other team)
// Input : playerID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CVoiceStatus::IsPlayerAudible( int iPlayer )
{
return !!m_AudiblePlayers[iPlayer - 1];
}
//-----------------------------------------------------------------------------
// Purpose: blocks/unblocks the target client from being heard
// Input : playerID -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CVoiceStatus::SetPlayerBlockedState( int iPlayer, bool blocked )
{
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::SetPlayerBlockedState part 1\n" );
}
char playerID[16];
if( !gEngfuncs.GetPlayerUniqueID( iPlayer, playerID ) )
return;
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
gEngfuncs.pfnConsolePrint( "CVoiceStatus::SetPlayerBlockedState part 2\n" );
}
// Squelch or (try to) unsquelch this player.
if( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
{
char str[256];
sprintf( str, "CVoiceStatus::SetPlayerBlockedState: setting player %d ban to %d\n", iPlayer, !m_BanMgr.GetPlayerBan( playerID ) );
gEngfuncs.pfnConsolePrint( str );
}
m_BanMgr.SetPlayerBan( playerID, blocked );
UpdateServerState( false );
}
Reference in New Issue View Git Blame Copy Permalink