994 lines
25 KiB
C++
994 lines
25 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef SWDS
|
|
#include "screen.h"
|
|
#include "cl_main.h"
|
|
#include "iprediction.h"
|
|
#include "proto_oob.h"
|
|
#include "demo.h"
|
|
#include "tier0/icommandline.h"
|
|
#include "ispatialpartitioninternal.h"
|
|
#include "GameEventManager.h"
|
|
#include "cdll_engine_int.h"
|
|
#include "voice.h"
|
|
#include "host_cmd.h"
|
|
#include "server.h"
|
|
#include "convar.h"
|
|
#include "dt_recv_eng.h"
|
|
#include "dt_common_eng.h"
|
|
#include "LocalNetworkBackdoor.h"
|
|
#include "vox.h"
|
|
#include "sound.h"
|
|
#include "r_efx.h"
|
|
#include "r_local.h"
|
|
#include "decal_private.h"
|
|
#include "vgui_baseui_interface.h"
|
|
#include "host_state.h"
|
|
#include "cl_ents_parse.h"
|
|
#include "eiface.h"
|
|
#include "server.h"
|
|
#include "cl_demoactionmanager.h"
|
|
#include "decal.h"
|
|
#include "r_decal.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "EngineSoundInternal.h"
|
|
#include "ivideomode.h"
|
|
#include "download.h"
|
|
#include "GameUI/IGameUI.h"
|
|
#include "cl_demo.h"
|
|
#include "cdll_engine_int.h"
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
#include "replay/ienginereplay.h"
|
|
#include "replay_internal.h"
|
|
#endif
|
|
|
|
#include "audio_pch.h"
|
|
|
|
#if defined ( _X360 )
|
|
#include "matchmaking.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
extern IVEngineClient *engineClient;
|
|
|
|
extern CNetworkStringTableContainer *networkStringTableContainerClient;
|
|
extern CNetworkStringTableContainer *networkStringTableContainerServer;
|
|
|
|
static ConVar cl_allowupload ( "cl_allowupload", "1", FCVAR_ARCHIVE, "Client uploads customization files" );
|
|
static ConVar cl_voice_filter( "cl_voice_filter", "", 0, "Filter voice by name substring" ); // filter incoming voice data
|
|
|
|
static ConVar *replay_voice_during_playback = NULL;
|
|
|
|
extern ConCommand quit;
|
|
|
|
void CClientState::ConnectionClosing( const char * reason )
|
|
{
|
|
// if connected, shut down host
|
|
if ( m_nSignonState > SIGNONSTATE_NONE )
|
|
{
|
|
ConMsg( "Disconnect: %s.\n", reason );
|
|
if ( !Q_stricmp( reason, INVALID_STEAM_TICKET )
|
|
|| !Q_stricmp( reason, INVALID_STEAM_LOGON_TICKET_CANCELED ) )
|
|
{
|
|
g_eSteamLoginFailure = STEAMLOGINFAILURE_BADTICKET;
|
|
}
|
|
else if ( !Q_stricmp( reason, INVALID_STEAM_LOGON_NOT_CONNECTED ) )
|
|
{
|
|
g_eSteamLoginFailure = STEAMLOGINFAILURE_NOSTEAMLOGIN;
|
|
}
|
|
else if ( !Q_stricmp( reason, INVALID_STEAM_LOGGED_IN_ELSEWHERE ) )
|
|
{
|
|
g_eSteamLoginFailure = STEAMLOGINFAILURE_LOGGED_IN_ELSEWHERE;
|
|
}
|
|
else if ( !Q_stricmp( reason, INVALID_STEAM_VACBANSTATE ) )
|
|
{
|
|
g_eSteamLoginFailure = STEAMLOGINFAILURE_VACBANNED;
|
|
}
|
|
else
|
|
{
|
|
g_eSteamLoginFailure = STEAMLOGINFAILURE_NONE;
|
|
}
|
|
|
|
if ( reason && reason[0] == '#' )
|
|
{
|
|
COM_ExplainDisconnection( true, reason );
|
|
}
|
|
else
|
|
{
|
|
COM_ExplainDisconnection( true, "Disconnect: %s.\n", reason );
|
|
}
|
|
SCR_EndLoadingPlaque();
|
|
Host_Disconnect( true, reason );
|
|
}
|
|
}
|
|
|
|
|
|
void CClientState::ConnectionCrashed( const char * reason )
|
|
{
|
|
// if connected, shut down host
|
|
if ( m_nSignonState > SIGNONSTATE_NONE )
|
|
{
|
|
DebuggerBreakIfDebugging_StagingOnly();
|
|
|
|
COM_ExplainDisconnection( true, "Disconnect: %s.\n", reason );
|
|
SCR_EndLoadingPlaque();
|
|
Host_EndGame ( true, "%s", reason );
|
|
}
|
|
}
|
|
|
|
|
|
void CClientState::FileRequested(const char *fileName, unsigned int transferID)
|
|
{
|
|
ConMsg( "File '%s' requested from server %s.\n", fileName, m_NetChannel->GetAddress() );
|
|
|
|
if ( !cl_allowupload.GetBool() )
|
|
{
|
|
ConMsg( "File uploading disabled.\n" );
|
|
m_NetChannel->DenyFile( fileName, transferID );
|
|
return;
|
|
}
|
|
|
|
// TODO check if file valid for uploading
|
|
m_NetChannel->SendFile( fileName, transferID );
|
|
}
|
|
|
|
void CClientState::FileReceived( const char * fileName, unsigned int transferID )
|
|
{
|
|
#ifndef _XBOX
|
|
// check if the client donwload manager requested this file
|
|
CL_FileReceived( fileName, transferID );
|
|
// notify client dll
|
|
if ( g_ClientDLL )
|
|
{
|
|
g_ClientDLL->FileReceived( fileName, transferID );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void CClientState::FileDenied(const char *fileName, unsigned int transferID )
|
|
{
|
|
#ifndef _XBOX
|
|
// check if the file download manager requested that file
|
|
CL_FileDenied( fileName, transferID );
|
|
#endif
|
|
}
|
|
|
|
void CClientState::FileSent( const char *fileName, unsigned int transferID )
|
|
{
|
|
}
|
|
|
|
void CClientState::PacketStart( int incoming_sequence, int outgoing_acknowledged )
|
|
{
|
|
// Ack'd incoming messages.
|
|
m_nCurrentSequence = incoming_sequence;
|
|
command_ack = outgoing_acknowledged;
|
|
}
|
|
|
|
|
|
void CClientState::PacketEnd()
|
|
{
|
|
//
|
|
// we don't know if it is ok to save a demo message until
|
|
// after we have parsed the frame
|
|
//
|
|
|
|
// Play any sounds we received this packet
|
|
CL_DispatchSounds();
|
|
|
|
// Did we get any messages this tick (i.e., did we call PreEntityPacketReceived)?
|
|
if ( GetServerTickCount() != m_nDeltaTick )
|
|
return;
|
|
|
|
// How many commands total did we run this frame
|
|
int commands_acknowledged = command_ack - last_command_ack;
|
|
|
|
// COM_Log( "cl.log", "Server ack'd %i commands this frame\n", commands_acknowledged );
|
|
|
|
//Msg( "%i/%i CL_PostReadMessages: last ack %i most recent %i acked %i commands\n",
|
|
// host_framecount, cl.tickcount,
|
|
// cl.last_command_ack,
|
|
// cl.netchan->outgoing_sequence - 1,
|
|
// commands_acknowledged );
|
|
|
|
// Highest command parsed from messages
|
|
last_command_ack = command_ack;
|
|
|
|
// Let prediction copy off pristine data and report any errors, etc.
|
|
g_pClientSidePrediction->PostNetworkDataReceived( commands_acknowledged );
|
|
|
|
#ifndef _XBOX
|
|
demoaction->DispatchEvents();
|
|
#endif
|
|
}
|
|
|
|
#undef CreateEvent
|
|
void CClientState::Disconnect( const char *pszReason, bool bShowMainMenu )
|
|
{
|
|
#if defined( REPLAY_ENABLED )
|
|
if ( g_pClientReplayContext && IsConnected() )
|
|
{
|
|
g_pClientReplayContext->OnClientSideDisconnect();
|
|
}
|
|
#endif
|
|
|
|
CBaseClientState::Disconnect( pszReason, bShowMainMenu );
|
|
|
|
#ifndef _X360
|
|
IGameEvent *event = g_GameEventManager.CreateEvent( "client_disconnect" );
|
|
if ( event )
|
|
{
|
|
if ( !pszReason )
|
|
pszReason = "";
|
|
event->SetString( "message", pszReason );
|
|
g_GameEventManager.FireEventClientSide( event );
|
|
}
|
|
#endif
|
|
|
|
// stop any demo activities
|
|
#ifndef _XBOX
|
|
demoplayer->StopPlayback();
|
|
demorecorder->StopRecording();
|
|
#endif
|
|
|
|
S_StopAllSounds( true );
|
|
|
|
R_DecalTermAll();
|
|
|
|
if ( m_nMaxClients > 1 )
|
|
{
|
|
if ( EngineVGui()->IsConsoleVisible() == false )
|
|
{
|
|
// start progress bar immediately for multiplayer level transitions
|
|
EngineVGui()->EnabledProgressBarForNextLoad();
|
|
}
|
|
}
|
|
|
|
CL_ClearState();
|
|
|
|
#ifndef _XBOX
|
|
// End any in-progress downloads
|
|
CL_HTTPStop_f();
|
|
#endif
|
|
|
|
// stop loading progress bar
|
|
if (bShowMainMenu)
|
|
{
|
|
SCR_EndLoadingPlaque();
|
|
}
|
|
|
|
// notify game ui dll of out-of-in-game status
|
|
EngineVGui()->NotifyOfServerDisconnect();
|
|
|
|
if (bShowMainMenu && !engineClient->IsDrawingLoadingImage() && (cl.demonum == -1))
|
|
{
|
|
// we're not in the middle of loading something, so show the UI
|
|
if ( EngineVGui() )
|
|
{
|
|
EngineVGui()->ActivateGameUI();
|
|
}
|
|
}
|
|
|
|
HostState_OnClientDisconnected();
|
|
|
|
// if we played a demo from the startdemos list, play next one
|
|
if (cl.demonum != -1)
|
|
{
|
|
CL_NextDemo();
|
|
}
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessTick( NET_Tick *msg )
|
|
{
|
|
int tick = msg->m_nTick;
|
|
|
|
m_NetChannel->SetRemoteFramerate( msg->m_flHostFrameTime, msg->m_flHostFrameTimeStdDeviation );
|
|
|
|
m_ClockDriftMgr.SetServerTick( tick );
|
|
|
|
// Remember this for GetLastTimeStamp().
|
|
m_flLastServerTickTime = tick * host_state.interval_per_tick;
|
|
|
|
// Use the server tick while reading network data (used for interpolation samples, etc).
|
|
g_ClientGlobalVariables.tickcount = tick;
|
|
g_ClientGlobalVariables.curtime = tick * host_state.interval_per_tick;
|
|
g_ClientGlobalVariables.frametime = (tick - oldtickcount) * host_state.interval_per_tick; // We used to call GetFrameTime() here, but 'insimulation' is always
|
|
// true so we have this code right in here to keep it simple.
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessStringCmd( NET_StringCmd *msg )
|
|
{
|
|
return CBaseClientState::ProcessStringCmd( msg );
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessServerInfo( SVC_ServerInfo *msg )
|
|
{
|
|
// Reset client state
|
|
CL_ClearState();
|
|
|
|
if ( !CBaseClientState::ProcessServerInfo( msg ) )
|
|
{
|
|
Disconnect( "CBaseClientState::ProcessServerInfo failed", true );
|
|
return false;
|
|
}
|
|
#ifndef _XBOX
|
|
if ( demoplayer->IsPlayingBack() )
|
|
{
|
|
// Because a server doesn't run during
|
|
// demoplayback, but the decal system relies on this...
|
|
m_nServerCount = gHostSpawnCount;
|
|
}
|
|
else
|
|
{
|
|
// tell demo recorder that new map is loaded and we are receiving
|
|
// it's signon data (will be written into extra demo header file)
|
|
demorecorder->SetSignonState( SIGNONSTATE_NEW );
|
|
}
|
|
#endif
|
|
// is server a HLTV proxy ?
|
|
ishltv = msg->m_bIsHLTV;
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
// is server a replay proxy ?
|
|
isreplay = msg->m_bIsReplay;
|
|
#endif
|
|
|
|
// The MD5 of the server map must match the MD5 of the client map. or else
|
|
// the client is probably cheating.
|
|
V_memcpy( serverMD5.bits, msg->m_nMapMD5.bits, MD5_DIGEST_LENGTH );
|
|
|
|
// Multiplayer game?
|
|
if ( m_nMaxClients > 1 )
|
|
{
|
|
if ( mp_decals.GetInt() < r_decals.GetInt() )
|
|
{
|
|
r_decals.SetValue( mp_decals.GetInt() );
|
|
}
|
|
}
|
|
|
|
g_ClientGlobalVariables.maxClients = m_nMaxClients;
|
|
g_ClientGlobalVariables.network_protocol = msg->m_nProtocol;
|
|
|
|
#ifdef SHARED_NET_STRING_TABLES
|
|
// use same instance of StringTableContainer as the server does
|
|
m_StringTableContainer = networkStringTableContainerServer;
|
|
CL_HookClientStringTables();
|
|
#else
|
|
// use own instance of StringTableContainer
|
|
m_StringTableContainer = networkStringTableContainerClient;
|
|
#endif
|
|
|
|
CL_ReallocateDynamicData( m_nMaxClients );
|
|
|
|
if ( sv.IsPaused() )
|
|
{
|
|
if ( msg->m_fTickInterval != host_state.interval_per_tick )
|
|
{
|
|
Host_Error( "Expecting interval_per_tick %f, got %f\n",
|
|
host_state.interval_per_tick, msg->m_fTickInterval );
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
host_state.interval_per_tick = msg->m_fTickInterval;
|
|
}
|
|
|
|
// Re-init hud video, especially if we changed game directories
|
|
ClientDLL_HudVidInit();
|
|
|
|
// Don't verify the map and player .mdl crc's until after any missing resources have
|
|
// been downloaded. This will still occur before requesting the rest of the signon.
|
|
|
|
|
|
gHostSpawnCount = m_nServerCount;
|
|
|
|
videomode->MarkClientViewRectDirty(); // leave intermission full screen
|
|
return true;
|
|
}
|
|
|
|
bool CClientState::ProcessClassInfo( SVC_ClassInfo *msg )
|
|
{
|
|
if ( msg->m_bCreateOnClient )
|
|
{
|
|
#ifndef _XBOX
|
|
if ( !demoplayer->IsPlayingBack() )
|
|
#endif
|
|
{
|
|
// Create all of the send tables locally
|
|
DataTable_CreateClientTablesFromServerTables();
|
|
|
|
// Now create all of the server classes locally, too
|
|
DataTable_CreateClientClassInfosFromServerClasses( this );
|
|
|
|
// store the current data tables in demo file to make sure
|
|
// they are the same during playback
|
|
#ifndef _XBOX
|
|
demorecorder->RecordServerClasses( serverGameDLL->GetAllServerClasses() );
|
|
#endif
|
|
}
|
|
|
|
LinkClasses(); // link server and client classes
|
|
}
|
|
else
|
|
{
|
|
CBaseClientState::ProcessClassInfo( msg );
|
|
}
|
|
|
|
#ifdef DEDICATED
|
|
bool bAllowMismatches = false;
|
|
#else
|
|
bool bAllowMismatches = ( demoplayer && demoplayer->IsPlayingBack() );
|
|
#endif // DEDICATED
|
|
|
|
if ( !RecvTable_CreateDecoders( serverGameDLL->GetStandardSendProxies(), bAllowMismatches ) ) // create receive table decoders
|
|
{
|
|
Host_EndGame( true, "CL_ParseClassInfo_EndClasses: CreateDecoders failed.\n" );
|
|
return false;
|
|
}
|
|
|
|
#ifndef _XBOX
|
|
if ( !demoplayer->IsPlayingBack() )
|
|
#endif
|
|
{
|
|
CLocalNetworkBackdoor::InitFastCopy();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientState::ProcessSetPause( SVC_SetPause *msg )
|
|
{
|
|
CBaseClientState::ProcessSetPause( msg );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientState::ProcessSetPauseTimed( SVC_SetPauseTimed *msg )
|
|
{
|
|
CBaseClientState::ProcessSetPauseTimed( msg );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CClientState::ProcessVoiceInit( SVC_VoiceInit *msg )
|
|
{
|
|
#if !defined( NO_VOICE )//#ifndef _XBOX
|
|
if ( msg->m_szVoiceCodec[0] == 0 )
|
|
{
|
|
Voice_Deinit();
|
|
}
|
|
else
|
|
{
|
|
Voice_Init( msg->m_szVoiceCodec, msg->m_nSampleRate );
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
ConVar voice_debugfeedback( "voice_debugfeedback", "0" );
|
|
|
|
bool CClientState::ProcessVoiceData( SVC_VoiceData *msg )
|
|
{
|
|
char chReceived[4096];
|
|
int bitsRead = msg->m_DataIn.ReadBitsClamped( chReceived, msg->m_nLength );
|
|
|
|
#if defined ( _X360 )
|
|
DWORD dwLength = msg->m_nLength;
|
|
XUID xuid = msg->m_xuid;
|
|
Audio_GetXVoice()->PlayIncomingVoiceData( xuid, (byte*)chReceived, dwLength );
|
|
|
|
if ( voice_debugfeedback.GetBool() )
|
|
{
|
|
Msg( "Received voice from: %d\n", msg->m_nFromClient + 1 );
|
|
}
|
|
|
|
return true;
|
|
#endif
|
|
|
|
#if !defined( NO_VOICE )//#ifndef _XBOX
|
|
int iEntity = msg->m_nFromClient + 1;
|
|
if ( iEntity == (m_nPlayerSlot + 1) )
|
|
{
|
|
Voice_LocalPlayerTalkingAck();
|
|
}
|
|
|
|
player_info_t playerinfo;
|
|
engineClient->GetPlayerInfo( iEntity, &playerinfo );
|
|
|
|
if ( Q_strlen( cl_voice_filter.GetString() ) > 0 && Q_strstr( playerinfo.name, cl_voice_filter.GetString() ) == NULL )
|
|
return true;
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
extern IEngineClientReplay *g_pEngineClientReplay;
|
|
bool bInReplay = engineClient->IsPlayingDemo() && g_pEngineClientReplay && g_pEngineClientReplay->IsPlayingReplayDemo();
|
|
|
|
if ( replay_voice_during_playback == NULL )
|
|
{
|
|
replay_voice_during_playback = g_pCVar->FindVar( "replay_voice_during_playback" );
|
|
Assert( replay_voice_during_playback != NULL );
|
|
}
|
|
|
|
// Don't play back voice data during replay unless the client specified it to.
|
|
if ( bInReplay && replay_voice_during_playback && !replay_voice_during_playback->GetBool() )
|
|
return true;
|
|
#endif
|
|
|
|
// Data length can be zero when the server is just acking a client's voice data.
|
|
if ( bitsRead == 0 )
|
|
return true;
|
|
|
|
if ( !Voice_Enabled() )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Have we already initialized the channels for this guy?
|
|
int nChannel = Voice_GetChannel( iEntity );
|
|
if ( nChannel == VOICE_CHANNEL_ERROR )
|
|
{
|
|
// Create a channel in the voice engine and a channel in the sound engine for this guy.
|
|
nChannel = Voice_AssignChannel( iEntity, msg->m_bProximity );
|
|
if ( nChannel == VOICE_CHANNEL_ERROR )
|
|
{
|
|
// If they used -nosound, then it's not a problem.
|
|
if ( S_IsInitted() )
|
|
ConDMsg("ProcessVoiceData: Voice_AssignChannel failed for client %d!\n", iEntity-1);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Give the voice engine the data (it in turn gives it to the mixer for the sound engine).
|
|
Voice_AddIncomingData( nChannel, chReceived, Bits2Bytes( bitsRead ), m_nCurrentSequence );
|
|
#endif
|
|
return true;
|
|
};
|
|
|
|
bool CClientState::ProcessPrefetch( SVC_Prefetch *msg )
|
|
{
|
|
char const *soundname = cl.GetSoundName( msg->m_nSoundIndex );
|
|
if ( soundname && soundname [ 0 ] )
|
|
{
|
|
EngineSoundClient()->PrefetchSound( soundname );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CClientState::ProcessSoundsWithProtoVersion( SVC_Sounds *msg, CUtlVector< SoundInfo_t > &sounds, int nProtoVersion )
|
|
{
|
|
SoundInfo_t defaultSound; defaultSound.SetDefault();
|
|
SoundInfo_t *pDeltaSound = &defaultSound;
|
|
|
|
// Max is 32 in multiplayer and 255 in singleplayer
|
|
// Reserve this memory up front so it doesn't realloc under pDeltaSound pointing at it
|
|
sounds.EnsureCapacity( 256 );
|
|
|
|
for ( int i = 0; i < msg->m_nNumSounds; i++ )
|
|
{
|
|
int nSound = sounds.AddToTail();
|
|
SoundInfo_t *pSound = &(sounds[ nSound ]);
|
|
|
|
pSound->ReadDelta( pDeltaSound, msg->m_DataIn, nProtoVersion );
|
|
|
|
pDeltaSound = pSound; // copy delta values
|
|
|
|
if ( msg->m_bReliableSound )
|
|
{
|
|
// client is incrementing the reliable sequence numbers itself
|
|
m_nSoundSequence = ( m_nSoundSequence + 1 ) & SOUND_SEQNUMBER_MASK;
|
|
Assert ( pSound->nSequenceNumber == 0 );
|
|
pSound->nSequenceNumber = m_nSoundSequence;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CClientState::ProcessSounds( SVC_Sounds *msg )
|
|
{
|
|
if ( msg->m_DataIn.IsOverflowed() )
|
|
{
|
|
// Overflowed before we even started! There's nothing we can do with this buffer.
|
|
return false;
|
|
}
|
|
|
|
CUtlVector< SoundInfo_t > sounds;
|
|
|
|
int startbit = msg->m_DataIn.GetNumBitsRead();
|
|
|
|
// Process with the reported proto version
|
|
ProcessSoundsWithProtoVersion( msg, sounds, g_ClientGlobalVariables.network_protocol );
|
|
|
|
int nRelativeBitsRead = msg->m_DataIn.GetNumBitsRead() - startbit;
|
|
|
|
if ( msg->m_nLength != nRelativeBitsRead || msg->m_DataIn.IsOverflowed() )
|
|
{
|
|
// The number of bits read is not what we expect!
|
|
sounds.RemoveAll();
|
|
|
|
int nFallbackProtocol = 0;
|
|
|
|
// If the demo file thinks it's version 18 or 19, it might actually be the other.
|
|
// This is a work around for when we broke compatibility Halloween 2011.
|
|
// -Jeep
|
|
if ( g_ClientGlobalVariables.network_protocol == PROTOCOL_VERSION_18 )
|
|
{
|
|
nFallbackProtocol = PROTOCOL_VERSION_19;
|
|
}
|
|
else if ( g_ClientGlobalVariables.network_protocol == PROTOCOL_VERSION_19 )
|
|
{
|
|
nFallbackProtocol = PROTOCOL_VERSION_18;
|
|
}
|
|
|
|
if ( nFallbackProtocol != 0 )
|
|
{
|
|
// Roll back our buffer to before we read those bits and wipe the overflow flag
|
|
msg->m_DataIn.Reset();
|
|
msg->m_DataIn.Seek( startbit );
|
|
|
|
// Try again with the fallback version
|
|
ProcessSoundsWithProtoVersion( msg, sounds, nFallbackProtocol );
|
|
|
|
nRelativeBitsRead = msg->m_DataIn.GetNumBitsRead() - startbit;
|
|
}
|
|
}
|
|
|
|
if ( msg->m_nLength == nRelativeBitsRead )
|
|
{
|
|
// Now that we know the bits were read correctly, add all the sounds
|
|
for ( int i = 0; i < sounds.Count(); ++i )
|
|
{
|
|
// Add all received sounds to sorted queue (sounds may arrive in multiple messages),
|
|
// will be processed after all packets have been completely parsed
|
|
CL_AddSound( sounds[ i ] );
|
|
}
|
|
|
|
// read the correct number of bits
|
|
return true;
|
|
}
|
|
|
|
// Wipe the overflow flag and set the buffer to how much we expected to read
|
|
msg->m_DataIn.Reset();
|
|
msg->m_DataIn.Seek( startbit + msg->m_nLength );
|
|
|
|
// didn't read the correct number of bits with either proto version attempt
|
|
return false;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessFixAngle( SVC_FixAngle *msg )
|
|
{
|
|
for (int i=0 ; i<3 ; i++)
|
|
{
|
|
// Clamp between -180 and 180
|
|
if (msg->m_Angle[i]>180)
|
|
{
|
|
msg->m_Angle[i] -= 360;
|
|
}
|
|
}
|
|
|
|
if ( msg->m_bRelative )
|
|
{
|
|
// Update running counter
|
|
addangletotal += msg->m_Angle[YAW];
|
|
|
|
AddAngle a;
|
|
a.total = addangletotal;
|
|
a.starttime = m_flLastServerTickTime;
|
|
|
|
addangle.AddToTail( a );
|
|
}
|
|
else
|
|
{
|
|
|
|
viewangles = msg->m_Angle;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessCrosshairAngle( SVC_CrosshairAngle *msg )
|
|
{
|
|
g_ClientDLL->SetCrosshairAngle( msg->m_Angle );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessBSPDecal( SVC_BSPDecal *msg )
|
|
{
|
|
model_t * model;
|
|
|
|
if ( msg->m_nEntityIndex )
|
|
{
|
|
model = GetModel( msg->m_nModelIndex );
|
|
}
|
|
else
|
|
{
|
|
model = host_state.worldmodel;
|
|
if ( !model )
|
|
{
|
|
Warning( "ProcessBSPDecal: Trying to project on world before host_state.worldmodel is set!!!\n" );
|
|
}
|
|
}
|
|
|
|
if ( model == NULL )
|
|
{
|
|
IMaterial *mat = Draw_DecalMaterial( msg->m_nDecalTextureIndex );
|
|
char const *matname = "???";
|
|
if ( mat )
|
|
{
|
|
matname = mat->GetName();
|
|
}
|
|
|
|
Warning( "Warning! Static BSP decal (%s), on NULL model index %i for entity index %i.\n",
|
|
matname,
|
|
msg->m_nModelIndex,
|
|
msg->m_nEntityIndex );
|
|
return true;
|
|
}
|
|
|
|
if (r_decals.GetInt())
|
|
{
|
|
g_pEfx->DecalShoot(
|
|
msg->m_nDecalTextureIndex,
|
|
msg->m_nEntityIndex,
|
|
model,
|
|
vec3_origin,
|
|
vec3_angle,
|
|
msg->m_Pos,
|
|
NULL,
|
|
msg->m_bLowPriority ? 0 : FDECAL_PERMANENT );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessGameEvent(SVC_GameEvent *msg)
|
|
{
|
|
tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );
|
|
|
|
int startbit = msg->m_DataIn.GetNumBitsRead();
|
|
|
|
IGameEvent *event = g_GameEventManager.UnserializeEvent( &msg->m_DataIn );
|
|
|
|
int length = msg->m_DataIn.GetNumBitsRead() - startbit;
|
|
|
|
if ( length != msg->m_nLength )
|
|
{
|
|
DevMsg("CClientState::ProcessGameEvent: KeyValue length mismatch.\n" );
|
|
return true;
|
|
}
|
|
|
|
if ( !event )
|
|
{
|
|
DevMsg("CClientState::ProcessGameEvent: UnserializeKeyValue failed.\n" );
|
|
return true;
|
|
}
|
|
|
|
g_GameEventManager.FireEventClientSide( event );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessUserMessage(SVC_UserMessage *msg)
|
|
{
|
|
// buffer for incoming user message
|
|
ALIGN4 byte userdata[ MAX_USER_MSG_DATA ] ALIGN4_POST = { 0 };
|
|
bf_read userMsg( "UserMessage(read)", userdata, sizeof( userdata ) );
|
|
int bitsRead = msg->m_DataIn.ReadBitsClamped( userdata, msg->m_nLength );
|
|
userMsg.StartReading( userdata, Bits2Bytes( bitsRead ) );
|
|
|
|
// dispatch message to client.dll
|
|
if ( !g_ClientDLL->DispatchUserMessage( msg->m_nMsgType, userMsg ) )
|
|
{
|
|
ConMsg( "Couldn't dispatch user message (%i)\n", msg->m_nMsgType );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessEntityMessage(SVC_EntityMessage *msg)
|
|
{
|
|
// Look up entity
|
|
IClientNetworkable *entity = entitylist->GetClientNetworkable( msg->m_nEntityIndex );
|
|
|
|
if ( !entity )
|
|
{
|
|
// message was send to use, even we don't have this entity TODO change that on server side
|
|
return true;
|
|
}
|
|
|
|
// route to entity
|
|
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
|
|
|
|
// buffer for incoming user message
|
|
ALIGN4 byte entityData[ MAX_ENTITY_MSG_DATA ] ALIGN4_POST = { 0 };
|
|
bf_read entMsg( "EntityMessage(read)", entityData, sizeof( entityData ) );
|
|
int bitsRead = msg->m_DataIn.ReadBitsClamped( entityData, msg->m_nLength );
|
|
entMsg.StartReading( entityData, Bits2Bytes( bitsRead ) );
|
|
|
|
entity->ReceiveMessage( msg->m_nClassID, entMsg );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessPacketEntities( SVC_PacketEntities *msg )
|
|
{
|
|
if ( !msg->m_bIsDelta )
|
|
{
|
|
// Delta too old or is initial message
|
|
#ifndef _XBOX
|
|
// we can start recording now that we've received an uncompressed packet
|
|
demorecorder->SetSignonState( SIGNONSTATE_FULL );
|
|
#endif
|
|
// Tell prediction that we're recreating entities due to an uncompressed packet arriving
|
|
if ( g_pClientSidePrediction )
|
|
{
|
|
g_pClientSidePrediction->OnReceivedUncompressedPacket();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_nDeltaTick == -1 )
|
|
{
|
|
// we requested a full update but still got a delta compressed packet. ignore it.
|
|
return true;
|
|
}
|
|
|
|
// Preprocessing primarily does client prediction. So if we're processing deltas--do it
|
|
// otherwise, we're about to be told exactly what the state of everything is--so skip it.
|
|
CL_PreprocessEntities(); // setup client prediction
|
|
}
|
|
|
|
TRACE_PACKET(( "CL Receive (%d <-%d)\n", m_nCurrentSequence, msg->m_nDeltaFrom ));
|
|
TRACE_PACKET(( "CL Num Ents (%d)\n", msg->m_nUpdatedEntries ));
|
|
|
|
if ( g_pLocalNetworkBackdoor )
|
|
{
|
|
if ( m_nSignonState == SIGNONSTATE_SPAWN )
|
|
{
|
|
// We are done with signon sequence.
|
|
SetSignonState( SIGNONSTATE_FULL, m_nServerCount );
|
|
}
|
|
|
|
// ignore message, all entities are transmitted using fast local memcopy routines
|
|
m_nDeltaTick = GetServerTickCount();
|
|
return true;
|
|
}
|
|
|
|
if ( !CL_ProcessPacketEntities ( msg ) )
|
|
return false;
|
|
|
|
return CBaseClientState::ProcessPacketEntities( msg );
|
|
}
|
|
|
|
|
|
bool CClientState::ProcessTempEntities( SVC_TempEntities *msg )
|
|
{
|
|
bool bReliable = false;
|
|
|
|
float fire_time = cl.GetTime();
|
|
|
|
#ifndef _XBOX
|
|
// delay firing temp ents by cl_interp in multiplayer or demoplayback
|
|
if ( cl.m_nMaxClients > 1 || demoplayer->IsPlayingBack() )
|
|
{
|
|
float flInterpAmount = GetClientInterpAmount();
|
|
fire_time += flInterpAmount;
|
|
}
|
|
#endif
|
|
|
|
if ( msg->m_nNumEntries == 0 )
|
|
{
|
|
bReliable = true;
|
|
msg->m_nNumEntries = 1;
|
|
}
|
|
|
|
int flags = bReliable ? FEV_RELIABLE : 0;
|
|
|
|
// Don't actually queue unreliable events if playing a demo and skipping ahead
|
|
#ifndef _XBOX
|
|
if ( !bReliable && demoplayer->IsSkipping() )
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
bf_read &buffer = msg->m_DataIn; // shortcut
|
|
|
|
int classID = -1;
|
|
void *from = NULL;
|
|
C_ServerClassInfo *pServerClass = NULL;
|
|
ClientClass *pClientClass = NULL;
|
|
ALIGN4 unsigned char data[CEventInfo::MAX_EVENT_DATA] ALIGN4_POST;
|
|
bf_write toBuf( data, sizeof(data) );
|
|
CEventInfo *ei = NULL;
|
|
|
|
for (int i = 0; i < msg->m_nNumEntries; i++ )
|
|
{
|
|
float delay = 0.0f;
|
|
|
|
if ( buffer.ReadOneBit() )
|
|
{
|
|
delay = (float)buffer.ReadSBitLong( 8 ) / 100.0f;
|
|
}
|
|
|
|
toBuf.Reset();
|
|
|
|
if ( buffer.ReadOneBit() )
|
|
{
|
|
from = NULL; // full update
|
|
|
|
classID = buffer.ReadUBitLong( m_nServerClassBits ); // classID
|
|
|
|
// Look up the client class, etc.
|
|
|
|
// Match the server classes to the client classes.
|
|
pServerClass = m_pServerClasses ? &m_pServerClasses[ classID - 1 ] : NULL;
|
|
|
|
if ( !pServerClass )
|
|
{
|
|
DevMsg("CL_QueueEvent: missing server class info for %i.\n", classID - 1 );
|
|
return false;
|
|
}
|
|
|
|
// See if the client .dll has a handler for this class
|
|
pClientClass = FindClientClass( pServerClass->m_ClassName );
|
|
|
|
if ( !pClientClass || !pClientClass->m_pRecvTable )
|
|
{
|
|
DevMsg("CL_QueueEvent: missing client receive table for %s.\n", pServerClass->m_ClassName );
|
|
return false;
|
|
}
|
|
|
|
RecvTable_MergeDeltas( pClientClass->m_pRecvTable, NULL, &buffer, &toBuf );
|
|
}
|
|
else
|
|
{
|
|
Assert( ei );
|
|
|
|
unsigned int buffer_size = PAD_NUMBER( Bits2Bytes( ei->bits ), 4 );
|
|
bf_read fromBuf( ei->pData, buffer_size );
|
|
|
|
RecvTable_MergeDeltas( pClientClass->m_pRecvTable, &fromBuf, &buffer, &toBuf );
|
|
}
|
|
|
|
// Add a slot
|
|
ei = &cl.events[ cl.events.AddToTail() ];
|
|
|
|
Assert( ei );
|
|
|
|
int size = Bits2Bytes(toBuf.GetNumBitsWritten() );
|
|
|
|
ei->classID = classID;
|
|
ei->fire_delay = fire_time + delay;
|
|
ei->flags = flags;
|
|
ei->pClientClass = pClientClass;
|
|
ei->bits = toBuf.GetNumBitsWritten();
|
|
|
|
// deltaBitsReader.ReadNextPropIndex reads uint32s, so make sure we alloc in 4-byte chunks.
|
|
ei->pData = new byte[ ALIGN_VALUE( size, 4 ) ]; // copy raw data
|
|
Q_memcpy( ei->pData, data, size );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif // swds
|