H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ToGLES3
source-engine/engine/sv_client.cpp

1683 lines
41 KiB
C++
Raw Permalink Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "server_pch.h"
#include "framesnapshot.h"
#include "checksum_engine.h"
#include "sv_main.h"
#include "GameEventManager.h"
#include "networkstringtable.h"
#include "demo.h"
#include "PlayerState.h"
#include "tier0/vprof.h"
#include "sv_packedentities.h"
#include "LocalNetworkBackdoor.h"
#include "testscriptmgr.h"
#include "hltvserver.h"
#include "pr_edict.h"
#include "logofile_shared.h"
#include "dt_send_eng.h"
#include "sv_plugin.h"
#include "download.h"
#include "cmodel_engine.h"
#include "tier1/CommandBuffer.h"
#include "gl_cvars.h"
#if defined( REPLAY_ENABLED )
#include "replayserver.h"
#include "replay_internal.h"
#endif
#include "tier2/tier2.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern CNetworkStringTableContainer *networkStringTableContainerServer;
static ConVar sv_timeout( "sv_timeout", "65", 0, "After this many seconds without a message from a client, the client is dropped" );
static ConVar sv_maxrate( "sv_maxrate", "0", FCVAR_REPLICATED, "Max bandwidth rate allowed on server, 0 == unlimited" );
static ConVar sv_minrate( "sv_minrate", "3500", FCVAR_REPLICATED, "Min bandwidth rate allowed on server, 0 == unlimited" );
ConVar sv_maxupdaterate( "sv_maxupdaterate", "66", FCVAR_REPLICATED, "Maximum updates per second that the server will allow" );
ConVar sv_minupdaterate( "sv_minupdaterate", "10", FCVAR_REPLICATED, "Minimum updates per second that the server will allow" );
ConVar sv_stressbots("sv_stressbots", "0", FCVAR_DEVELOPMENTONLY, "If set to 1, the server calculates data and fills packets to bots. Used for perf testing.");
static ConVar sv_allowdownload ("sv_allowdownload", "1", 0, "Allow clients to download files");
static ConVar sv_allowupload ("sv_allowupload", "1", 0, "Allow clients to upload customizations files");
ConVar sv_sendtables ( "sv_sendtables", "0", FCVAR_DEVELOPMENTONLY, "Force full sendtable sending path." );
extern ConVar sv_maxreplay;
extern ConVar tv_snapshotrate;
extern ConVar tv_transmitall;
extern ConVar sv_pure_kick_clients;
extern ConVar sv_pure_trace;
// static ConVar sv_failuretime( "sv_failuretime", "0.5", 0, "After this long without a packet from client, don't send any more until client starts sending again" );
static const char * s_clcommands[] =
{
"status",
"pause",
"setpause",
"unpause",
"ping",
"rpt_server_enable",
"rpt_client_enable",
#ifndef SWDS
"rpt",
"rpt_connect",
"rpt_password",
"rpt_screenshot",
"rpt_download_log",
#endif
NULL,
};
// Used on the server and on the client to bound its cl_rate cvar.
int ClampClientRate( int nRate )
{
if ( sv_maxrate.GetInt() > 0 )
{
nRate = clamp( nRate, MIN_RATE, sv_maxrate.GetInt() );
}
if ( sv_minrate.GetInt() > 0 )
{
nRate = clamp( nRate, sv_minrate.GetInt(), MAX_RATE );
}
return nRate;
}
CGameClient::CGameClient(int slot, CBaseServer *pServer )
{
Clear();
m_nClientSlot = slot;
m_nEntityIndex = slot+1;
m_Server = pServer;
m_pCurrentFrame = NULL;
m_bIsInReplayMode = false;
// NULL out data we'll never use.
memset( &m_PrevPackInfo, 0, sizeof( m_PrevPackInfo ) );
m_PrevPackInfo.m_pTransmitEdict = &m_PrevTransmitEdict;
}
CGameClient::~CGameClient()
{
}
bool CGameClient::ProcessClientInfo( CLC_ClientInfo *msg )
{
CBaseClient::ProcessClientInfo( msg );
if ( m_bIsHLTV )
{
// Likely spoofing, or misconfiguration. Don't let Disconnect pathway believe this is a replay bot, it will
// asplode.
m_bIsHLTV = false;
Disconnect( "ProcessClientInfo: SourceTV can not connect to game directly.\n" );
return false;
}
#if defined( REPLAY_ENABLED )
if ( m_bIsReplay )
{
// Likely spoofing, or misconfiguration. Don't let Disconnect pathway believe this is an hltv bot, it will
// asplode.
m_bIsReplay = false;
Disconnect( "ProcessClientInfo: Replay can not connect to game directly.\n" );
return false;
}
#endif
if ( sv_allowupload.GetBool() )
{
// download all missing customizations files from this client;
DownloadCustomizations();
}
return true;
}
bool CGameClient::ProcessMove(CLC_Move *msg)
{
// Don't process usercmds until the client is active. If we do, there can be weird behavior
// like the game trying to send reliable messages to the client and having those messages discarded.
if ( !IsActive() )
return true;
if ( m_LastMovementTick == sv.m_nTickCount )
{
// Only one movement command per frame, someone is cheating.
return true;
}
m_LastMovementTick = sv.m_nTickCount;
int totalcmds =msg->m_nBackupCommands + msg->m_nNewCommands;
// Decrement drop count by held back packet count
int netdrop = m_NetChannel->GetDropNumber();
bool ignore = !sv.IsActive();
#ifdef SWDS
bool paused = sv.IsPaused();
#else
bool paused = sv.IsPaused() || ( !sv.IsMultiplayer() && Con_IsVisible() );
#endif
// Make sure player knows of correct server time
g_ServerGlobalVariables.curtime = sv.GetTime();
g_ServerGlobalVariables.frametime = host_state.interval_per_tick;
// COM_Log( "sv.log", " executing %i move commands from client starting with command %i(%i)\n",
// numcmds,
// m_Client->m_NetChan->incoming_sequence,
// m_Client->m_NetChan->incoming_sequence & SV_UPDATE_MASK );
int startbit = msg->m_DataIn.GetNumBitsRead();
serverGameClients->ProcessUsercmds
(
edict, // Player edict
&msg->m_DataIn,
msg->m_nNewCommands,
totalcmds, // Commands in packet
netdrop, // Number of dropped commands
ignore, // Don't actually run anything
paused // Run, but don't actually do any movement
);
if ( msg->m_DataIn.IsOverflowed() )
{
Disconnect( "ProcessUsercmds: Overflowed reading usercmd data (check sending and receiving code for mismatches)!\n" );
return false;
}
int endbit = msg->m_DataIn.GetNumBitsRead();
if ( msg->m_nLength != (endbit-startbit) )
{
Disconnect( "ProcessUsercmds: Incorrect reading frame (check sending and receiving code for mismatches)!\n" );
return false;
}
return true;
}
bool CGameClient::ProcessVoiceData( CLC_VoiceData *msg )
{
char voiceDataBuffer[4096];
int bitsRead = msg->m_DataIn.ReadBitsClamped( voiceDataBuffer, msg->m_nLength );
SV_BroadcastVoiceData( this, Bits2Bytes(bitsRead), voiceDataBuffer, msg->m_xuid );
return true;
}
bool CGameClient::ProcessCmdKeyValues( CLC_CmdKeyValues *msg )
{
serverGameClients->ClientCommandKeyValues( edict, msg->GetKeyValues() );
return true;
}
bool CGameClient::ProcessRespondCvarValue( CLC_RespondCvarValue *msg )
{
if ( msg->m_iCookie > 0 )
{
if ( g_pServerPluginHandler )
g_pServerPluginHandler->OnQueryCvarValueFinished( msg->m_iCookie, edict, msg->m_eStatusCode, msg->m_szCvarName, msg->m_szCvarValue );
}
else
{
// Negative cookie means the game DLL asked for the value.
if ( serverGameDLL && g_iServerGameDLLVersion >= 6 )
{
#ifdef REL_TO_STAGING_MERGE_TODO
serverGameDLL->OnQueryCvarValueFinished( msg->m_iCookie, edict, msg->m_eStatusCode, msg->m_szCvarName, msg->m_szCvarValue );
#endif
}
}
return true;
}
#include "pure_server.h"
bool CGameClient::ProcessFileCRCCheck( CLC_FileCRCCheck *msg )
{
// Ignore this message if we're not in pure server mode...
if ( !sv.IsInPureServerMode() )
return true;
char warningStr[1024] = {0};
// The client may send us files we don't care about, so filter them here
// if ( !sv.GetPureServerWhitelist()->GetForceMatchList()->IsFileInList( msg->m_szFilename ) )
// return true;
// first check against all the other files users have sent
FileHash_t filehash;
filehash.m_md5contents = msg->m_MD5;
filehash.m_crcIOSequence = msg->m_CRCIOs;
filehash.m_eFileHashType = msg->m_eFileHashType;
filehash.m_cbFileLen = msg->m_nFileFraction;
filehash.m_nPackFileNumber = msg->m_nPackFileNumber;
filehash.m_PackFileID = msg->m_PackFileID;
const char *path = msg->m_szPathID;
const char *fileName = msg->m_szFilename;
if ( g_PureFileTracker.DoesFileMatch( path, fileName, msg->m_nFileFraction, &filehash, GetNetworkID() ) )
{
// track successful file
}
else
{
V_snprintf( warningStr, sizeof( warningStr ), "Pure server: file [%s]\\%s does not match the server's file.", path, fileName );
}
// still ToDo:
// 1. make sure the user sends some files
// 2. make sure the user doesnt skip any files
// 3. make sure the user sends the right files...
if ( warningStr[0] )
{
if ( sv_pure_kick_clients.GetInt() )
{
Disconnect( "%s", warningStr );
}
else
{
ClientPrintf( "Warning: %s\n", warningStr );
if ( sv_pure_trace.GetInt() >= 1 )
{
Msg( "[%s] %s\n", GetNetworkIDString(), warningStr );
}
}
}
else
{
if ( sv_pure_trace.GetInt() >= 2 )
{
Msg( "Pure server CRC check: client %s passed check for [%s]\\%s\n", GetClientName(), msg->m_szPathID, msg->m_szFilename );
}
}
return true;
}
bool CGameClient::ProcessFileMD5Check( CLC_FileMD5Check *msg )
{
// Legacy message
return true;
}
#if defined( REPLAY_ENABLED )
bool CGameClient::ProcessSaveReplay( CLC_SaveReplay *pMsg )
{
// Don't allow on listen servers
if ( !sv.IsDedicated() )
return false;
if ( !g_pReplay )
return false;
g_pReplay->SV_NotifyReplayRequested();
return true;
}
#endif
void CGameClient::DownloadCustomizations()
{
for ( int i=0; i<MAX_CUSTOM_FILES; i++ )
{
if ( m_nCustomFiles[i].crc == 0 )
continue; // slot not used
CCustomFilename hexname( m_nCustomFiles[i].crc );
if ( g_pFileSystem->FileExists( hexname.m_Filename, "game" ) )
continue; // we already have it
// we don't have it, request download from client
m_nCustomFiles[i].reqID = m_NetChannel->RequestFile( hexname.m_Filename );
}
}
void CGameClient::Connect( const char * szName, int nUserID, INetChannel *pNetChannel, bool bFakePlayer, int clientChallenge )
{
CBaseClient::Connect( szName, nUserID, pNetChannel, bFakePlayer, clientChallenge );
edict = EDICT_NUM( m_nEntityIndex );
// init PackInfo
m_PackInfo.m_pClientEnt = edict;
m_PackInfo.m_nPVSSize = sizeof( m_PackInfo.m_PVS );
// fire global game event - server only
IGameEvent *event = g_GameEventManager.CreateEvent( "player_connect" );
{
event->SetInt( "userid", m_UserID );
event->SetInt( "index", m_nClientSlot );
event->SetString( "name", m_Name );
event->SetString("networkid", GetNetworkIDString() );
event->SetString( "address", m_NetChannel?m_NetChannel->GetAddress():"none" );
event->SetInt( "bot", m_bFakePlayer?1:0 );
g_GameEventManager.FireEvent( event, true );
}
// the only difference here is we don't send an
// IP to prevent hackers from doing evil things
event = g_GameEventManager.CreateEvent( "player_connect_client" );
if ( event )
{
event->SetInt( "userid", m_UserID );
event->SetInt( "index", m_nClientSlot );
event->SetString( "name", m_Name );
event->SetString( "networkid", GetNetworkIDString() );
event->SetInt( "bot", m_bFakePlayer ? 1 : 0 );
g_GameEventManager.FireEvent( event );
}
}
void CGameClient::SetupPackInfo( CFrameSnapshot *pSnapshot )
{
// Compute Vis for each client
m_PackInfo.m_nPVSSize = (GetCollisionBSPData()->numclusters + 7) / 8;
serverGameClients->ClientSetupVisibility( (edict_t *)m_pViewEntity,
m_PackInfo.m_pClientEnt, m_PackInfo.m_PVS, m_PackInfo.m_nPVSSize );
// This is the frame we are creating, i.e., the next
// frame after the last one that the client acknowledged
m_pCurrentFrame = AllocateFrame();
m_pCurrentFrame->Init( pSnapshot );
m_PackInfo.m_pTransmitEdict = &m_pCurrentFrame->transmit_entity;
// if this client is the HLTV or Replay client, add the nocheck PVS bit array
// normal clients don't need that extra array
#ifndef _XBOX
#if defined( REPLAY_ENABLED )
if ( IsHLTV() || IsReplay() )
#else
if ( IsHLTV() )
#endif
{
// the hltv client doesn't has a ClientFrame list
m_pCurrentFrame->transmit_always = new CBitVec<MAX_EDICTS>;
m_PackInfo.m_pTransmitAlways = m_pCurrentFrame->transmit_always;
}
else
#endif
{
m_PackInfo.m_pTransmitAlways = NULL;
}
// Add frame to ClientFrame list
int nMaxFrames = MAX_CLIENT_FRAMES;
if ( sv_maxreplay.GetFloat() > 0 )
{
// if the server has replay features enabled, allow a way bigger frame buffer
nMaxFrames = max ( (float)nMaxFrames, sv_maxreplay.GetFloat() / m_Server->GetTickInterval() );
}
if ( nMaxFrames < AddClientFrame( m_pCurrentFrame ) )
{
// If the client has more than 64 frames, the server will start to eat too much memory.
RemoveOldestFrame();
}
// Since area to area visibility is determined by each player's PVS, copy
// the area network lookups into the ClientPackInfo_t
m_PackInfo.m_AreasNetworked = 0;
int areaCount = g_AreasNetworked.Count();
for ( int j = 0; j < areaCount; j++ )
{
m_PackInfo.m_Areas[m_PackInfo.m_AreasNetworked] = g_AreasNetworked[ j ];
m_PackInfo.m_AreasNetworked++;
// Msg("CGameClient::SetupPackInfo: too much areas (%i)", areaCount );
Assert( m_PackInfo.m_AreasNetworked < MAX_WORLD_AREAS );
}
CM_SetupAreaFloodNums( m_PackInfo.m_AreaFloodNums, &m_PackInfo.m_nMapAreas );
}
void CGameClient::SetupPrevPackInfo()
{
memcpy( &m_PrevTransmitEdict, m_PackInfo.m_pTransmitEdict, sizeof( m_PrevTransmitEdict ) );
// Copy the relevant fields into m_PrevPackInfo.
m_PrevPackInfo.m_AreasNetworked = m_PackInfo.m_AreasNetworked;
memcpy( m_PrevPackInfo.m_Areas, m_PackInfo.m_Areas, sizeof( m_PackInfo.m_Areas[0] ) * m_PackInfo.m_AreasNetworked );
m_PrevPackInfo.m_nPVSSize = m_PackInfo.m_nPVSSize;
memcpy( m_PrevPackInfo.m_PVS, m_PackInfo.m_PVS, m_PackInfo.m_nPVSSize );
m_PrevPackInfo.m_nMapAreas = m_PackInfo.m_nMapAreas;
memcpy( m_PrevPackInfo.m_AreaFloodNums, m_PackInfo.m_AreaFloodNums, m_PackInfo.m_nMapAreas * sizeof( m_PackInfo.m_nMapAreas ) );
}
/*
================
CheckRate
Make sure channel rate for active client is within server bounds
================
*/
void CGameClient::SetRate(int nRate, bool bForce )
{
if ( !bForce )
{
nRate = ClampClientRate( nRate );
}
CBaseClient::SetRate( nRate, bForce );
}
void CGameClient::SetUpdateRate(int udpaterate, bool bForce)
{
if ( !bForce )
{
if ( sv_maxupdaterate.GetInt() > 0 )
{
udpaterate = clamp( udpaterate, 1, sv_maxupdaterate.GetInt() );
}
if ( sv_minupdaterate.GetInt() > 0 )
{
udpaterate = clamp( udpaterate, sv_minupdaterate.GetInt(), 100 );
}
}
CBaseClient::SetUpdateRate( udpaterate, bForce );
}
void CGameClient::UpdateUserSettings()
{
// set voice loopback
m_bVoiceLoopback = m_ConVars->GetInt( "voice_loopback", 0 ) != 0;
CBaseClient::UpdateUserSettings();
// Give entity dll a chance to look at the changes.
// Do this after CBaseClient::UpdateUserSettings() so name changes like prepending a (1)
// take effect before the server dll sees the name.
g_pServerPluginHandler->ClientSettingsChanged( edict );
}
//-----------------------------------------------------------------------------
// Purpose: A File has been received, if it's a logo, send it on to any other players who need it
// and return true, otherwise, return false
// Input : *cl -
// *filename -
// Output : Returns true on success, false on failure.
/*-----------------------------------------------------------------------------
bool CGameClient::ProcessIncomingLogo( const char *filename )
{
char crcfilename[ 512 ];
char logohex[ 16 ];
Q_binarytohex( (byte *)&logo, sizeof( logo ), logohex, sizeof( logohex ) );
Q_snprintf( crcfilename, sizeof( crcfilename ), "materials/decals/downloads/%s.vtf", logohex );
// It's not a logo file?
if ( Q_strcasecmp( filename, crcfilename ) )
{
return false;
}
// First, make sure crc is valid
CRC32_t check;
CRC_File( &check, crcfilename );
if ( check != logo )
{
ConMsg( "Incoming logo file didn't match player's logo CRC, ignoring\n" );
// Still note that it was a logo!
return true;
}
// Okay, looks good, see if any other players need this logo file
SV_SendLogo( check );
return true;
} */
/*
===================
SV_FullClientUpdate
sends all the info about *cl to *sb
===================
*/
bool CGameClient::IsHearingClient( int index ) const
{
#if defined( REPLAY_ENABLED )
if ( IsHLTV() || IsReplay() )
#else
if ( IsHLTV() )
#endif
return true;
if ( index == GetPlayerSlot() )
return m_bVoiceLoopback;
CGameClient *pClient = sv.Client( index );
return pClient->m_VoiceStreams.Get( GetPlayerSlot() ) != 0;
}
bool CGameClient::IsProximityHearingClient( int index ) const
{
CGameClient *pClient = sv.Client( index );
return pClient->m_VoiceProximity.Get( GetPlayerSlot() ) != 0;
}
void CGameClient::Inactivate( void )
{
if ( edict && !edict->IsFree() )
{
m_Server->RemoveClientFromGame( this );
}
#ifndef _XBOX
if ( IsHLTV() )
{
hltv->Changelevel();
}
#if defined( REPLAY_ENABLED )
if ( IsReplay() )
{
replay->Changelevel();
}
#endif
#endif
CBaseClient::Inactivate();
m_Sounds.Purge();
m_VoiceStreams.ClearAll();
m_VoiceProximity.ClearAll();
DeleteClientFrames( -1 ); // delete all
}
bool CGameClient::UpdateAcknowledgedFramecount(int tick)
{
// free old client frames which won't be used anymore
if ( tick != m_nDeltaTick )
{
// delta tick changed, free all frames smaller than tick
int removeTick = tick;
if ( sv_maxreplay.GetFloat() > 0 )
removeTick -= (sv_maxreplay.GetFloat() / m_Server->GetTickInterval() ); // keep a replay buffer
if ( removeTick > 0 )
{
DeleteClientFrames( removeTick );
}
}
return CBaseClient::UpdateAcknowledgedFramecount( tick );
}
void CGameClient::Clear()
{
#ifndef _XBOX
if ( m_bIsHLTV && hltv )
{
hltv->Shutdown();
}
#if defined( REPLAY_ENABLED )
if ( m_bIsReplay && replay )
{
replay->Shutdown();
}
#endif
#endif
CBaseClient::Clear();
// free all frames
DeleteClientFrames( -1 );
m_Sounds.Purge();
m_VoiceStreams.ClearAll();
m_VoiceProximity.ClearAll();
edict = NULL;
m_pViewEntity = NULL;
m_bVoiceLoopback = false;
m_LastMovementTick = 0;
m_nSoundSequence = 0;
#if defined( REPLAY_ENABLED )
m_flLastSaveReplayTime = host_time;
#endif
}
void CGameClient::Reconnect( void )
{
// If the client was connected before, tell the game .dll to disconnect him/her.
sv.RemoveClientFromGame( this );
CBaseClient::Reconnect();
}
void CGameClient::Disconnect( const char *fmt, ... )
{
va_list argptr;
char reason[1024];
if ( m_nSignonState == SIGNONSTATE_NONE )
return; // no recursion
va_start (argptr,fmt);
Q_vsnprintf (reason, sizeof( reason ), fmt,argptr);
va_end (argptr);
// notify other clients of player leaving the game
// send the username and network id so we don't depend on the CBasePlayer pointer
IGameEvent *event = g_GameEventManager.CreateEvent( "player_disconnect" );
if ( event )
{
event->SetInt("userid", GetUserID() );
event->SetString("reason", reason );
event->SetString("name", GetClientName() );
event->SetString("networkid", GetNetworkIDString() );
event->SetInt( "bot", m_bFakePlayer?1:0 );
g_GameEventManager.FireEvent( event );
}
m_Server->RemoveClientFromGame( this );
CBaseClient::Disconnect( "%s", reason );
}
bool CGameClient::SetSignonState(int state, int spawncount)
{
if ( state == SIGNONSTATE_CONNECTED )
{
if ( !CheckConnect() )
return false;
m_NetChannel->SetTimeout( SIGNON_TIME_OUT ); // allow 5 minutes to load map
m_NetChannel->SetFileTransmissionMode( false );
m_NetChannel->SetMaxBufferSize( true, NET_MAX_PAYLOAD );
}
else if ( state == SIGNONSTATE_NEW )
{
if ( !sv.IsMultiplayer() )
{
// local client as received and create string tables,
// now link server tables to client tables
SV_InstallClientStringTableMirrors();
}
}
else if ( state == SIGNONSTATE_FULL )
{
if ( sv.m_bLoadgame )
{
// If this game was loaded from savegame, finish restoring game now
sv.FinishRestore();
}
m_NetChannel->SetTimeout( sv_timeout.GetFloat() ); // use smaller timeout limit
m_NetChannel->SetFileTransmissionMode( true );
#ifdef _XBOX
// to save memory on the XBOX reduce reliable buffer size from 96 to 8 kB
m_NetChannel->SetMaxBufferSize( true, 8*1024 );
#endif
}
return CBaseClient::SetSignonState( state, spawncount );
}
void CGameClient::SendSound( SoundInfo_t &sound, bool isReliable )
{
#if defined( REPLAY_ENABLED )
if ( IsFakeClient() && !IsHLTV() && !IsReplay() )
#else
if ( IsFakeClient() && !IsHLTV() )
#endif
{
return; // dont send sound messages to bots
}
// don't send sound messages while client is replay mode
if ( m_bIsInReplayMode )
{
return;
}
// reliable sounds are send as single messages
if ( isReliable )
{
SVC_Sounds sndmsg;
char buffer[32];
m_nSoundSequence = ( m_nSoundSequence + 1 ) & SOUND_SEQNUMBER_MASK; // increase own sound sequence counter
sound.nSequenceNumber = 0; // don't transmit nSequenceNumber for reliable sounds
sndmsg.m_DataOut.StartWriting(buffer, sizeof(buffer) );
sndmsg.m_nNumSounds = 1;
sndmsg.m_bReliableSound = true;
SoundInfo_t defaultSound; defaultSound.SetDefault();
sound.WriteDelta( &defaultSound, sndmsg.m_DataOut );
// send reliable sound as single message
SendNetMsg( sndmsg, true );
return;
}
sound.nSequenceNumber = m_nSoundSequence;
m_Sounds.AddToTail( sound ); // queue sounds until snapshot is send
}
void CGameClient::WriteGameSounds( bf_write &buf )
{
if ( m_Sounds.Count() <= 0 )
return;
char data[NET_MAX_PAYLOAD];
SVC_Sounds msg;
msg.m_DataOut.StartWriting( data, sizeof(data) );
int nSoundCount = FillSoundsMessage( msg );
msg.WriteToBuffer( buf );
if ( IsTracing() )
{
TraceNetworkData( buf, "Sounds [count=%d]", nSoundCount );
}
}
int CGameClient::FillSoundsMessage(SVC_Sounds &msg)
{
int i, count = m_Sounds.Count();
// send max 64 sound in multiplayer per snapshot, 255 in SP
int max = m_Server->IsMultiplayer() ? 32 : 255;
// Discard events if we have too many to signal with 8 bits
if ( count > max )
count = max;
// Nothing to send
if ( !count )
return 0;
SoundInfo_t defaultSound; defaultSound.SetDefault();
SoundInfo_t *pDeltaSound = &defaultSound;
msg.m_nNumSounds = count;
msg.m_bReliableSound = false;
msg.SetReliable( false );
Assert( msg.m_DataOut.GetNumBitsLeft() > 0 );
for ( i = 0 ; i < count; i++ )
{
SoundInfo_t &sound = m_Sounds[ i ];
sound.WriteDelta( pDeltaSound, msg.m_DataOut );
pDeltaSound = &m_Sounds[ i ];
}
// remove added events from list
int remove = m_Sounds.Count() - ( count + max );
if ( remove > 0 )
{
DevMsg("Warning! Dropped %i unreliable sounds for client %s.\n" , remove, m_Name );
count+= remove;
}
if ( count > 0 )
{
m_Sounds.RemoveMultiple( 0, count );
}
Assert( m_Sounds.Count() <= max ); // keep ev_max temp ent for next update
return msg.m_nNumSounds;
}
bool CGameClient::CheckConnect( void )
{
// Allow the game dll to reject this client.
char szRejectReason[128];
Q_strncpy( szRejectReason, "Connection rejected by game\n", sizeof( szRejectReason ) );
if ( !g_pServerPluginHandler->ClientConnect( edict, m_Name, m_NetChannel->GetAddress(), szRejectReason, sizeof( szRejectReason ) ) )
{
// Reject the connection and drop the client.
Disconnect( szRejectReason, m_Name );
return false;
}
return true;
}
void CGameClient::ActivatePlayer( void )
{
CBaseClient::ActivatePlayer();
COM_TimestampedLog( "CGameClient::ActivatePlayer -start" );
// call the spawn function
if ( !sv.m_bLoadgame )
{
g_ServerGlobalVariables.curtime = sv.GetTime();
COM_TimestampedLog( "g_pServerPluginHandler->ClientPutInServer" );
g_pServerPluginHandler->ClientPutInServer( edict, m_Name );
}
COM_TimestampedLog( "g_pServerPluginHandler->ClientActive" );
g_pServerPluginHandler->ClientActive( edict, sv.m_bLoadgame );
COM_TimestampedLog( "g_pServerPluginHandler->ClientSettingsChanged" );
g_pServerPluginHandler->ClientSettingsChanged( edict );
COM_TimestampedLog( "GetTestScriptMgr()->CheckPoint" );
GetTestScriptMgr()->CheckPoint( "client_connected" );
// don't send signonstate to client, client will switch to FULL as soon
// as the first full entity update packets has been received
// fire a activate event
IGameEvent *event = g_GameEventManager.CreateEvent( "player_activate" );
if ( event )
{
event->SetInt( "userid", GetUserID() );
g_GameEventManager.FireEvent( event );
}
COM_TimestampedLog( "CGameClient::ActivatePlayer -end" );
}
bool CGameClient::SendSignonData( void )
{
bool bClientHasdifferentTables = false;
if ( sv.m_FullSendTables.IsOverflowed() )
{
Host_Error( "Send Table signon buffer overflowed %i bytes!!!\n", sv.m_FullSendTables.GetNumBytesWritten() );
return false;
}
if ( SendTable_GetCRC() != (CRC32_t)0 )
{
bClientHasdifferentTables = m_nSendtableCRC != SendTable_GetCRC();
}
#ifdef _DEBUG
if ( sv_sendtables.GetInt() == 2 )
{
// force sending class tables, for debugging
bClientHasdifferentTables = true;
}
#endif
// Write the send tables & class infos if needed
if ( bClientHasdifferentTables )
{
if ( sv_sendtables.GetBool() )
{
// send client class table descriptions so it can rebuild tables
ConDMsg("Client sent different SendTable CRC, sending full tables.\n" );
m_NetChannel->SendData( sv.m_FullSendTables );
}
else
{
Disconnect( "Server uses different class tables" );
return false;
}
}
else
{
// use your class infos, CRC is correct
SVC_ClassInfo classmsg( true, m_Server->serverclasses );
m_NetChannel->SendNetMsg( classmsg );
}
if ( !CBaseClient::SendSignonData() )
return false;
m_nSoundSequence = 1; // reset sound sequence numbers after signon block
return true;
}
void CGameClient::SpawnPlayer( void )
{
// run the entrance script
if ( sv.m_bLoadgame )
{ // loaded games are fully inited already
// if this is the last client to be connected, unpause
sv.SetPaused( false );
}
else
{
// set up the edict
Assert( serverGameEnts );
serverGameEnts->FreeContainingEntity( edict );
InitializeEntityDLLFields( edict );
}
// restore default client entity and turn off replay mdoe
m_nEntityIndex = m_nClientSlot+1;
m_bIsInReplayMode = false;
// set view entity
SVC_SetView setView( m_nEntityIndex );
SendNetMsg( setView );
CBaseClient::SpawnPlayer();
// notify that the player is spawning
serverGameClients->ClientSpawned( edict );
}
CClientFrame *CGameClient::GetDeltaFrame( int nTick )
{
#ifndef _XBOX
Assert ( !IsHLTV() ); // has no ClientFrames
#if defined( REPLAY_ENABLED )
Assert ( !IsReplay() ); // has no ClientFrames
#endif
#endif
if ( m_bIsInReplayMode )
{
int followEntity;
serverGameClients->GetReplayDelay( edict, followEntity );
Assert( followEntity > 0 );
CGameClient *pFollowEntity = sv.Client( followEntity-1 );
if ( pFollowEntity )
return pFollowEntity->GetClientFrame( nTick );
}
return GetClientFrame( nTick );
}
void CGameClient::WriteViewAngleUpdate()
{
//
// send the current viewpos offset from the view entity
//
// a fixangle might get lost in a dropped packet. Oh well.
if ( IsFakeClient() )
return;
Assert( serverGameClients );
CPlayerState *pl = serverGameClients->GetPlayerState( edict );
Assert( pl );
if ( pl && pl->fixangle != FIXANGLE_NONE )
{
if ( pl->fixangle == FIXANGLE_RELATIVE )
{
SVC_FixAngle fixAngle( true, pl->anglechange );
m_NetChannel->SendNetMsg( fixAngle );
pl->anglechange.Init(); // clear
}
else
{
SVC_FixAngle fixAngle(false, pl->v_angle );
m_NetChannel->SendNetMsg( fixAngle );
}
pl->fixangle = FIXANGLE_NONE;
}
}
/*
===================
SV_ValidateClientCommand
Determine if passed in user command is valid.
===================
*/
bool CGameClient::IsEngineClientCommand( const CCommand &args ) const
{
if ( args.ArgC() == 0 )
return false;
for ( int i = 0; s_clcommands[i] != NULL; ++i )
{
if ( !Q_strcasecmp( args[0], s_clcommands[i] ) )
return true;
}
return false;
}
bool CGameClient::SendNetMsg(INetMessage &msg, bool bForceReliable)
{
#ifndef _XBOX
if ( m_bIsHLTV )
{
// pass this message to HLTV
return hltv->SendNetMsg( msg, bForceReliable );
}
#if defined( REPLAY_ENABLED )
if ( m_bIsReplay )
{
// pass this message to replay
return replay->SendNetMsg( msg, bForceReliable );
}
#endif
#endif
return CBaseClient::SendNetMsg( msg, bForceReliable);
}
bool CGameClient::ExecuteStringCommand( const char *pCommandString )
{
// first let the baseclass handle it
if ( CBaseClient::ExecuteStringCommand( pCommandString ) )
return true;
// Determine whether the command is appropriate
CCommand args;
if ( !args.Tokenize( pCommandString ) )
return false;
if ( args.ArgC() == 0 )
return false;
if ( IsEngineClientCommand( args ) )
{
Cmd_ExecuteCommand( args, src_client, m_nClientSlot );
return true;
}
const ConCommandBase *pCommand = g_pCVar->FindCommandBase( args[ 0 ] );
if ( pCommand && pCommand->IsCommand() && pCommand->IsFlagSet( FCVAR_GAMEDLL ) )
{
// Allow cheat commands in singleplayer, debug, or multiplayer with sv_cheats on
// NOTE: Don't bother with rpt stuff; commands that matter there shouldn't have FCVAR_GAMEDLL set
if ( pCommand->IsFlagSet( FCVAR_CHEAT ) )
{
if ( sv.IsMultiplayer() && !CanCheat() )
return false;
}
if ( pCommand->IsFlagSet( FCVAR_SPONLY ) )
{
if ( sv.IsMultiplayer() )
{
return false;
}
}
// Don't allow clients to execute commands marked as development only.
if ( pCommand->IsFlagSet( FCVAR_DEVELOPMENTONLY ) )
{
return false;
}
g_pServerPluginHandler->SetCommandClient( m_nClientSlot );
Cmd_Dispatch( pCommand, args );
}
else
{
g_pServerPluginHandler->ClientCommand( edict, args ); // TODO pass client id and string
}
return true;
}
void CGameClient::SendSnapshot( CClientFrame * pFrame )
{
if ( m_bIsHLTV )
{
#ifndef SHARED_NET_STRING_TABLES
// copy string updates from server to hltv stringtable
networkStringTableContainerServer->DirectUpdate( GetMaxAckTickCount() );
#endif
char *buf = (char *)_alloca( NET_MAX_PAYLOAD );
// pack sounds to one message
if ( m_Sounds.Count() > 0 )
{
SVC_Sounds sounds;
sounds.m_DataOut.StartWriting( buf, NET_MAX_PAYLOAD );
FillSoundsMessage( sounds );
hltv->SendNetMsg( sounds );
}
int maxEnts = tv_transmitall.GetBool()?255:64;
hltv->WriteTempEntities( this, pFrame->GetSnapshot(), m_pLastSnapshot.GetObject(), *hltv->GetBuffer( HLTV_BUFFER_TEMPENTS ), maxEnts );
// add snapshot to HLTV server frame list
hltv->AddNewFrame( pFrame );
// remember this snapshot
m_pLastSnapshot = pFrame->GetSnapshot();
// fake acknowledgement, remove ClientFrame reference immediately
UpdateAcknowledgedFramecount( pFrame->tick_count );
return;
}
#if defined( REPLAY_ENABLED )
if ( m_bIsReplay )
{
#ifndef SHARED_NET_STRING_TABLES
// copy string updates from server to replay stringtable
networkStringTableContainerServer->DirectUpdate( GetMaxAckTickCount() );
#endif
char *buf = (char *)_alloca( NET_MAX_PAYLOAD );
// pack sounds to one message
if ( m_Sounds.Count() > 0 )
{
SVC_Sounds sounds;
sounds.m_DataOut.StartWriting( buf, NET_MAX_PAYLOAD );
FillSoundsMessage( sounds );
replay->SendNetMsg( sounds );
}
int maxEnts = 255;
replay->WriteTempEntities( this, pFrame->GetSnapshot(), m_pLastSnapshot.GetObject(), *replay->GetBuffer( REPLAY_BUFFER_TEMPENTS ), maxEnts );
// add snapshot to Replay server frame list
if ( replay->AddNewFrame( pFrame ) )
{
// remember this snapshot
m_pLastSnapshot = pFrame->GetSnapshot();
// fake acknowledgement, remove ClientFrame reference immediately
UpdateAcknowledgedFramecount( pFrame->tick_count );
}
return;
}
#endif
// update client viewangles update
WriteViewAngleUpdate();
CBaseClient::SendSnapshot( pFrame );
}
//-----------------------------------------------------------------------------
// This function contains all the logic to determine if we should send a datagram
// to a particular client
//-----------------------------------------------------------------------------
bool CGameClient::ShouldSendMessages( void )
{
#ifndef _XBOX
if ( m_bIsHLTV )
{
// calc snapshot interval
int nSnapshotInterval = 1.0f / ( m_Server->GetTickInterval() * tv_snapshotrate.GetFloat() );
// I am the HLTV client, record every nSnapshotInterval tick
return ( sv.m_nTickCount >= (hltv->m_nLastTick + nSnapshotInterval) );
}
#if defined( REPLAY_ENABLED )
if ( m_bIsReplay )
{
const float replay_snapshotrate = 16.0f;
// calc snapshot interval
int nSnapshotInterval = 1.0f / ( m_Server->GetTickInterval() * replay_snapshotrate );
// I am the Replay client, record every nSnapshotInterval tick
return ( sv.m_nTickCount >= (replay->m_nLastTick + nSnapshotInterval) );
}
#endif
#endif
// If sv_stressbots is true, then treat a bot more like a regular client and do deltas and such for it.
if( IsFakeClient() )
{
if ( !sv_stressbots.GetBool() )
return false;
}
return CBaseClient::ShouldSendMessages();
}
void CGameClient::FileReceived( const char *fileName, unsigned int transferID )
{
//check if file is one of our requested custom files
for ( int i=0; i<MAX_CUSTOM_FILES; i++ )
{
if ( m_nCustomFiles[i].reqID == transferID )
{
m_nFilesDownloaded++;
// broadcast update to other clients so they start downlaoding this file
m_Server->UserInfoChanged( m_nClientSlot );
return;
}
}
Msg( "CGameClient::FileReceived: %s not wanted.\n", fileName );
}
void CGameClient::FileRequested(const char *fileName, unsigned int transferID )
{
DevMsg( "File '%s' requested from client %s.\n", fileName, m_NetChannel->GetAddress() );
if ( sv_allowdownload.GetBool() )
{
m_NetChannel->SendFile( fileName, transferID );
}
else
{
m_NetChannel->DenyFile( fileName, transferID );
}
}
void CGameClient::FileDenied(const char *fileName, unsigned int transferID )
{
ConMsg( "Downloading file '%s' from client %s failed.\n", fileName, GetClientName() );
}
void CGameClient::FileSent( const char *fileName, unsigned int transferID )
{
ConMsg( "Sent file '%s' to client %s.\n", fileName, GetClientName() );
}
void CGameClient::PacketStart(int incoming_sequence, int outgoing_acknowledged)
{
// make sure m_LastMovementTick != sv.tickcount
m_LastMovementTick = ( sv.m_nTickCount - 1 );
host_client = this;
// During connection, only respond if client sends a packet
m_bReceivedPacket = true;
}
void CGameClient::PacketEnd()
{
// Fix up clock in case prediction/etc. code reset it.
g_ServerGlobalVariables.frametime = host_state.interval_per_tick;
}
void CGameClient::ConnectionClosing(const char *reason)
{
#ifndef _XBOX
SV_RedirectEnd ();
#endif
// Check for printf format tokens in this reason string. Crash exploit.
Disconnect ( (reason && !strchr( reason, '%' ) ) ? reason : "Connection closing" );
}
void CGameClient::ConnectionCrashed(const char *reason)
{
if ( m_Name[0] && IsConnected() )
{
DebuggerBreakIfDebugging_StagingOnly();
#ifndef _XBOX
SV_RedirectEnd ();
#endif
// Check for printf format tokens in this reason string. Crash exploit.
Disconnect ( (reason && !strchr( reason, '%' ) ) ? reason : "Connection lost" );
}
}
CClientFrame *CGameClient::GetSendFrame()
{
CClientFrame *pFrame = m_pCurrentFrame;
// just return if replay is disabled
if ( sv_maxreplay.GetFloat() <= 0 )
return pFrame;
int followEntity;
int delayTicks = serverGameClients->GetReplayDelay( edict, followEntity );
bool isInReplayMode = ( delayTicks > 0 );
if ( isInReplayMode != m_bIsInReplayMode )
{
// force a full update when modes are switched
m_nDeltaTick = -1;
m_bIsInReplayMode = isInReplayMode;
if ( isInReplayMode )
{
m_nEntityIndex = followEntity;
}
else
{
m_nEntityIndex = m_nClientSlot+1;
}
}
Assert( (m_nClientSlot+1 == m_nEntityIndex) || isInReplayMode );
if ( isInReplayMode )
{
CGameClient *pFollowPlayer = sv.Client( followEntity-1 );
if ( !pFollowPlayer )
return NULL;
pFrame = pFollowPlayer->GetClientFrame( sv.GetTick() - delayTicks, false );
if ( !pFrame )
return NULL;
if ( m_pLastSnapshot == pFrame->GetSnapshot() )
return NULL;
}
return pFrame;
}
bool CGameClient::IgnoreTempEntity( CEventInfo *event )
{
// in replay mode replay all temp entities
if ( m_bIsInReplayMode )
return false;
return CBaseClient::IgnoreTempEntity( event );
}
const CCheckTransmitInfo* CGameClient::GetPrevPackInfo()
{
return &m_PrevPackInfo;
}
// This code is useful for verifying that the networking of soundinfo_t stuff isn't borked.
#if 0
#include "vstdlib/random.h"
class CTestSoundInfoNetworking
{
public:
CTestSoundInfoNetworking();
void RunTest();
private:
void CreateRandomSounds( int nCount );
void CreateRandomSound( SoundInfo_t &si );
void Compare( const SoundInfo_t &s1, const SoundInfo_t &s2 );
CUtlVector< SoundInfo_t > m_Sounds;
CUtlVector< SoundInfo_t > m_Received;
};
static CTestSoundInfoNetworking g_SoundTest;
CON_COMMAND( st, "sound test" )
{
int nCount = 1;
if ( args.ArgC() >= 2 )
{
nCount = clamp( Q_atoi( args.Arg( 1 ) ), 1, 100000 );
}
for ( int i = 0 ; i < nCount; ++i )
{
if ( !( i % 100 ) && i > 0 )
{
Msg( "Running test %d %f %% done\n",
i, 100.0f * (float)i/(float)nCount );
}
g_SoundTest.RunTest();
}
}
CTestSoundInfoNetworking::CTestSoundInfoNetworking()
{
}
void CTestSoundInfoNetworking::CreateRandomSound( SoundInfo_t &si )
{
int entindex = RandomInt( 0, MAX_EDICTS - 1 );
int channel = RandomInt( 0, 7 );
int soundnum = RandomInt( 0, MAX_SOUNDS - 1 );
Vector org = RandomVector( -16383, 16383 );
Vector dir = RandomVector( -1.0f, 1.0f );
float flVolume = RandomFloat( 0.1f, 1.0f );
bool bLooping = RandomInt( 0, 100 ) < 5;
int nPitch = RandomInt( 0, 100 ) < 5 ? RandomInt( 95, 105 ) : 100;
Vector lo = RandomInt( 0, 100 ) < 5 ? RandomVector( -16383, 16383 ) : org;
int speaker = RandomInt( 0, 100 ) < 2 ? RandomInt( 0, MAX_EDICTS - 1 ) : -1;
soundlevel_t level = soundlevel_t(RandomInt( 70, 150 ));
si.Set( entindex, channel, "foo.wav", org, dir, flVolume, level, bLooping, nPitch, lo, speaker );
si.nFlags = ( 1 << RandomInt( 0, 6 ) );
si.nSoundNum = soundnum;
si.bIsSentence = RandomInt( 0, 1 );
si.bIsAmbient = RandomInt( 0, 1 );
si.fDelay = RandomInt( 0, 100 ) < 2 ? RandomFloat( -0.1, 0.1f ) : 0.0f;
}
void CTestSoundInfoNetworking::CreateRandomSounds( int nCount )
{
m_Sounds.Purge();
m_Sounds.EnsureCount( nCount );
for ( int i = 0; i < nCount; ++i )
{
SoundInfo_t &si = m_Sounds[ i ];
CreateRandomSound( si );
}
}
void CTestSoundInfoNetworking::RunTest()
{
int m_nSoundSequence = 0;
CreateRandomSounds( 512 );
SoundInfo_t defaultSound; defaultSound.SetDefault();
SoundInfo_t *pDeltaSound = &defaultSound;
SVC_Sounds msg;
char *buf = (char *)_alloca( NET_MAX_PAYLOAD );
msg.m_DataOut.StartWriting( buf, NET_MAX_PAYLOAD );
msg.m_nNumSounds = m_Sounds.Count();
msg.m_bReliableSound = false;
msg.SetReliable( false );
Assert( msg.m_DataOut.GetNumBitsLeft() > 0 );
for ( int i = 0 ; i < m_Sounds.Count(); i++ )
{
SoundInfo_t &sound = m_Sounds[ i ];
sound.WriteDelta( pDeltaSound, msg.m_DataOut );
pDeltaSound = &m_Sounds[ i ];
}
// Now read them out
defaultSound.SetDefault();
pDeltaSound = &defaultSound;
msg.m_DataIn.StartReading( buf, msg.m_DataOut.GetNumBytesWritten(), 0, msg.m_DataOut.GetNumBitsWritten() );
SoundInfo_t sound;
for ( int i=0; i<msg.m_nNumSounds; i++ )
{
sound.ReadDelta( pDeltaSound, msg.m_DataIn );
pDeltaSound = &sound; // copy delta values
if ( msg.m_bReliableSound )
{
// 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 no ambient sounds to sorted queue, will be processed after packet has been completly parsed
// CL_AddSound( sound );
m_Received.AddToTail( sound );
}
// Now validate them
for ( int i = 0 ; i < msg.m_nNumSounds; ++i )
{
SoundInfo_t &server = m_Sounds[ i ];
SoundInfo_t &client = m_Received[ i ];
Compare( server, client );
}
m_Sounds.Purge();
m_Received.Purge();
}
void CTestSoundInfoNetworking::Compare( const SoundInfo_t &s1, const SoundInfo_t &s2 )
{
bool bSndStop = s2.nFlags == SND_STOP;
if ( !bSndStop && s1.nSequenceNumber != s2.nSequenceNumber )
{
Msg( "seq number mismatch %d %d\n", s1.nSequenceNumber, s2.nSequenceNumber );
}
if ( s1.nEntityIndex != s2.nEntityIndex )
{
Msg( "ent mismatch %d %d\n", s1.nEntityIndex, s2.nEntityIndex );
}
if ( s1.nChannel != s2.nChannel )
{
Msg( "channel mismatch %d %d\n", s1.nChannel, s2.nChannel );
}
Vector d;
d = s1.vOrigin - s2.vOrigin;
if ( !bSndStop && d.Length() > 32.0f )
{
Msg( "origin mismatch [%f] (%f %f %f) != (%f %f %f)\n", d.Length(), s1.vOrigin.x, s1.vOrigin.y, s1.vOrigin.z, s2.vOrigin.x, s2.vOrigin.y, s2.vOrigin.z );
}
// Vector vDirection;
float delta = fabs( s1.fVolume - s2.fVolume );
if ( !bSndStop && delta > 1.0f )
{
Msg( "vol mismatch %f %f\n", s1.fVolume, s2.fVolume );
}
if ( !bSndStop && s1.Soundlevel != s2.Soundlevel )
{
Msg( "sndlvl mismatch %d %d\n", s1.Soundlevel, s2.Soundlevel );
}
// bLooping;
if ( s1.bIsSentence != s2.bIsSentence )
{
Msg( "sentence mismatch %d %d\n", s1.bIsSentence ? 1 : 0, s2.bIsSentence ? 1 : 0 );
}
if ( s1.bIsAmbient != s2.bIsAmbient )
{
Msg( "ambient mismatch %d %d\n", s1.bIsAmbient ? 1 : 0, s2.bIsAmbient ? 1 : 0 );
}
if ( !bSndStop && s1.nPitch != s2.nPitch )
{
Msg( "pitch mismatch %d %d\n", s1.nPitch, s2.nPitch );
}
if ( !bSndStop && s1.nSpecialDSP != s2.nSpecialDSP )
{
Msg( "special dsp mismatch %d %d\n", s1.nSpecialDSP, s2.nSpecialDSP );
}
// Vector vListenerOrigin;
if ( s1.nFlags != s2.nFlags )
{
Msg( "flags mismatch %d %d\n", s1.nFlags, s2.nFlags );
}
if ( s1.nSoundNum != s2.nSoundNum )
{
Msg( "soundnum mismatch %d %d\n", s1.nSoundNum, s2.nSoundNum );
}
delta = fabs( s1.fDelay - s2.fDelay );
if ( !bSndStop && delta > 0.020f )
{
Msg( "delay mismatch %f %f\n", s1.fDelay, s2.fDelay );
}
if ( !bSndStop && s1.nSpeakerEntity != s2.nSpeakerEntity )
{
Msg( "speakerentity mismatch %d %d\n", s1.nSpeakerEntity, s2.nSpeakerEntity );
}
}
#endif
Reference in New Issue Copy Permalink