Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
csgo-2018-source/engine/servermsghandler.cpp

998 lines
27 KiB
C++
Raw Permalink Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#ifndef DEDICATED
#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 "master.h"
#include "ivideomode.h"
#include "download.h"
#include "GameUI/IGameUI.h"
#if defined( REPLAY_ENABLED )
#include "replayhistorymanager.h"
#endif
#include "cl_demo.h"
#include "audio_pch.h"
#include "paint.h"
// 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
ConVar cl_voice_hltv_buffer_time("cl_voice_hltv_buffer_time", "0.3", 0, "Amount of time between receiving voice data and playing the audio in hltv");
ConVar cl_voice_buffer_time("cl_voice_buffer_time", "0.04", 0, "Amount of time between receiving voice data and playing the audio");
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 ) )
{
g_eSteamLoginFailure = STEAMLOGINFAILURE_BADTICKET;
}
else if ( !Q_stricmp( reason, INVALID_STEAM_LOGON ) )
{
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 the reason is a localized string, pass it raw.
if ( reason && reason[0] == '#' )
COM_ExplainDisconnection( true, "%s", reason );
else
COM_ExplainDisconnection( true, "Disconnect: %s.\n", reason );
SCR_EndLoadingPlaque();
Host_Disconnect(true);
if ( (reason != NULL) && (Q_stricmp( reason, "Server shutting down" ) == 0) && //if disconnect reason is server shutdown
(CommandLine()->FindParm( "-quitonservershutdown" ) != 0) ) //and we want to quit the game whenever the server shuts down (assists quick iteration)
{
Host_Shutdown(); //quit the game
}
}
}
void CClientState::ConnectionCrashed( const char * reason )
{
// if connected, shut down host
if ( m_nSignonState > SIGNONSTATE_NONE )
{
// If the reason is a localized string, pass it raw.
if(reason && reason[0] == '#')
COM_ExplainDisconnection( true, "%s", reason );
else
COM_ExplainDisconnection( true, "Disconnect: %s.\n", reason );
SCR_EndLoadingPlaque();
Host_Disconnect(true);
}
}
void CClientState::FileRequested(const char *fileName, unsigned int transferID, bool isReplayDemoFile )
{
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, isReplayDemoFile );
return;
}
// TODO check if file valid for uploading
m_NetChannel->SendFile( fileName, transferID, isReplayDemoFile );
}
void CClientState::FileReceived( const char * fileName, unsigned int transferID, bool isReplayDemoFile )
{
// check if the client donwload manager requested this file
CL_FileReceived( fileName, transferID, isReplayDemoFile );
}
void CClientState::FileDenied(const char *fileName, unsigned int transferID, bool isReplayDemoFile )
{
// check if the file download manager requested that file
CL_FileDenied( fileName, transferID, isReplayDemoFile );
}
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( "GetBaseLocalClient().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, GetBaseLocalClient().tickcount,
// GetBaseLocalClient().last_command_ack,
// GetBaseLocalClient().netchan->outgoing_sequence - 1,
// commands_acknowledged );
// Highest command parsed from messages
last_command_ack = command_ack;
last_server_tick = GetServerTickCount();
// Let prediction copy off pristine data and report any errors, etc.
g_pClientSidePrediction->PostNetworkDataReceived( commands_acknowledged );
demoaction->DispatchEvents();
}
void CClientState::Disconnect( bool bShowMainMenu )
{
CBaseClientState::Disconnect( bShowMainMenu );
if ( m_bSplitScreenUser )
return;
// clear any map hacks
{
static ConVarRef map_wants_save_disable( "map_wants_save_disable" );
map_wants_save_disable.SetValue( 0 );
}
// stop any demo activities
demoplayer->StopPlayback();
demorecorder->StopRecording();
#if defined( REPLAY_ENABLED )
extern IReplayHistoryManager *g_pClientReplayHistoryManager;
g_pClientReplayHistoryManager->StopDownloads();
#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();
// End any in-progress downloads
CL_HTTPStop_f();
// stop loading progress bar
if ( bShowMainMenu )
{
SCR_EndLoadingPlaque();
}
// notify game ui dll of out-of-in-game status
EngineVGui()->NotifyOfServerDisconnect();
HostState_OnClientDisconnected();
// if we played a demo from the startdemos list, play next one
if ( GetBaseLocalClient().demonum != -1 )
{
CL_NextDemo();
}
}
static bool s_bClientWaitingForHltvReplayTick = false;
bool CClientState::NETMsg_Tick( const CNETMsg_Tick& msg )
{
if ( g_ClientDLL )
{
// Notify the client that we are just about to tick over.
g_ClientDLL->OnTickPre( host_tickcount );
}
int tick = msg.tick();
{
if ( m_nHltvReplayDelay )
{
if ( !msg.hltv_replay_flags() )
DevMsg( "%d. Msg_Tick %d cl:delayed sv:real-time\n", GetClientTickCount(), tick );
}
else
{
if ( msg.hltv_replay_flags() )
DevMsg( "%d. Msg_Tick %d cl:real-time sv:replay\n", GetClientTickCount(), tick );
}
}
if ( m_nHltvReplayDelay && !msg.hltv_replay_flags() )
{
// client is in hltv replay state, but server doesn't remember it - maybe there was a connection issue or something.
DevMsg( "Inconsistent Client Replay state: tick without replay during replay. Force Stop Replay.\n" );
s_bClientWaitingForHltvReplayTick = true;
StopHltvReplay();
}
m_NetChannel->SetRemoteFramerate(
CNETMsg_Tick_t::FrametimeToFloat( msg.host_computationtime() ),
CNETMsg_Tick_t::FrametimeToFloat( msg.host_computationtime_std_deviation() ),
CNETMsg_Tick_t::FrametimeToFloat( msg.host_framestarttime_std_deviation() ) );
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.
if ( s_bClientWaitingForHltvReplayTick && g_ClientDLL )
{
if ( m_nHltvReplayDelay )
{
// we're starting replay. Clean up decals from the future
R_DecalTermNew( host_state.worldmodel->brush.pShared, tick );
}
g_ClientDLL->OnHltvReplayTick();
s_bClientWaitingForHltvReplayTick = false;
}
return true;
}
bool CClientState::NETMsg_StringCmd( const CNETMsg_StringCmd& msg )
{
// Even though this is just forwarding to the base class, do not remove this function.
// There are multiple implementations of CClientState and the one in cl_null.cpp
// stubs this function out as a simple 'return true;'.
return BaseClass::NETMsg_StringCmd( msg );
}
bool CClientState::SVCMsg_ServerInfo( const CSVCMsg_ServerInfo& msg )
{
// Reset client state
CL_ClearState();
if ( !CBaseClientState::SVCMsg_ServerInfo( msg ) )
{
Disconnect(true);
return false;
}
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 );
}
// is server a HLTV proxy ?
ishltv = msg.is_hltv();
#if defined( REPLAY_ENABLED )
// is server a replay proxy ?
isreplay = msg.is_replay();
#endif
// The CRC of the server map must match the CRC of the client map. or else
// the client is probably cheating.
serverCRC = msg.map_crc();
// The client side DLL CRC check.
serverClientSideDllCRC = msg.client_crc();
g_ClientGlobalVariables.maxClients = m_nMaxClients;
g_ClientGlobalVariables.network_protocol = msg.protocol();
#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.tick_interval() != host_state.interval_per_tick )
{
Host_Error( "Expecting interval_per_tick %f, got %f\n",
host_state.interval_per_tick, msg.tick_interval() );
return false;
}
}
else
{
host_state.interval_per_tick = msg.tick_interval();
}
// 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::SVCMsg_ClassInfo( const CSVCMsg_ClassInfo& msg )
{
if ( msg.create_on_client() )
{
if ( !demoplayer->IsPlayingBack() )
{
// 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
demorecorder->RecordServerClasses( serverGameDLL->GetAllServerClasses() );
}
LinkClasses(); // link server and client classes
}
else
{
CBaseClientState::SVCMsg_ClassInfo( msg );
}
bool bAllowMismatches = ( g_pClientDemoPlayer && g_pClientDemoPlayer->IsPlayingBack() );
if ( !RecvTable_CreateDecoders( serverGameDLL->GetStandardSendProxies(), bAllowMismatches ) ) // create receive table decoders
{
Host_EndGame( true, "CL_ParseClassInfo_EndClasses: CreateDecoders failed.\n" );
return false;
}
if ( !demoplayer->IsPlayingBack() )
{
CLocalNetworkBackdoor::InitFastCopy();
}
return true;
}
bool CClientState::SVCMsg_SetPause( const CSVCMsg_SetPause& msg )
{
CBaseClientState::SVCMsg_SetPause( msg );
return true;
}
bool CClientState::SVCMsg_VoiceInit( const CSVCMsg_VoiceInit& msg )
{
#if !defined( NO_VOICE )
if( msg.codec().size() == 0 )
{
Voice_Deinit();
}
else
{
#define SPEEX_QUALITY 4
Voice_Init( msg.codec().c_str(), msg.has_version() ? msg.version() : SPEEX_QUALITY );
}
#endif
return true;
}
ConVar voice_debugfeedback( "voice_debugfeedback", "0" );
bool CClientState::SVCMsg_VoiceData( const CSVCMsg_VoiceData &msg )
{
#if defined ( _GAMECONSOLE )
FOR_EACH_VALID_SPLITSCREEN_PLAYER( i )
{
if ( msg.client() == GetLocalClient( i ).m_nPlayerSlot )
return true;
}
ConVarRef voice_verbose( "voice_verbose" );
if ( voice_verbose.GetBool() )
{
Msg( "* CClientState::ProcessVoiceData: playing SVC_VoiceData from %s with %u bytes\n", msg.GetNetChannel()->GetAddress(), msg.voice_data_size() );
}
Audio_GetXVoice()->PlayIncomingVoiceData( msg.xuid(), (const byte*)&msg.voice_data[0], msg.voice_data_size(), bAudible );
if ( voice_debugfeedback.GetBool() )
{
Msg( "%f Received voice from: %d [%d bytes]\n", realtime, msg->m_nFromClient + 1, dwLength );
}
return true;
#endif
#if !defined( NO_VOICE )
if ( voice_debugfeedback.GetBool() )
{
Msg( "Received voice from: %d\n", msg.client() + 1 );
}
int iEntity = msg.client() + 1;
if ( iEntity == (m_nPlayerSlot + 1) )
{
Voice_LocalPlayerTalkingAck( m_nSplitScreenSlot );
}
player_info_t playerinfo;
engineClient->GetPlayerInfo( iEntity, &playerinfo );
CSteamID voicePlayer( playerinfo.xuid );
if ( Q_strlen( cl_voice_filter.GetString() ) > 0 && Q_strstr( playerinfo.name, cl_voice_filter.GetString() ) == NULL )
return true;
// Data length can be zero when the server is just acking a client's voice data.
if ( msg.voice_data().size() == 0 )
return true;
if ( !Voice_SystemEnabled() )
return true;
bool bIsCaster = msg.has_caster() && msg.caster();
// if this voice data is for a caster that is not enabled, then bail
if ( bIsCaster && !Voice_CasterEnabled( voicePlayer.GetAccountID() ) )
return true;
// if voice is enabled or it's a caster and caster voice is enabled.
if ( Voice_Enabled() || ( Voice_CasterEnabled( voicePlayer.GetAccountID() ) && bIsCaster ) )
{
// 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.
float flBufferTime = GetBaseLocalClient().ishltv ? cl_voice_hltv_buffer_time.GetFloat() : cl_voice_buffer_time.GetFloat();
nChannel = Voice_AssignChannel( iEntity, msg.proximity(), bIsCaster, flBufferTime );
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,
&msg.voice_data()[0],
msg.voice_data().size(),
msg.has_section_number() ? msg.section_number() : 0,
msg.has_sequence_bytes() ? msg.sequence_bytes() : 0,
msg.has_uncompressed_sample_offset() ? msg.uncompressed_sample_offset() : 0,
( msg.has_format() && ( msg.format() == VOICEDATA_FORMAT_STEAM ) ) ? VoiceFormat_Steam : VoiceFormat_Engine );
}
#endif
return true;
};
bool CClientState::SVCMsg_Prefetch( const CSVCMsg_Prefetch& msg )
{
char const *soundname = GetBaseLocalClient().GetSoundName( msg.sound_index() );
if ( soundname && soundname [ 0 ] )
{
EngineSoundClient()->PrefetchSound( soundname );
}
return true;
}
bool CClientState::SVCMsg_Sounds( const CSVCMsg_Sounds& msg )
{
SoundInfo_t defaultSound;
SoundInfo_t *pDeltaSound = &defaultSound;
SoundInfo_t sound;
int nNumSounds = msg.sounds_size();
for ( int i=0; i<nNumSounds; i++ )
{
const CSVCMsg_Sounds::sounddata_t& SoundData = msg.sounds( i );
sound.ReadDelta( pDeltaSound, SoundData );
pDeltaSound = &sound; // copy delta values
if ( msg.reliable_sound() )
{
// client is incrementing the reliable sequence numbers itself
m_nSoundSequence = ( m_nSoundSequence + 1 ) & SOUND_SEQNUMBER_MASK;
Assert ( sound.nSequenceNumber == 0 );
sound.nSequenceNumber = m_nSoundSequence;
}
// 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( sound );
}
// check given length against read bits
return true;
}
bool CClientState::SVCMsg_FixAngle( const CSVCMsg_FixAngle &msg )
{
const CMsgQAngle& angle = msg.angle();
QAngle qangle( angle.x(), angle.y(), angle.z() );
for (int i=0 ; i<3 ; i++)
{
// Clamp between -180 and 180
if (qangle[i]>180)
{
qangle[i] -= 360;
}
}
if ( msg.relative() )
{
// Update running counter
addangletotal += qangle[YAW];
AddAngle a;
a.total = addangletotal;
a.starttime = m_flLastServerTickTime;
addangle.AddToTail( a );
}
else
{
viewangles = qangle;
}
return true;
}
bool CClientState::SVCMsg_CrosshairAngle( const CSVCMsg_CrosshairAngle& msg )
{
const CMsgQAngle& angle = msg.angle();
const QAngle qangle( angle.x(), angle.y(), angle.z() );
g_ClientDLL->SetCrosshairAngle( qangle );
return true;
}
bool CClientState::SVCMsg_BSPDecal( const CSVCMsg_BSPDecal& msg )
{
model_t * model;
if ( msg.entity_index() )
{
model = GetModel( msg.model_index() );
}
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.decal_texture_index() );
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.model_index(),
msg.entity_index() );
return true;
}
if (r_decals.GetInt())
{
const CMsgVector& pos = msg.pos();
const Vector vecPos( pos.x(), pos.y(), pos.z() );
g_pEfx->DecalShoot(
msg.decal_texture_index(),
msg.entity_index(),
model,
vec3_origin,
vec3_angle,
vecPos,
NULL,
msg.low_priority() ? 0 : FDECAL_PERMANENT );
}
return true;
}
bool CClientState::SVCMsg_GameEvent(const CSVCMsg_GameEvent& msg)
{
IGameEvent *event = g_GameEventManager.UnserializeEvent( msg );
if ( !event )
{
DevMsg("CClientState::ProcessGameEvent: UnserializeKeyValue failed.\n" );
return true;
}
if ( msg.passthrough() == 1 )
{
// this should only come to clients while they have replay in progress
event->SetBool( "realtime_passthrough", true );
}
g_GameEventManager.FireEventClientSide( event );
return true;
}
bool CClientState::SVCMsg_UserMessage( const CSVCMsg_UserMessage &msg)
{
if ( !g_ClientDLL->DispatchUserMessage( msg.msg_type(), msg.passthrough(), msg.msg_data().size(), &msg.msg_data()[0] ) )
{
ConMsg( "Couldn't dispatch user message (%i)\n", msg.msg_type() );
return false;
}
return true;
}
bool CClientState::SVCMsg_EntityMsg( const CSVCMsg_EntityMsg& msg )
{
// Look up entity
IClientNetworkable *entity = entitylist->GetClientNetworkable( msg.ent_index() );
if ( !entity )
{
int idx = queuedmessage.AddToTail();
CQueuedEntityMessage *pMessage = &queuedmessage[idx];
pMessage->m_msg.CopyFrom( msg );
return true;
}
// route to entity
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
bf_read entMsg;
entMsg.StartReading( msg.ent_data().data(), msg.ent_data().size() );
entity->ReceiveMessage( msg.class_id(), entMsg );
return true;
}
bool CClientState::SVCMsg_PacketEntities( const CSVCMsg_PacketEntities &msg )
{
CL_PreprocessEntities(); // setup client prediction
if ( !msg.is_delta() )
{
// Delta too old or is initial message
// we can start recording now that we've received an uncompressed packet
demorecorder->SetSignonState( SIGNONSTATE_FULL );
// 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;
}
}
TRACE_PACKET(( "CL Receive (%d <-%d)\n", m_nCurrentSequence, msg.delta_from() ));
TRACE_PACKET(( "CL Num Ents (%d)\n", msg.updated_entries() ));
if ( g_pLocalNetworkBackdoor )
{
if ( m_nSignonState == SIGNONSTATE_SPAWN )
{
// We are done with signon sequence.
SetSignonState( SIGNONSTATE_FULL, m_nServerCount, NULL );
}
// ignore message, all entities are transmitted using fast local memcopy routines
m_nDeltaTick = GetServerTickCount();
return true;
}
if ( !CL_ProcessPacketEntities( msg ) )
return false;
return CBaseClientState::SVCMsg_PacketEntities( msg );
}
bool CClientState::SVCMsg_TempEntities( const CSVCMsg_TempEntities &msg )
{
bool bReliable = msg.reliable();
float fire_time = GetBaseLocalClient().GetTime();
// delay firing temp ents by cl_interp in multiplayer or demoplayback
if ( GetBaseLocalClient().m_nMaxClients > 1 || demoplayer->IsPlayingBack() )
{
float flInterpAmount = GetClientInterpAmount();
fire_time += flInterpAmount;
}
int numEntries = msg.num_entries();
if ( numEntries == 0 )
{
bReliable = true;
numEntries = 1;
}
int flags = bReliable ? FEV_RELIABLE : 0;
// Don't actually queue unreliable events if playing a demo and skipping ahead
if ( !bReliable && demoplayer->IsSkipping() )
{
return true;
}
bf_read buffer( &msg.entity_data()[0], msg.entity_data().size() );
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;
CUtlFixedLinkedList< CEventInfo > &eventList = GetBaseLocalClient().events;
class CAutoCleanupHandle
{
public:
explicit CAutoCleanupHandle( SerializedEntityHandle_t handle ) : m_Handle( handle )
{
}
~CAutoCleanupHandle()
{
g_pSerializedEntities->ReleaseSerializedEntity( m_Handle );
}
private:
SerializedEntityHandle_t m_Handle;
};
SerializedEntityHandle_t incoming = g_pSerializedEntities->AllocateSerializedEntity(__FILE__, __LINE__);
CAutoCleanupHandle cleanup( incoming );
for (int i = 0; i < numEntries; i++ )
{
float delay = 0.0f;
if ( buffer.ReadOneBit() )
{
delay = (float)buffer.ReadSBitLong( 8 ) / 100.0f;
}
toBuf.Reset();
SerializedEntityHandle_t merged = g_pSerializedEntities->AllocateSerializedEntity(__FILE__, __LINE__);
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;
}
// Incoming data
RecvTable_ReadFieldList( pClientClass->m_pRecvTable, buffer, incoming, -1, false );
RecvTable_MergeDeltas( pClientClass->m_pRecvTable, SERIALIZED_ENTITY_HANDLE_INVALID, incoming, merged );
}
else
{
Assert( eventList.Tail() != eventList.InvalidIndex() );
CEventInfo *previous = &eventList[ eventList.Tail() ];
RecvTable_ReadFieldList( pClientClass->m_pRecvTable, buffer, incoming, -1, false );
RecvTable_MergeDeltas( pClientClass->m_pRecvTable, previous->m_Packed, incoming, merged );
}
// Add a slot
ei = &GetBaseLocalClient().events[ GetBaseLocalClient().events.AddToTail() ];
Assert( ei );
ei->classID = classID;
ei->fire_delay = fire_time + delay;
ei->flags = flags;
ei->pClientClass = pClientClass;
ei->m_Packed = merged;
}
return true;
}
bool CClientState::SVCMsg_PaintmapData( const CSVCMsg_PaintmapData& msg )
{
int nDword = ( Bits2Bytes( msg.paintmap().size() ) + 3 ) / 4;
CUtlVector< uint32 > data;
data.SetCount( nDword );
bf_read dataIn;
dataIn.ReadBits( const_cast<char*>(msg.paintmap().data()), msg.paintmap().size() );
//handle endian issue between platforms
CByteswap swap;
swap.ActivateByteSwapping( !CByteswap::IsMachineBigEndian() );
swap.SwapBufferToTargetEndian( data.Base(), data.Base(), nDword );
if ( data.Count() > 0 )
{
g_PaintManager.LoadPaintmapDataRLE( data );
}
return true;
}
bool CClientState::SVCMsg_HltvReplay( const CSVCMsg_HltvReplay &msg )
{
VPROF( "HltvReplayStart" );
DevMsg( "%d. Msg_HltvReplay %s->%s\n", GetClientTickCount(), m_nHltvReplayDelay ? "replay" : "real-time", msg.delay() ? "replay" : "real-time" );
int nWasDelay = m_nHltvReplayDelay;
m_nHltvReplayDelay = msg.delay();
m_nHltvReplayStopAt = msg.replay_stop_at();
m_nHltvReplayStartAt = msg.replay_start_at();
float flRate = msg.replay_slowdown_rate();
if ( flRate > 0 )
{
m_nHltvReplaySlowdownBeginAt = msg.replay_slowdown_begin();
m_nHltvReplaySlowdownEndAt = msg.replay_slowdown_end();
m_flHltvReplaySlowdownRate = flRate;
}
else
{
m_nHltvReplaySlowdownBeginAt = 0;
m_nHltvReplaySlowdownEndAt = 0;
m_flHltvReplaySlowdownRate = 1.0f;
}
if ( g_ClientDLL )
{
g_ClientDLL->OnHltvReplay( msg );
s_bClientWaitingForHltvReplayTick = true; // waiting for a tick message after the hltv replay either starts or stops: it will carry the new tick to time replay fades etc.
}
if ( !m_nHltvReplayDelay != !nWasDelay )
{
// clean up frame history, because we're about to start new history.
// this is only useful when we're switching the timeline between HLTV and non-HLTV streams:
// the same frame encodes different information in these two modes, and we can't decode delta frames in one timeline based on the full frames in another.
// It's tolerable from networking perspective because every time we switch the mode, the server forces a full frame update immediately after this message.
// It's NOT VALID to delete client frames when we don't switch the modes, because the server WILL NOT send a full frame update
DeleteClientFrames( -1 );
}
return true;
}
#endif // swds
Reference in New Issue Copy Permalink