/*
==================
Host_ShutdownServer
This only happens at the end of a game, not between levels
==================
*/
void Host_ShutdownServer(void)
{
prvm_prog_t *prog = SVVM_prog;
int i;
Con_DPrintf("Host_ShutdownServer\n");
if (!sv.active)
return;
NetConn_Heartbeat(2);
NetConn_Heartbeat(2);
// make sure all the clients know we're disconnecting
World_End(&sv.world);
if(prog->loaded)
{
if(PRVM_serverfunction(SV_Shutdown))
{
func_t s = PRVM_serverfunction(SV_Shutdown);
PRVM_serverglobalfloat(time) = sv.time;
PRVM_serverfunction(SV_Shutdown) = 0; // prevent it from getting called again
prog->ExecuteProgram(prog, s,"SV_Shutdown() required");
}
}
for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
if (host_client->active)
SV_DropClient(false); // server shutdown
NetConn_CloseServerPorts();
sv.active = false;
//
// clear structures
//
memset(&sv, 0, sizeof(sv));
memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
cl.islocalgame = false;
}
/*
==================
Host_ShutdownServer
This only happens at the end of a game, not between levels
==================
*/
void Host_ShutdownServer(void)
{
int i;
Con_DPrintf("Host_ShutdownServer\n");
if (!sv.active)
return;
NetConn_Heartbeat(2);
NetConn_Heartbeat(2);
// make sure all the clients know we're disconnecting
SV_VM_Begin();
World_End(&sv.world);
if(prog->loaded)
if(prog->funcoffsets.SV_Shutdown)
{
func_t s = prog->funcoffsets.SV_Shutdown;
prog->funcoffsets.SV_Shutdown = 0; // prevent it from getting called again
PRVM_ExecuteProgram(s,"SV_Shutdown() required");
}
for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
if (host_client->active)
SV_DropClient(false); // server shutdown
SV_VM_End();
NetConn_CloseServerPorts();
sv.active = false;
//
// clear structures
//
memset(&sv, 0, sizeof(sv));
memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
}
void Host_Main(void)
{
double time1 = 0;
double time2 = 0;
double time3 = 0;
double cl_timer = 0, sv_timer = 0;
double clframetime, deltacleantime, olddirtytime, dirtytime;
double wait;
int pass1, pass2, pass3, i;
char vabuf[1024];
qboolean playing;
Host_Init();
realtime = 0;
host_dirtytime = Sys_DirtyTime();
for (;;)
{
if (setjmp(host_abortframe))
{
SCR_ClearLoadingScreen(false);
continue; // something bad happened, or the server disconnected
}
olddirtytime = host_dirtytime;
dirtytime = Sys_DirtyTime();
deltacleantime = dirtytime - olddirtytime;
if (deltacleantime < 0)
{
// warn if it's significant
if (deltacleantime < -0.01)
Con_Printf("Host_Mingled: time stepped backwards (went from %f to %f, difference %f)\n", olddirtytime, dirtytime, deltacleantime);
deltacleantime = 0;
}
else if (deltacleantime >= 1800)
{
Con_Printf("Host_Mingled: time stepped forward (went from %f to %f, difference %f)\n", olddirtytime, dirtytime, deltacleantime);
deltacleantime = 0;
}
realtime += deltacleantime;
host_dirtytime = dirtytime;
cl_timer += deltacleantime;
sv_timer += deltacleantime;
if (!svs.threaded)
{
svs.perf_acc_realtime += deltacleantime;
// Look for clients who have spawned
playing = false;
for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
if(host_client->begun)
if(host_client->netconnection)
playing = true;
if(sv.time < 10)
{
// don't accumulate time for the first 10 seconds of a match
// so things can settle
svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0;
}
else if(svs.perf_acc_realtime > 5)
{
svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime;
svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime;
if(svs.perf_acc_offset_samples > 0)
{
svs.perf_offset_max = svs.perf_acc_offset_max;
svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples;
svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg);
}
if(svs.perf_lost > 0 && developer_extra.integer)
if(playing) // only complain if anyone is looking
Con_DPrintf("Server can't keep up: %s\n", Host_TimingReport(vabuf, sizeof(vabuf)));
svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0;
}
}
if (slowmo.value < 0.00001 && slowmo.value != 0)
Cvar_SetValue("slowmo", 0);
if (host_framerate.value < 0.00001 && host_framerate.value != 0)
Cvar_SetValue("host_framerate", 0);
// keep the random time dependent, but not when playing demos/benchmarking
if(!*sv_random_seed.string && !cls.demoplayback)
rand();
// get new key events
Key_EventQueue_Unblock();
SndSys_SendKeyEvents();
Sys_SendKeyEvents();
NetConn_UpdateSockets();
Log_DestBuffer_Flush();
// receive packets on each main loop iteration, as the main loop may
// be undersleeping due to select() detecting a new packet
if (sv.active && !svs.threaded)
NetConn_ServerFrame();
Curl_Run();
// check for commands typed to the host
Host_GetConsoleCommands();
// when a server is running we only execute console commands on server frames
// (this mainly allows frikbot .way config files to work properly by staying in sync with the server qc)
// otherwise we execute them on client frames
if (sv.active ? sv_timer > 0 : cl_timer > 0)
{
// process console commands
// R_TimeReport("preconsole");
CL_VM_PreventInformationLeaks();
Cbuf_Frame();
// R_TimeReport("console");
}
//Con_Printf("%6.0f %6.0f\n", cl_timer * 1000000.0, sv_timer * 1000000.0);
// if the accumulators haven't become positive yet, wait a while
if (cls.state == ca_dedicated)
wait = sv_timer * -1000000.0;
else if (!sv.active || svs.threaded)
wait = cl_timer * -1000000.0;
else
wait = max(cl_timer, sv_timer) * -1000000.0;
if (!cls.timedemo && wait >= 1)
{
double time0, delta;
if(host_maxwait.value <= 0)
wait = min(wait, 1000000.0);
else
wait = min(wait, host_maxwait.value * 1000.0);
if(wait < 1)
wait = 1; // because we cast to int
time0 = Sys_DirtyTime();
if (sv_checkforpacketsduringsleep.integer && !sys_usenoclockbutbenchmark.integer && !svs.threaded) {
NetConn_SleepMicroseconds((int)wait);
if (cls.state != ca_dedicated)
NetConn_ClientFrame(); // helps server browser get good ping values
// TODO can we do the same for ServerFrame? Probably not.
}
else
Sys_Sleep((int)wait);
delta = Sys_DirtyTime() - time0;
if (delta < 0 || delta >= 1800) delta = 0;
if (!svs.threaded)
svs.perf_acc_sleeptime += delta;
// R_TimeReport("sleep");
continue;
}
// limit the frametime steps to no more than 100ms each
if (cl_timer > 0.1)
cl_timer = 0.1;
if (sv_timer > 0.1)
{
if (!svs.threaded)
svs.perf_acc_lost += (sv_timer - 0.1);
sv_timer = 0.1;
}
R_TimeReport("---");
//-------------------
//
// server operations
//
//-------------------
// limit the frametime steps to no more than 100ms each
if (sv.active && sv_timer > 0 && !svs.threaded)
{
// execute one or more server frames, with an upper limit on how much
// execution time to spend on server frames to avoid freezing the game if
// the server is overloaded, this execution time limit means the game will
// slow down if the server is taking too long.
int framecount, framelimit = 1;
double advancetime, aborttime = 0;
float offset;
prvm_prog_t *prog = SVVM_prog;
// run the world state
// don't allow simulation to run too fast or too slow or logic glitches can occur
// stop running server frames if the wall time reaches this value
if (sys_ticrate.value <= 0)
advancetime = sv_timer;
else if (cl.islocalgame && !sv_fixedframeratesingleplayer.integer)
{
// synchronize to the client frametime, but no less than 10ms and no more than 100ms
advancetime = bound(0.01, cl_timer, 0.1);
}
else
{
advancetime = sys_ticrate.value;
// listen servers can run multiple server frames per client frame
framelimit = cl_maxphysicsframesperserverframe.integer;
aborttime = Sys_DirtyTime() + 0.1;
}
if(slowmo.value > 0 && slowmo.value < 1)
advancetime = min(advancetime, 0.1 / slowmo.value);
else
advancetime = min(advancetime, 0.1);
if(advancetime > 0)
{
offset = Sys_DirtyTime() - dirtytime;if (offset < 0 || offset >= 1800) offset = 0;
offset += sv_timer;
++svs.perf_acc_offset_samples;
svs.perf_acc_offset += offset;
svs.perf_acc_offset_squared += offset * offset;
if(svs.perf_acc_offset_max < offset)
svs.perf_acc_offset_max = offset;
}
// only advance time if not paused
// the game also pauses in singleplayer when menu or console is used
sv.frametime = advancetime * slowmo.value;
if (host_framerate.value)
sv.frametime = host_framerate.value;
if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
sv.frametime = 0;
for (framecount = 0;framecount < framelimit && sv_timer > 0;framecount++)
{
sv_timer -= advancetime;
// move things around and think unless paused
if (sv.frametime)
SV_Physics();
// if this server frame took too long, break out of the loop
if (framelimit > 1 && Sys_DirtyTime() >= aborttime)
break;
}
R_TimeReport("serverphysics");
// send all messages to the clients
SV_SendClientMessages();
if (sv.paused == 1 && realtime > sv.pausedstart && sv.pausedstart > 0) {
prog->globals.fp[OFS_PARM0] = realtime - sv.pausedstart;
PRVM_serverglobalfloat(time) = sv.time;
prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing");
}
// send an heartbeat if enough time has passed since the last one
NetConn_Heartbeat(0);
R_TimeReport("servernetwork");
}
else if (!svs.threaded)
{
// don't let r_speeds display jump around
R_TimeReport("serverphysics");
R_TimeReport("servernetwork");
}
//-------------------
//
// client operations
//
//-------------------
if (cls.state != ca_dedicated && (cl_timer > 0 || cls.timedemo || ((vid_activewindow ? cl_maxfps : cl_maxidlefps).value < 1)))
{
R_TimeReport("---");
Collision_Cache_NewFrame();
R_TimeReport("photoncache");
// decide the simulation time
if (cls.capturevideo.active)
{
//***
if (cls.capturevideo.realtime)
clframetime = cl.realframetime = max(cl_timer, 1.0 / cls.capturevideo.framerate);
else
{
clframetime = 1.0 / cls.capturevideo.framerate;
cl.realframetime = max(cl_timer, clframetime);
}
}
else if (vid_activewindow && cl_maxfps.value >= 1 && !cls.timedemo)
{
clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxfps.value);
// when running slow, we need to sleep to keep input responsive
wait = bound(0, cl_maxfps_alwayssleep.value * 1000, 100000);
if (wait > 0)
Sys_Sleep((int)wait);
}
else if (!vid_activewindow && cl_maxidlefps.value >= 1 && !cls.timedemo)
clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxidlefps.value);
else
clframetime = cl.realframetime = cl_timer;
// apply slowmo scaling
clframetime *= cl.movevars_timescale;
// scale playback speed of demos by slowmo cvar
if (cls.demoplayback)
{
clframetime *= slowmo.value;
// if demo playback is paused, don't advance time at all
if (cls.demopaused)
clframetime = 0;
}
else
{
// host_framerate overrides all else
if (host_framerate.value)
clframetime = host_framerate.value;
if (cl.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
clframetime = 0;
}
if (cls.timedemo)
clframetime = cl.realframetime = cl_timer;
// deduct the frame time from the accumulator
cl_timer -= cl.realframetime;
cl.oldtime = cl.time;
cl.time += clframetime;
// update video
if (host_speeds.integer)
time1 = Sys_DirtyTime();
R_TimeReport("pre-input");
// Collect input into cmd
CL_Input();
R_TimeReport("input");
// check for new packets
NetConn_ClientFrame();
// read a new frame from a demo if needed
CL_ReadDemoMessage();
R_TimeReport("clientnetwork");
// now that packets have been read, send input to server
CL_SendMove();
R_TimeReport("sendmove");
// update client world (interpolate entities, create trails, etc)
CL_UpdateWorld();
R_TimeReport("lerpworld");
CL_Video_Frame();
R_TimeReport("client");
CL_UpdateScreen();
CL_MeshEntities_Reset();
R_TimeReport("render");
if (host_speeds.integer)
time2 = Sys_DirtyTime();
// update audio
if(cl.csqc_usecsqclistener)
{
S_Update(&cl.csqc_listenermatrix);
cl.csqc_usecsqclistener = false;
}
else
S_Update(&r_refdef.view.matrix);
CDAudio_Update();
R_TimeReport("audio");
// reset gathering of mouse input
in_mouse_x = in_mouse_y = 0;
if (host_speeds.integer)
{
pass1 = (int)((time1 - time3)*1000000);
time3 = Sys_DirtyTime();
pass2 = (int)((time2 - time1)*1000000);
pass3 = (int)((time3 - time2)*1000000);
Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n",
pass1+pass2+pass3, pass1, pass2, pass3);
}
}
#if MEMPARANOIA
Mem_CheckSentinelsGlobal();
#else
if (developer_memorydebug.integer)
Mem_CheckSentinelsGlobal();
#endif
// if there is some time remaining from this frame, reset the timers
if (cl_timer >= 0)
cl_timer = 0;
if (sv_timer >= 0)
{
if (!svs.threaded)
svs.perf_acc_lost += sv_timer;
sv_timer = 0;
}
host_framecount++;
}
}
/*
=====================
SV_DropClient
Called when the player is getting totally kicked off the host
if (crash = true), don't bother sending signofs
=====================
*/
void SV_DropClient(qboolean crash)
{
prvm_prog_t *prog = SVVM_prog;
int i;
Con_Printf("Client \"%s\" dropped\n", host_client->name);
SV_StopDemoRecording(host_client);
// make sure edict is not corrupt (from a level change for example)
host_client->edict = PRVM_EDICT_NUM(host_client - svs.clients + 1);
if (host_client->netconnection)
{
// tell the client to be gone
if (!crash)
{
// LordHavoc: no opportunity for resending, so use unreliable 3 times
unsigned char bufdata[8];
sizebuf_t buf;
memset(&buf, 0, sizeof(buf));
buf.data = bufdata;
buf.maxsize = sizeof(bufdata);
MSG_WriteByte(&buf, svc_disconnect);
NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
}
}
// call qc ClientDisconnect function
// LordHavoc: don't call QC if server is dead (avoids recursive
// Host_Error in some mods when they run out of edicts)
if (host_client->clientconnectcalled && sv.active && host_client->edict)
{
// call the prog function for removing a client
// this will set the body to a dead frame, among other things
int saveSelf = PRVM_serverglobaledict(self);
host_client->clientconnectcalled = false;
PRVM_serverglobalfloat(time) = sv.time;
PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
prog->ExecuteProgram(prog, PRVM_serverfunction(ClientDisconnect), "QC function ClientDisconnect is missing");
PRVM_serverglobaledict(self) = saveSelf;
}
if (host_client->netconnection)
{
// break the net connection
NetConn_Close(host_client->netconnection);
host_client->netconnection = NULL;
}
// if a download is active, close it
if (host_client->download_file)
{
Con_DPrintf("Download of %s aborted when %s dropped\n", host_client->download_name, host_client->name);
FS_Close(host_client->download_file);
host_client->download_file = NULL;
host_client->download_name[0] = 0;
host_client->download_expectedposition = 0;
host_client->download_started = false;
}
// remove leaving player from scoreboard
host_client->name[0] = 0;
host_client->colors = 0;
host_client->frags = 0;
// send notification to all clients
// get number of client manually just to make sure we get it right...
i = host_client - svs.clients;
MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
MSG_WriteByte (&sv.reliable_datagram, i);
MSG_WriteString (&sv.reliable_datagram, host_client->name);
MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
MSG_WriteByte (&sv.reliable_datagram, i);
MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
MSG_WriteByte (&sv.reliable_datagram, i);
MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
// free the client now
if (host_client->entitydatabase)
EntityFrame_FreeDatabase(host_client->entitydatabase);
if (host_client->entitydatabase4)
EntityFrame4_FreeDatabase(host_client->entitydatabase4);
if (host_client->entitydatabase5)
EntityFrame5_FreeDatabase(host_client->entitydatabase5);
if (sv.active)
{
// clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
PRVM_ED_ClearEdict(prog, host_client->edict);
}
// clear the client struct (this sets active to false)
memset(host_client, 0, sizeof(*host_client));
// update server listing on the master because player count changed
// (which the master uses for filtering empty/full servers)
NetConn_Heartbeat(1);
if (sv.loadgame)
{
for (i = 0;i < svs.maxclients;i++)
if (svs.clients[i].active && !svs.clients[i].spawned)
break;
if (i == svs.maxclients)
{
Con_Printf("Loaded game, everyone rejoined - unpausing\n");
sv.paused = sv.loadgame = false; // we're basically done with loading now
}
}
}