/*
=================
SV_MasterShutdown
Informs all masters that this server is going down
=================
*/
void SV_MasterShutdown( void ) {
// send a hearbeat right now
svs.nextHeartbeatTime = -9999;
SV_MasterHeartbeat(HEARTBEAT_FOR_MASTER);
// send it again to minimize chance of drops
svs.nextHeartbeatTime = -9999;
SV_MasterHeartbeat(HEARTBEAT_FOR_MASTER);
// when the master tries to poll the server, it won't respond, so
// it will be removed from the list
}
/*
=================
SV_MasterShutdown
Informs all masters that this server is going down
=================
*/
void SV_MasterShutdown( void ) {
// send a hearbeat right now
svs.nextHeartbeatTime = -9999;
SV_MasterHeartbeat();
// send it again to minimize chance of drops
svs.nextHeartbeatTime = -9999;
SV_MasterHeartbeat();
// when the master tries to poll the server, it won't respond, so
// it will be removed from the list
#ifdef USE_AUTH
VM_Call( gvm, GAME_AUTHSERVER_SHUTDOWN );
#endif
}
/*
* @brief Informs all masters that this server is going down
*/
void SV_MasterShutdown(void)
{
svs.nextHeartbeatTime = -9999; // send a hearbeat right now
SV_MasterHeartbeat(HEARTBEAT_DEAD);
// when the master tries to poll the server, it won't respond, so
// it will be removed from the list
}
/*
=================
SV_MasterShutdown
Informs all masters that this server is going down
=================
*/
void SV_MasterShutdown( void ) {
// send a hearbeat right now
svs.nextHeartbeatTime = -9999;
SV_MasterHeartbeat( HEARTBEAT_DEAD ); // NERVE - SMF - changed to flatline
// send it again to minimize chance of drops
// svs.nextHeartbeatTime = -9999;
// SV_MasterHeartbeat( HEARTBEAT_DEAD );
// when the master tries to poll the server, it won't respond, so
// it will be removed from the list
}
/*
* SV_Frame
*/
void SV_Frame( int realmsec, int gamemsec )
{
const unsigned int wrappingPoint = 0x70000000;
time_before_game = time_after_game = 0;
// if server is not active, do nothing
if( !svs.initialized )
{
SV_CheckDefaultMap();
return;
}
svs.realtime += realmsec;
svs.gametime += gamemsec;
// advance to next map if the server is running for too long (numbers taken from q3 src)
if( svs.realtime > wrappingPoint || svs.gametime > wrappingPoint || sv.framenum >= wrappingPoint )
{
Cbuf_AddText( "wait; vstr nextmap\n" );
SV_ShutdownGame( "Restarting server due to time wrapping", qtrue );
return;
}
// check timeouts
SV_CheckTimeouts();
// get packets from clients
SV_ReadPackets();
// let everything in the world think and move
if( SV_RunGameFrame( gamemsec ) )
{
// send messages back to the clients that had packets read this frame
SV_SendClientMessages();
// write snap to server demo file
SV_Demo_WriteSnap();
// run matchmaker stuff
SV_CheckMatchUUID();
SV_MM_Frame();
// send a heartbeat to the master if needed
SV_MasterHeartbeat();
// clear teleport flags, etc for next frame
ge->ClearSnap();
}
SV_CheckAutoUpdate();
}
/*
==================
SV_Frame
Player movement occurs as a result of packet events, which
happen before SV_Frame is called
==================
*/
void SV_Frame( int msec ) {
int frameMsec;
int startTime;
// the menu kills the server with this cvar
if ( sv_killserver->integer ) {
SV_Shutdown ("Server was killed");
Cvar_Set( "sv_killserver", "0" );
return;
}
if (!com_sv_running->integer)
{
if(com_dedicated->integer)
{
// Block indefinitely until something interesting happens
// on STDIN.
NET_Sleep(-1);
}
return;
}
// allow pause if only the local client is connected
if ( SV_CheckPaused() ) {
return;
}
// if it isn't time for the next frame, do nothing
if ( sv_fps->integer < 1 ) {
Cvar_Set( "sv_fps", "10" );
}
frameMsec = 1000 / sv_fps->integer * com_timescale->value;
// don't let it scale below 1ms
if(frameMsec < 1)
{
Cvar_Set("timescale", va("%f", sv_fps->integer / 1000.0f));
frameMsec = 1;
}
sv.timeResidual += msec;
if (!com_dedicated->integer) SV_BotFrame (sv.time + sv.timeResidual);
if ( com_dedicated->integer && sv.timeResidual < frameMsec ) {
// NET_Sleep will give the OS time slices until either get a packet
// or time enough for a server frame has gone by
NET_Sleep(frameMsec - sv.timeResidual);
return;
}
// if time is about to hit the 32nd bit, kick all clients
// and clear sv.time, rather
// than checking for negative time wraparound everywhere.
// 2giga-milliseconds = 23 days, so it won't be too often
if ( svs.time > 0x70000000 ) {
SV_Shutdown( "Restarting server due to time wrapping" );
Cbuf_AddText( va( "map %s\n", Cvar_VariableString( "mapname" ) ) );
return;
}
// this can happen considerably earlier when lots of clients play and the map doesn't change
if ( svs.nextSnapshotEntities >= 0x7FFFFFFE - svs.numSnapshotEntities ) {
SV_Shutdown( "Restarting server due to numSnapshotEntities wrapping" );
Cbuf_AddText( va( "map %s\n", Cvar_VariableString( "mapname" ) ) );
return;
}
if( sv.restartTime && sv.time >= sv.restartTime ) {
sv.restartTime = 0;
Cbuf_AddText( "map_restart 0\n" );
return;
}
// update infostrings if anything has been changed
if ( cvar_modifiedFlags & CVAR_SERVERINFO ) {
SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
cvar_modifiedFlags &= ~CVAR_SERVERINFO;
}
if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) {
SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString_Big( CVAR_SYSTEMINFO ) );
cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
}
if ( com_speeds->integer ) {
startTime = Sys_Milliseconds ();
} else {
startTime = 0; // quite a compiler warning
}
// update ping based on the all received frames
SV_CalcPings();
if (com_dedicated->integer) SV_BotFrame (sv.time);
// run the game simulation in chunks
while ( sv.timeResidual >= frameMsec ) {
sv.timeResidual -= frameMsec;
svs.time += frameMsec;
sv.time += frameMsec;
// let everything in the world think and move
VM_Call (gvm, GAME_RUN_FRAME, sv.time);
}
if ( com_speeds->integer ) {
time_game = Sys_Milliseconds () - startTime;
}
// check timeouts
SV_CheckTimeouts();
// check user info buffer thingy
SV_CheckClientUserinfoTimer();
// send messages back to the clients
SV_SendClientMessages();
// send a heartbeat to the master if needed
SV_MasterHeartbeat();
}
/*
=================
SV_SendServerCommand
Sends a reliable command string to be interpreted by
the client game module: "cp", "print", "chat", etc
A NULL client will broadcast to all clients
=================
*/
void QDECL SV_SendServerCommand( client_t *cl, const char *fmt, ... ) {
va_list argptr;
byte message[MAX_MSGLEN];
client_t *client;
int j;
va_start( argptr,fmt );
#if defined RTCW_SP
vsprintf( (char *)message, fmt,argptr );
#else
Q_vsnprintf( (char *)message, sizeof( message ), fmt, argptr );
#endif // RTCW_XX
va_end( argptr );
#if !defined RTCW_SP
// do not forward server command messages that would be too big to clients
// ( q3infoboom / q3msgboom stuff )
if ( strlen( (char *)message ) > 1022 ) {
return;
}
#endif // RTCW_XX
if ( cl != NULL ) {
SV_AddServerCommand( cl, (char *)message );
return;
}
// hack to echo broadcast prints to console
if ( com_dedicated->integer && !strncmp( (char *)message, "print", 5 ) ) {
Com_Printf( "broadcast: %s\n", SV_ExpandNewlines( (char *)message ) );
}
// send the data to all relevent clients
for ( j = 0, client = svs.clients; j < sv_maxclients->integer ; j++, client++ ) {
if ( client->state < CS_PRIMED ) {
continue;
}
// Ridah, don't need to send messages to AI
#if !defined RTCW_ET
if ( client->gentity && client->gentity->r.svFlags & SVF_CASTAI ) {
#else
if ( client->gentity && client->gentity->r.svFlags & SVF_BOT ) {
#endif // RTCW_XX
continue;
}
// done.
SV_AddServerCommand( client, (char *)message );
}
}
/*
==============================================================================
MASTER SERVER FUNCTIONS
==============================================================================
*/
/*
================
SV_MasterHeartbeat
Send a message to the masters every few minutes to
let it know we are alive, and log information.
We will also have a heartbeat sent when a server
changes from empty to non-empty, and full to non-full,
but not on every player enter or exit.
================
*/
#define HEARTBEAT_MSEC 300 * 1000
#if !defined RTCW_ET
#define HEARTBEAT_GAME "Wolfenstein-1"
#else
//#define HEARTBEAT_GAME "Wolfenstein-1"
//#define HEARTBEAT_DEAD "WolfFlatline-1" // NERVE - SMF
#define HEARTBEAT_GAME "EnemyTerritory-1"
#endif // RTCW_XX
#if defined RTCW_SP
void SV_MasterHeartbeat( void ) {
#else
#if !defined RTCW_ET
#define HEARTBEAT_DEAD "WolfFlatline-1" // NERVE - SMF
#else
#define HEARTBEAT_DEAD "ETFlatline-1" // NERVE - SMF
#endif // RTCW_XX
void SV_MasterHeartbeat( const char *hbname ) {
#endif // RTCW_XX
static netadr_t adr[MAX_MASTER_SERVERS];
int i;
#if defined RTCW_MP
// DHM - Nerve :: Update Server doesn't send heartbeat
#ifdef UPDATE_SERVER
return;
#endif
#endif // RTCW_XX
#if defined RTCW_ET
if ( SV_GameIsSinglePlayer() ) {
return; // no heartbeats for SP
}
#endif // RTCW_XX
// "dedicated 1" is for lan play, "dedicated 2" is for inet public play
if ( !com_dedicated || com_dedicated->integer != 2 ) {
return; // only dedicated servers send heartbeats
}
// if not time yet, don't send anything
if ( svs.time < svs.nextHeartbeatTime ) {
return;
}
svs.nextHeartbeatTime = svs.time + HEARTBEAT_MSEC;
// send to group masters
for ( i = 0 ; i < MAX_MASTER_SERVERS ; i++ ) {
if ( !sv_master[i]->string[0] ) {
continue;
}
// see if we haven't already resolved the name
// resolving usually causes hitches on win95, so only
// do it when needed
if ( sv_master[i]->modified ) {
sv_master[i]->modified = qfalse;
Com_Printf( "Resolving %s\n", sv_master[i]->string );
if ( !NET_StringToAdr( sv_master[i]->string, &adr[i] ) ) {
// if the address failed to resolve, clear it
// so we don't take repeated dns hits
Com_Printf( "Couldn't resolve address: %s\n", sv_master[i]->string );
Cvar_Set( sv_master[i]->name, "" );
sv_master[i]->modified = qfalse;
continue;
}
if ( !strstr( ":", sv_master[i]->string ) ) {
adr[i].port = rtcw::Endian::be( PORT_MASTER );
}
Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", sv_master[i]->string,
adr[i].ip[0], adr[i].ip[1], adr[i].ip[2], adr[i].ip[3],
rtcw::Endian::be( adr[i].port ) );
}
Com_Printf( "Sending heartbeat to %s\n", sv_master[i]->string );
// this command should be changed if the server info / status format
// ever incompatably changes
#if defined RTCW_SP
NET_OutOfBandPrint( NS_SERVER, adr[i], "heartbeat %s\n", HEARTBEAT_GAME );
#else
NET_OutOfBandPrint( NS_SERVER, adr[i], "heartbeat %s\n", hbname );
#endif // RTCW_XX
}
}
#if !defined RTCW_SP
/*
=================
SV_MasterGameCompleteStatus
NERVE - SMF - Sends gameCompleteStatus messages to all master servers
=================
*/
void SV_MasterGameCompleteStatus() {
static netadr_t adr[MAX_MASTER_SERVERS];
int i;
#if defined RTCW_ET
if ( SV_GameIsSinglePlayer() ) {
return; // no master game status for SP
}
#endif // RTCW_XX
// "dedicated 1" is for lan play, "dedicated 2" is for inet public play
if ( !com_dedicated || com_dedicated->integer != 2 ) {
return; // only dedicated servers send master game status
}
// send to group masters
for ( i = 0 ; i < MAX_MASTER_SERVERS ; i++ ) {
if ( !sv_master[i]->string[0] ) {
continue;
}
// see if we haven't already resolved the name
// resolving usually causes hitches on win95, so only
// do it when needed
if ( sv_master[i]->modified ) {
sv_master[i]->modified = qfalse;
Com_Printf( "Resolving %s\n", sv_master[i]->string );
if ( !NET_StringToAdr( sv_master[i]->string, &adr[i] ) ) {
// if the address failed to resolve, clear it
// so we don't take repeated dns hits
Com_Printf( "Couldn't resolve address: %s\n", sv_master[i]->string );
Cvar_Set( sv_master[i]->name, "" );
sv_master[i]->modified = qfalse;
continue;
}
if ( !strstr( ":", sv_master[i]->string ) ) {
adr[i].port = rtcw::Endian::be ( PORT_MASTER );
}
Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", sv_master[i]->string,
adr[i].ip[0], adr[i].ip[1], adr[i].ip[2], adr[i].ip[3],
rtcw::Endian::be ( adr[i].port ) );
}
Com_Printf( "Sending gameCompleteStatus to %s\n", sv_master[i]->string );
// this command should be changed if the server info / status format
// ever incompatably changes
SVC_GameCompleteStatus( adr[i] );
}
}
#endif // RTCW_XX
/*
=================
SV_MasterShutdown
Informs all masters that this server is going down
=================
*/
void SV_MasterShutdown( void ) {
// send a hearbeat right now
svs.nextHeartbeatTime = -9999;
#if defined RTCW_SP
SV_MasterHeartbeat();
#else
SV_MasterHeartbeat( HEARTBEAT_DEAD ); // NERVE - SMF - changed to flatline
#endif // RTCW_XX
// send it again to minimize chance of drops
#if defined RTCW_SP
svs.nextHeartbeatTime = -9999;
SV_MasterHeartbeat();
#else
// svs.nextHeartbeatTime = -9999;
// SV_MasterHeartbeat( HEARTBEAT_DEAD );
#endif // RTCW_XX
// when the master tries to poll the server, it won't respond, so
// it will be removed from the list
}
/*
==================
SV_Frame
Player movement occurs as a result of packet events, which
happen before SV_Frame is called
==================
*/
void SV_Frame( int msec ) {
int frameMsec;
int startTime;
#if !defined RTCW_SP
char mapname[MAX_QPATH];
#endif // RTCW_XX
#if defined RTCW_ET
int frameStartTime = 0, frameEndTime;
#endif // RTCW_XX
// the menu kills the server with this cvar
if ( sv_killserver->integer ) {
SV_Shutdown( "Server was killed.\n" );
Cvar_Set( "sv_killserver", "0" );
return;
}
if ( !com_sv_running->integer ) {
return;
}
// allow pause if only the local client is connected
if ( SV_CheckPaused() ) {
return;
}
#if defined RTCW_ET
if ( com_dedicated->integer ) {
frameStartTime = Sys_Milliseconds();
}
#endif // RTCW_XX
// if it isn't time for the next frame, do nothing
if ( sv_fps->integer < 1 ) {
Cvar_Set( "sv_fps", "10" );
}
frameMsec = 1000 / sv_fps->integer ;
sv.timeResidual += msec;
if ( !com_dedicated->integer ) {
SV_BotFrame( svs.time + sv.timeResidual );
}
if ( com_dedicated->integer && sv.timeResidual < frameMsec ) {
// NET_Sleep will give the OS time slices until either get a packet
// or time enough for a server frame has gone by
NET_Sleep( frameMsec - sv.timeResidual );
return;
}
// if time is about to hit the 32nd bit, kick all clients
// and clear sv.time, rather
// than checking for negative time wraparound everywhere.
// 2giga-milliseconds = 23 days, so it won't be too often
if ( svs.time > 0x70000000 ) {
#if defined RTCW_SP
SV_Shutdown( "Restarting server due to time wrapping" );
Cbuf_AddText( "vstr nextmap\n" );
#else
Q_strncpyz( mapname, sv_mapname->string, MAX_QPATH );
SV_Shutdown( "Restarting server due to time wrapping" );
// TTimo
// show_bug.cgi?id=388
// there won't be a map_restart if you have shut down the server
// since it doesn't restart a non-running server
// instead, re-run the current map
Cbuf_AddText( va( "map %s\n", mapname ) );
#endif // RTCW_XX
return;
}
// this can happen considerably earlier when lots of clients play and the map doesn't change
if ( svs.nextSnapshotEntities >= 0x7FFFFFFE - svs.numSnapshotEntities ) {
#if defined RTCW_SP
SV_Shutdown( "Restarting server due to numSnapshotEntities wrapping" );
Cbuf_AddText( "vstr nextmap\n" );
#else
Q_strncpyz( mapname, sv_mapname->string, MAX_QPATH );
SV_Shutdown( "Restarting server due to numSnapshotEntities wrapping" );
// TTimo see above
Cbuf_AddText( va( "map %s\n", mapname ) );
#endif // RTCW_XX
return;
}
if ( sv.restartTime && svs.time >= sv.restartTime ) {
sv.restartTime = 0;
Cbuf_AddText( "map_restart 0\n" );
return;
}
// update infostrings if anything has been changed
if ( cvar_modifiedFlags & CVAR_SERVERINFO ) {
#if !defined RTCW_ET
SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
#else
SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO | CVAR_SERVERINFO_NOUPDATE ) );
#endif // RTCW_XX
cvar_modifiedFlags &= ~CVAR_SERVERINFO;
}
#if defined RTCW_ET
if ( cvar_modifiedFlags & CVAR_SERVERINFO_NOUPDATE ) {
SV_SetConfigstringNoUpdate( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO | CVAR_SERVERINFO_NOUPDATE ) );
cvar_modifiedFlags &= ~CVAR_SERVERINFO_NOUPDATE;
}
#endif // RTCW_XX
if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) {
SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString_Big( CVAR_SYSTEMINFO ) );
cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
}
#if !defined RTCW_SP
// NERVE - SMF
if ( cvar_modifiedFlags & CVAR_WOLFINFO ) {
SV_SetConfigstring( CS_WOLFINFO, Cvar_InfoString( CVAR_WOLFINFO ) );
cvar_modifiedFlags &= ~CVAR_WOLFINFO;
}
#endif // RTCW_XX
if ( com_speeds->integer ) {
startTime = Sys_Milliseconds();
} else {
startTime = 0; // quite a compiler warning
}
// update ping based on the all received frames
SV_CalcPings();
if ( com_dedicated->integer ) {
SV_BotFrame( svs.time );
}
// run the game simulation in chunks
while ( sv.timeResidual >= frameMsec ) {
sv.timeResidual -= frameMsec;
svs.time += frameMsec;
// let everything in the world think and move
#if !defined RTCW_MP || (defined RTCW_MP && !UPDATE_SERVER)
VM_Call( gvm, GAME_RUN_FRAME, svs.time );
#endif // RTCW_XX
}
if ( com_speeds->integer ) {
time_game = Sys_Milliseconds() - startTime;
}
// check timeouts
SV_CheckTimeouts();
// send messages back to the clients
SV_SendClientMessages();
// send a heartbeat to the master if needed
#if defined RTCW_SP
SV_MasterHeartbeat();
#else
SV_MasterHeartbeat( HEARTBEAT_GAME );
#endif // RTCW_XX
#if defined RTCW_ET
if ( com_dedicated->integer ) {
frameEndTime = Sys_Milliseconds();
svs.totalFrameTime += ( frameEndTime - frameStartTime );
svs.currentFrameIndex++;
//if( svs.currentFrameIndex % 50 == 0 )
// Com_Printf( "currentFrameIndex: %i\n", svs.currentFrameIndex );
if ( svs.currentFrameIndex == SERVER_PERFORMANCECOUNTER_FRAMES ) {
int averageFrameTime;
averageFrameTime = svs.totalFrameTime / SERVER_PERFORMANCECOUNTER_FRAMES;
svs.sampleTimes[svs.currentSampleIndex % SERVER_PERFORMANCECOUNTER_SAMPLES] = averageFrameTime;
svs.currentSampleIndex++;
if ( svs.currentSampleIndex > SERVER_PERFORMANCECOUNTER_SAMPLES ) {
int totalTime, i;
totalTime = 0;
for ( i = 0; i < SERVER_PERFORMANCECOUNTER_SAMPLES; i++ ) {
totalTime += svs.sampleTimes[i];
}
if ( !totalTime ) {
totalTime = 1;
}
averageFrameTime = totalTime / SERVER_PERFORMANCECOUNTER_SAMPLES;
svs.serverLoad = ( averageFrameTime / (float)frameMsec ) * 100;
}
//Com_Printf( "serverload: %i (%i/%i)\n", svs.serverLoad, averageFrameTime, frameMsec );
svs.totalFrameTime = 0;
svs.currentFrameIndex = 0;
}
} else
{
svs.serverLoad = -1;
}
#endif // RTCW_XX
}
/*
==================
SV_Frame
Player movement occurs as a result of packet events, which
happen before SV_Frame is called
==================
*/
void SV_Frame( int msec ) {
int frameMsec;
int startTime;
char mapname[MAX_QPATH];
// the menu kills the server with this cvar
if ( sv_killserver->integer ) {
SV_Shutdown( "Server was killed.\n" );
Cvar_Set( "sv_killserver", "0" );
return;
}
if ( !com_sv_running->integer ) {
return;
}
// allow pause if only the local client is connected
if ( SV_CheckPaused() ) {
return;
}
// if it isn't time for the next frame, do nothing
if ( sv_fps->integer < 1 ) {
Cvar_Set( "sv_fps", "10" );
}
frameMsec = 1000 / sv_fps->integer ;
sv.timeResidual += msec;
if ( !com_dedicated->integer ) {
SV_BotFrame( svs.time + sv.timeResidual );
}
if ( com_dedicated->integer && sv.timeResidual < frameMsec ) {
// NET_Sleep will give the OS time slices until either get a packet
// or time enough for a server frame has gone by
NET_Sleep( frameMsec - sv.timeResidual );
return;
}
// if time is about to hit the 32nd bit, kick all clients
// and clear sv.time, rather
// than checking for negative time wraparound everywhere.
// 2giga-milliseconds = 23 days, so it won't be too often
if ( svs.time > 0x70000000 ) {
Q_strncpyz( mapname, sv_mapname->string, MAX_QPATH );
SV_Shutdown( "Restarting server due to time wrapping" );
// TTimo
// show_bug.cgi?id=388
// there won't be a map_restart if you have shut down the server
// since it doesn't restart a non-running server
// instead, re-run the current map
Cbuf_AddText( va( "map %s\n", mapname ) );
return;
}
// this can happen considerably earlier when lots of clients play and the map doesn't change
if ( svs.nextSnapshotEntities >= 0x7FFFFFFE - svs.numSnapshotEntities ) {
Q_strncpyz( mapname, sv_mapname->string, MAX_QPATH );
SV_Shutdown( "Restarting server due to numSnapshotEntities wrapping" );
// TTimo see above
Cbuf_AddText( va( "map %s\n", mapname ) );
return;
}
if ( sv.restartTime && svs.time >= sv.restartTime ) {
sv.restartTime = 0;
Cbuf_AddText( "map_restart 0\n" );
return;
}
// update infostrings if anything has been changed
if ( cvar_modifiedFlags & CVAR_SERVERINFO ) {
SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
cvar_modifiedFlags &= ~CVAR_SERVERINFO;
}
if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) {
SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString_Big( CVAR_SYSTEMINFO ) );
cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
}
// NERVE - SMF
if ( cvar_modifiedFlags & CVAR_WOLFINFO ) {
SV_SetConfigstring( CS_WOLFINFO, Cvar_InfoString( CVAR_WOLFINFO ) );
cvar_modifiedFlags &= ~CVAR_WOLFINFO;
}
if ( com_speeds->integer ) {
startTime = Sys_Milliseconds();
} else {
startTime = 0; // quite a compiler warning
}
// update ping based on the all received frames
SV_CalcPings();
if ( com_dedicated->integer ) {
SV_BotFrame( svs.time );
}
// run the game simulation in chunks
while ( sv.timeResidual >= frameMsec ) {
sv.timeResidual -= frameMsec;
svs.time += frameMsec;
// let everything in the world think and move
#ifndef UPDATE_SERVER
VM_Call( gvm, GAME_RUN_FRAME, svs.time );
#endif
}
if ( com_speeds->integer ) {
time_game = Sys_Milliseconds() - startTime;
}
// check timeouts
SV_CheckTimeouts();
// send messages back to the clients
SV_SendClientMessages();
// send a heartbeat to the master if needed
SV_MasterHeartbeat( HEARTBEAT_GAME );
}
