slowmo: when slowmo is < 1, restrict sys_ticrate not to 0.1 but to 0.1 / slowmo....
[divverent/darkplaces.git] / host.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // host.c -- coordinates spawning and killing of local servers
21
22 #include "quakedef.h"
23
24 #include <time.h>
25 #include "libcurl.h"
26 #include "cdaudio.h"
27 #include "cl_gecko.h"
28 #include "cl_video.h"
29 #include "progsvm.h"
30 #include "csprogs.h"
31 #include "sv_demo.h"
32 #include "snd_main.h"
33
34 /*
35
36 A server can always be started, even if the system started out as a client
37 to a remote system.
38
39 A client can NOT be started if the system started as a dedicated server.
40
41 Memory is cleared / released when a server or client begins, not when they end.
42
43 */
44
45 // how many frames have occurred
46 // (checked by Host_Error and Host_SaveConfig_f)
47 int host_framecount = 0;
48 // LordHavoc: set when quit is executed
49 qboolean host_shuttingdown = false;
50
51 // the real time since application started, without any slowmo or clamping
52 double realtime;
53
54 // current client
55 client_t *host_client;
56
57 jmp_buf host_abortframe;
58 double host_starttime = 0;
59
60 // pretend frames take this amount of time (in seconds), 0 = realtime
61 cvar_t host_framerate = {0, "host_framerate","0", "locks frame timing to this value in seconds, 0.05 is 20fps for example, note that this can easily run too fast, use cl_maxfps if you want to limit your framerate instead, or sys_ticrate to limit server speed"};
62 // shows time used by certain subsystems
63 cvar_t host_speeds = {0, "host_speeds","0", "reports how much time is used in server/graphics/sound"};
64 cvar_t cl_minfps = {CVAR_SAVE, "cl_minfps", "40", "minimum fps target - while the rendering performance is below this, it will drift toward lower quality"};
65 cvar_t cl_minfps_fade = {CVAR_SAVE, "cl_minfps_fade", "0.2", "how fast the quality adapts to varying framerate"};
66 cvar_t cl_minfps_qualitymax = {CVAR_SAVE, "cl_minfps_qualitymax", "1", "highest allowed drawdistance multiplier"};
67 cvar_t cl_minfps_qualitymin = {CVAR_SAVE, "cl_minfps_qualitymin", "0.25", "lowest allowed drawdistance multiplier"};
68 cvar_t cl_minfps_qualitypower = {CVAR_SAVE, "cl_minfps_qualitypower", "4", "raises quality value to a power of itself, higher values make quality drop more sharply in relation to framerate"};
69 cvar_t cl_minfps_qualityscale = {CVAR_SAVE, "cl_minfps_qualityscale", "0.5", "multiplier for quality"};
70 cvar_t cl_maxfps = {CVAR_SAVE, "cl_maxfps", "0", "maximum fps cap, 0 = unlimited, if game is running faster than this it will wait before running another frame (useful to make cpu time available to other programs)"};
71 cvar_t cl_maxfps_alwayssleep = {0, "cl_maxfps_alwayssleep","1", "gives up some processing time to other applications each frame, value in milliseconds, disabled if cl_maxfps is 0"};
72 cvar_t cl_maxidlefps = {CVAR_SAVE, "cl_maxidlefps", "20", "maximum fps cap when the game is not the active window (makes cpu time available to other programs"};
73
74 cvar_t developer = {0, "developer","0", "prints additional debugging messages and information (recommended for modders and level designers)"};
75 cvar_t developer_loadfile = {0, "developer_loadfile","0", "prints name and size of every file loaded via the FS_LoadFile function (which is almost everything)"};
76 cvar_t developer_loading = {0, "developer_loading","0", "prints information about files as they are loaded or unloaded successfully"};
77 cvar_t developer_entityparsing = {0, "developer_entityparsing", "0", "prints detailed network entities information each time a packet is received"};
78
79 cvar_t timestamps = {CVAR_SAVE, "timestamps", "0", "prints timestamps on console messages"};
80 cvar_t timeformat = {CVAR_SAVE, "timeformat", "[%Y-%m-%d %H:%M:%S] ", "time format to use on timestamped console messages"};
81
82 /*
83 ================
84 Host_AbortCurrentFrame
85
86 aborts the current host frame and goes on with the next one
87 ================
88 */
89 void Host_AbortCurrentFrame(void)
90 {
91         longjmp (host_abortframe, 1);
92 }
93
94 /*
95 ================
96 Host_Error
97
98 This shuts down both the client and server
99 ================
100 */
101 void Host_Error (const char *error, ...)
102 {
103         static char hosterrorstring1[MAX_INPUTLINE];
104         static char hosterrorstring2[MAX_INPUTLINE];
105         static qboolean hosterror = false;
106         va_list argptr;
107
108         // turn off rcon redirect if it was active when the crash occurred
109         // to prevent loops when it is a networking problem
110         Con_Rcon_Redirect_Abort();
111
112         va_start (argptr,error);
113         dpvsnprintf (hosterrorstring1,sizeof(hosterrorstring1),error,argptr);
114         va_end (argptr);
115
116         Con_Printf("Host_Error: %s\n", hosterrorstring1);
117
118         // LordHavoc: if crashing very early, or currently shutting down, do
119         // Sys_Error instead
120         if (host_framecount < 3 || host_shuttingdown)
121                 Sys_Error ("Host_Error: %s", hosterrorstring1);
122
123         if (hosterror)
124                 Sys_Error ("Host_Error: recursively entered (original error was: %s    new error is: %s)", hosterrorstring2, hosterrorstring1);
125         hosterror = true;
126
127         strlcpy(hosterrorstring2, hosterrorstring1, sizeof(hosterrorstring2));
128
129         CL_Parse_DumpPacket();
130
131         CL_Parse_ErrorCleanUp();
132
133         //PR_Crash();
134
135         // print out where the crash happened, if it was caused by QC (and do a cleanup)
136         PRVM_Crash();
137
138
139         Host_ShutdownServer ();
140
141         if (cls.state == ca_dedicated)
142                 Sys_Error ("Host_Error: %s",hosterrorstring2);  // dedicated servers exit
143
144         CL_Disconnect ();
145         cls.demonum = -1;
146
147         hosterror = false;
148
149         Host_AbortCurrentFrame();
150 }
151
152 void Host_ServerOptions (void)
153 {
154         int i;
155
156         // general default
157         svs.maxclients = 8;
158
159 // COMMANDLINEOPTION: Server: -dedicated [playerlimit] starts a dedicated server (with a command console), default playerlimit is 8
160 // COMMANDLINEOPTION: Server: -listen [playerlimit] starts a multiplayer server with graphical client, like singleplayer but other players can connect, default playerlimit is 8
161         // if no client is in the executable or -dedicated is specified on
162         // commandline, start a dedicated server
163         i = COM_CheckParm ("-dedicated");
164         if (i || !cl_available)
165         {
166                 cls.state = ca_dedicated;
167                 // check for -dedicated specifying how many players
168                 if (i && i + 1 < com_argc && atoi (com_argv[i+1]) >= 1)
169                         svs.maxclients = atoi (com_argv[i+1]);
170                 if (COM_CheckParm ("-listen"))
171                         Con_Printf ("Only one of -dedicated or -listen can be specified\n");
172                 // default sv_public on for dedicated servers (often hosted by serious administrators), off for listen servers (often hosted by clueless users)
173                 Cvar_SetValue("sv_public", 1);
174         }
175         else if (cl_available)
176         {
177                 // client exists and not dedicated, check if -listen is specified
178                 cls.state = ca_disconnected;
179                 i = COM_CheckParm ("-listen");
180                 if (i)
181                 {
182                         // default players unless specified
183                         if (i + 1 < com_argc && atoi (com_argv[i+1]) >= 1)
184                                 svs.maxclients = atoi (com_argv[i+1]);
185                 }
186                 else
187                 {
188                         // default players in some games, singleplayer in most
189                         if (gamemode != GAME_GOODVSBAD2 && gamemode != GAME_NEXUIZ && gamemode != GAME_BATTLEMECH)
190                                 svs.maxclients = 1;
191                 }
192         }
193
194         svs.maxclients = svs.maxclients_next = bound(1, svs.maxclients, MAX_SCOREBOARD);
195
196         svs.clients = (client_t *)Mem_Alloc(sv_mempool, sizeof(client_t) * svs.maxclients);
197
198         if (svs.maxclients > 1 && !deathmatch.integer && !coop.integer)
199                 Cvar_SetValueQuick(&deathmatch, 1);
200 }
201
202 /*
203 =======================
204 Host_InitLocal
205 ======================
206 */
207 void Host_SaveConfig_f(void);
208 void Host_LoadConfig_f(void);
209 extern cvar_t sv_writepicture_quality;
210 static void Host_InitLocal (void)
211 {
212         Cmd_AddCommand("saveconfig", Host_SaveConfig_f, "save settings to config.cfg (or a specified filename) immediately (also automatic when quitting)");
213         Cmd_AddCommand("loadconfig", Host_LoadConfig_f, "reset everything and reload configs");
214
215         Cvar_RegisterVariable (&host_framerate);
216         Cvar_RegisterVariable (&host_speeds);
217         Cvar_RegisterVariable (&cl_minfps);
218         Cvar_RegisterVariable (&cl_minfps_fade);
219         Cvar_RegisterVariable (&cl_minfps_qualitymax);
220         Cvar_RegisterVariable (&cl_minfps_qualitymin);
221         Cvar_RegisterVariable (&cl_minfps_qualitypower);
222         Cvar_RegisterVariable (&cl_minfps_qualityscale);
223         Cvar_RegisterVariable (&cl_maxfps);
224         Cvar_RegisterVariable (&cl_maxfps_alwayssleep);
225         Cvar_RegisterVariable (&cl_maxidlefps);
226
227         Cvar_RegisterVariable (&developer);
228         Cvar_RegisterVariable (&developer_loadfile);
229         Cvar_RegisterVariable (&developer_loading);
230         Cvar_RegisterVariable (&developer_entityparsing);
231
232         Cvar_RegisterVariable (&timestamps);
233         Cvar_RegisterVariable (&timeformat);
234
235         Cvar_RegisterVariable (&sv_writepicture_quality);
236 }
237
238
239 /*
240 ===============
241 Host_SaveConfig_f
242
243 Writes key bindings and archived cvars to config.cfg
244 ===============
245 */
246 void Host_SaveConfig_to(const char *file)
247 {
248         qfile_t *f;
249
250 // dedicated servers initialize the host but don't parse and set the
251 // config.cfg cvars
252         // LordHavoc: don't save a config if it crashed in startup
253         if (host_framecount >= 3 && cls.state != ca_dedicated && !COM_CheckParm("-benchmark") && !COM_CheckParm("-capturedemo"))
254         {
255                 f = FS_OpenRealFile(file, "wb", false);
256                 if (!f)
257                 {
258                         Con_Printf("Couldn't write %s.\n", file);
259                         return;
260                 }
261
262                 Key_WriteBindings (f);
263                 Cvar_WriteVariables (f);
264
265                 FS_Close (f);
266         }
267 }
268 void Host_SaveConfig(void)
269 {
270         Host_SaveConfig_to("config.cfg");
271 }
272 void Host_SaveConfig_f(void)
273 {
274         const char *file = "config.cfg";
275
276         if(Cmd_Argc() >= 2) {
277                 file = Cmd_Argv(1);
278                 Con_Printf("Saving to %s\n", file);
279         }
280
281         Host_SaveConfig_to(file);
282 }
283
284 /*
285 ===============
286 Host_LoadConfig_f
287
288 Resets key bindings and cvars to defaults and then reloads scripts
289 ===============
290 */
291 void Host_LoadConfig_f(void)
292 {
293         // unlock the cvar default strings so they can be updated by the new default.cfg
294         Cvar_UnlockDefaults();
295         // reset cvars to their defaults, and then exec startup scripts again
296         Cbuf_InsertText("cvar_resettodefaults_all;exec quake.rc\n");
297 }
298
299 /*
300 =================
301 SV_ClientPrint
302
303 Sends text across to be displayed
304 FIXME: make this just a stuffed echo?
305 =================
306 */
307 void SV_ClientPrint(const char *msg)
308 {
309         if (host_client->netconnection)
310         {
311                 MSG_WriteByte(&host_client->netconnection->message, svc_print);
312                 MSG_WriteString(&host_client->netconnection->message, msg);
313         }
314 }
315
316 /*
317 =================
318 SV_ClientPrintf
319
320 Sends text across to be displayed
321 FIXME: make this just a stuffed echo?
322 =================
323 */
324 void SV_ClientPrintf(const char *fmt, ...)
325 {
326         va_list argptr;
327         char msg[MAX_INPUTLINE];
328
329         va_start(argptr,fmt);
330         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
331         va_end(argptr);
332
333         SV_ClientPrint(msg);
334 }
335
336 /*
337 =================
338 SV_BroadcastPrint
339
340 Sends text to all active clients
341 =================
342 */
343 void SV_BroadcastPrint(const char *msg)
344 {
345         int i;
346         client_t *client;
347
348         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
349         {
350                 if (client->active && client->netconnection)
351                 {
352                         MSG_WriteByte(&client->netconnection->message, svc_print);
353                         MSG_WriteString(&client->netconnection->message, msg);
354                 }
355         }
356
357         if (sv_echobprint.integer && cls.state == ca_dedicated)
358                 Con_Print(msg);
359 }
360
361 /*
362 =================
363 SV_BroadcastPrintf
364
365 Sends text to all active clients
366 =================
367 */
368 void SV_BroadcastPrintf(const char *fmt, ...)
369 {
370         va_list argptr;
371         char msg[MAX_INPUTLINE];
372
373         va_start(argptr,fmt);
374         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
375         va_end(argptr);
376
377         SV_BroadcastPrint(msg);
378 }
379
380 /*
381 =================
382 Host_ClientCommands
383
384 Send text over to the client to be executed
385 =================
386 */
387 void Host_ClientCommands(const char *fmt, ...)
388 {
389         va_list argptr;
390         char string[MAX_INPUTLINE];
391
392         if (!host_client->netconnection)
393                 return;
394
395         va_start(argptr,fmt);
396         dpvsnprintf(string, sizeof(string), fmt, argptr);
397         va_end(argptr);
398
399         MSG_WriteByte(&host_client->netconnection->message, svc_stufftext);
400         MSG_WriteString(&host_client->netconnection->message, string);
401 }
402
403 /*
404 =====================
405 SV_DropClient
406
407 Called when the player is getting totally kicked off the host
408 if (crash = true), don't bother sending signofs
409 =====================
410 */
411 void SV_DropClient(qboolean crash)
412 {
413         int i;
414         Con_Printf("Client \"%s\" dropped\n", host_client->name);
415
416         SV_StopDemoRecording(host_client);
417
418         // make sure edict is not corrupt (from a level change for example)
419         host_client->edict = PRVM_EDICT_NUM(host_client - svs.clients + 1);
420
421         if (host_client->netconnection)
422         {
423                 // free the client (the body stays around)
424                 if (!crash)
425                 {
426                         // LordHavoc: no opportunity for resending, so use unreliable 3 times
427                         unsigned char bufdata[8];
428                         sizebuf_t buf;
429                         memset(&buf, 0, sizeof(buf));
430                         buf.data = bufdata;
431                         buf.maxsize = sizeof(bufdata);
432                         MSG_WriteByte(&buf, svc_disconnect);
433                         NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, false);
434                         NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, false);
435                         NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, false);
436                 }
437                 // break the net connection
438                 NetConn_Close(host_client->netconnection);
439                 host_client->netconnection = NULL;
440         }
441
442         // call qc ClientDisconnect function
443         // LordHavoc: don't call QC if server is dead (avoids recursive
444         // Host_Error in some mods when they run out of edicts)
445         if (host_client->clientconnectcalled && sv.active && host_client->edict)
446         {
447                 // call the prog function for removing a client
448                 // this will set the body to a dead frame, among other things
449                 int saveSelf = prog->globals.server->self;
450                 host_client->clientconnectcalled = false;
451                 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
452                 PRVM_ExecuteProgram(prog->globals.server->ClientDisconnect, "QC function ClientDisconnect is missing");
453                 prog->globals.server->self = saveSelf;
454         }
455
456         // if a download is active, close it
457         if (host_client->download_file)
458         {
459                 Con_DPrintf("Download of %s aborted when %s dropped\n", host_client->download_name, host_client->name);
460                 FS_Close(host_client->download_file);
461                 host_client->download_file = NULL;
462                 host_client->download_name[0] = 0;
463                 host_client->download_expectedposition = 0;
464                 host_client->download_started = false;
465         }
466
467         // remove leaving player from scoreboard
468         host_client->name[0] = 0;
469         host_client->colors = 0;
470         host_client->frags = 0;
471         // send notification to all clients
472         // get number of client manually just to make sure we get it right...
473         i = host_client - svs.clients;
474         MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
475         MSG_WriteByte (&sv.reliable_datagram, i);
476         MSG_WriteString (&sv.reliable_datagram, host_client->name);
477         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
478         MSG_WriteByte (&sv.reliable_datagram, i);
479         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
480         MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
481         MSG_WriteByte (&sv.reliable_datagram, i);
482         MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
483
484         // free the client now
485         if (host_client->entitydatabase)
486                 EntityFrame_FreeDatabase(host_client->entitydatabase);
487         if (host_client->entitydatabase4)
488                 EntityFrame4_FreeDatabase(host_client->entitydatabase4);
489         if (host_client->entitydatabase5)
490                 EntityFrame5_FreeDatabase(host_client->entitydatabase5);
491
492         if (sv.active)
493         {
494                 // clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
495                 PRVM_ED_ClearEdict(host_client->edict);
496         }
497
498         // clear the client struct (this sets active to false)
499         memset(host_client, 0, sizeof(*host_client));
500
501         // update server listing on the master because player count changed
502         // (which the master uses for filtering empty/full servers)
503         NetConn_Heartbeat(1);
504
505         if (sv.loadgame)
506         {
507                 for (i = 0;i < svs.maxclients;i++)
508                         if (svs.clients[i].active && !svs.clients[i].spawned)
509                                 break;
510                 if (i == svs.maxclients)
511                 {
512                         Con_Printf("Loaded game, everyone rejoined - unpausing\n");
513                         sv.paused = sv.loadgame = false; // we're basically done with loading now
514                 }
515         }
516 }
517
518 /*
519 ==================
520 Host_ShutdownServer
521
522 This only happens at the end of a game, not between levels
523 ==================
524 */
525 void Host_ShutdownServer(void)
526 {
527         int i;
528
529         Con_DPrintf("Host_ShutdownServer\n");
530
531         if (!sv.active)
532                 return;
533
534         NetConn_Heartbeat(2);
535         NetConn_Heartbeat(2);
536
537 // make sure all the clients know we're disconnecting
538         SV_VM_Begin();
539         World_End(&sv.world);
540         if(prog->loaded)
541                 if(prog->funcoffsets.SV_Shutdown)
542                 {
543                         func_t s = prog->funcoffsets.SV_Shutdown;
544                         prog->funcoffsets.SV_Shutdown = 0; // prevent it from getting called again
545                         PRVM_ExecuteProgram(s,"SV_Shutdown() required");
546                 }
547         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
548                 if (host_client->active)
549                         SV_DropClient(false); // server shutdown
550         SV_VM_End();
551
552         NetConn_CloseServerPorts();
553
554         sv.active = false;
555 //
556 // clear structures
557 //
558         memset(&sv, 0, sizeof(sv));
559         memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
560 }
561
562
563 //============================================================================
564
565 /*
566 ===================
567 Host_GetConsoleCommands
568
569 Add them exactly as if they had been typed at the console
570 ===================
571 */
572 void Host_GetConsoleCommands (void)
573 {
574         char *cmd;
575
576         while (1)
577         {
578                 cmd = Sys_ConsoleInput ();
579                 if (!cmd)
580                         break;
581                 Cbuf_AddText (cmd);
582         }
583 }
584
585 /*
586 ==================
587 Host_TimeReport
588
589 Returns a time report string, for example for
590 ==================
591 */
592 const char *Host_TimingReport(void)
593 {
594         return va("%.1f%% CPU, %.2f%% lost, offset avg %.1fms, max %.1fms, sdev %.1fms", svs.perf_cpuload * 100, svs.perf_lost * 100, svs.perf_offset_avg * 1000, svs.perf_offset_max * 1000, svs.perf_offset_sdev * 1000);
595 }
596
597 /*
598 ==================
599 Host_Frame
600
601 Runs all active servers
602 ==================
603 */
604 static void Host_Init(void);
605 void Host_Main(void)
606 {
607         double time1 = 0;
608         double time2 = 0;
609         double time3 = 0;
610         double cl_timer, sv_timer;
611         double clframetime, deltarealtime, oldrealtime;
612         double wait;
613         int pass1, pass2, pass3, i;
614
615         Host_Init();
616
617         cl_timer = 0;
618         sv_timer = 0;
619
620         realtime = host_starttime = Sys_DoubleTime();
621         for (;;)
622         {
623                 if (setjmp(host_abortframe))
624                 {
625                         SCR_ClearLoadingScreen(false);
626                         continue;                       // something bad happened, or the server disconnected
627                 }
628
629                 oldrealtime = realtime;
630                 realtime = Sys_DoubleTime();
631
632                 deltarealtime = realtime - oldrealtime;
633                 cl_timer += deltarealtime;
634                 sv_timer += deltarealtime;
635
636                 svs.perf_acc_realtime += deltarealtime;
637
638                 // Look for clients who have spawned
639                 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
640                         if(host_client->spawned)
641                                 if(host_client->netconnection)
642                                         break;
643                 if(i == svs.maxclients)
644                 {
645                         // Nobody is looking? Then we won't do timing...
646                         // Instead, reset it to zero
647                         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;
648                 }
649                 else if(svs.perf_acc_realtime > 5)
650                 {
651                         svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime;
652                         svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime;
653                         if(svs.perf_acc_offset_samples > 0)
654                         {
655                                 svs.perf_offset_max = svs.perf_acc_offset_max;
656                                 svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples;
657                                 svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg);
658                         }
659                         if(svs.perf_lost > 0)
660                                 Con_DPrintf("Server can't keep up: %s\n", Host_TimingReport());
661                         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;
662                 }
663
664                 if (slowmo.value < 0.00001 && slowmo.value != 0)
665                         Cvar_SetValue("slowmo", 0);
666                 if (host_framerate.value < 0.00001 && host_framerate.value != 0)
667                         Cvar_SetValue("host_framerate", 0);
668
669                 // keep the random time dependent, but not when playing demos/benchmarking
670                 if(!*sv_random_seed.string && !cls.demoplayback)
671                         rand();
672
673                 cl.islocalgame = NetConn_IsLocalGame();
674
675                 // get new key events
676                 SndSys_SendKeyEvents();
677                 Sys_SendKeyEvents();
678
679                 NetConn_UpdateSockets();
680
681                 Log_DestBuffer_Flush();
682
683                 // receive packets on each main loop iteration, as the main loop may
684                 // be undersleeping due to select() detecting a new packet
685                 if (sv.active)
686                         NetConn_ServerFrame();
687
688                 Curl_Run();
689
690                 // check for commands typed to the host
691                 Host_GetConsoleCommands();
692
693                 // when a server is running we only execute console commands on server frames
694                 // (this mainly allows frikbot .way config files to work properly by staying in sync with the server qc)
695                 // otherwise we execute them on client frames
696                 if (sv.active ? sv_timer > 0 : cl_timer > 0)
697                 {
698                         // process console commands
699                         CL_VM_PreventInformationLeaks();
700                         Cbuf_Execute();
701                 }
702
703                 //Con_Printf("%6.0f %6.0f\n", cl_timer * 1000000.0, sv_timer * 1000000.0);
704
705                 // if the accumulators haven't become positive yet, wait a while
706                 if (cls.state == ca_dedicated)
707                         wait = sv_timer * -1000000.0;
708                 else if (!sv.active)
709                         wait = cl_timer * -1000000.0;
710                 else
711                         wait = max(cl_timer, sv_timer) * -1000000.0;
712                 wait = bound(0, wait, 100000);
713
714                 if (!cls.timedemo && wait >= 1)
715                 {
716                         double time0 = Sys_DoubleTime();
717                         if (sv_checkforpacketsduringsleep.integer)
718                                 NetConn_SleepMicroseconds((int)wait);
719                         else
720                                 Sys_Sleep((int)wait);
721                         svs.perf_acc_sleeptime += Sys_DoubleTime() - time0;
722                         continue;
723                 }
724
725         //-------------------
726         //
727         // server operations
728         //
729         //-------------------
730
731                 // limit the frametime steps to no more than 100ms each
732                 if (cl_timer > 0.1)
733                         cl_timer = 0.1;
734                 if (sv_timer > 0.1)
735                 {
736                         svs.perf_acc_lost += (sv_timer - 0.1);
737                         sv_timer = 0.1;
738                 }
739
740                 if (sv.active && sv_timer > 0)
741                 {
742                         // execute one or more server frames, with an upper limit on how much
743                         // execution time to spend on server frames to avoid freezing the game if
744                         // the server is overloaded, this execution time limit means the game will
745                         // slow down if the server is taking too long.
746                         int framecount, framelimit = 1;
747                         double advancetime, aborttime = 0;
748                         float offset;
749
750                         // run the world state
751                         // don't allow simulation to run too fast or too slow or logic glitches can occur
752
753                         // stop running server frames if the wall time reaches this value
754                         if (sys_ticrate.value <= 0)
755                                 advancetime = sv_timer;
756                         else if (cl.islocalgame && !sv_fixedframeratesingleplayer.integer)
757                         {
758                                 // synchronize to the client frametime, but no less than 10ms and no more than sys_ticrate
759                                 advancetime = bound(0.01, cl_timer, sys_ticrate.value);
760                                 framelimit = 10;
761                                 aborttime = realtime + 0.1;
762                         }
763                         else
764                         {
765                                 advancetime = sys_ticrate.value;
766                                 // listen servers can run multiple server frames per client frame
767                                 if (cls.state == ca_connected)
768                                 {
769                                         framelimit = 10;
770                                         aborttime = realtime + 0.1;
771                                 }
772                         }
773                         if(slowmo.value > 0 && slowmo.value < 1)
774                                 advancetime = min(advancetime, 0.1 / slowmo.value);
775                         else
776                                 advancetime = min(advancetime, 0.1);
777
778                         if(advancetime > 0)
779                         {
780                                 offset = sv_timer + (Sys_DoubleTime() - realtime);
781                                 ++svs.perf_acc_offset_samples;
782                                 svs.perf_acc_offset += offset;
783                                 svs.perf_acc_offset_squared += offset * offset;
784                                 if(svs.perf_acc_offset_max < offset)
785                                         svs.perf_acc_offset_max = offset;
786                         }
787
788                         // only advance time if not paused
789                         // the game also pauses in singleplayer when menu or console is used
790                         sv.frametime = advancetime * slowmo.value;
791                         if (host_framerate.value)
792                                 sv.frametime = host_framerate.value;
793                         if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive)))
794                                 sv.frametime = 0;
795
796                         // setup the VM frame
797                         SV_VM_Begin();
798
799                         for (framecount = 0;framecount < framelimit && sv_timer > 0;framecount++)
800                         {
801                                 sv_timer -= advancetime;
802
803                                 // move things around and think unless paused
804                                 if (sv.frametime)
805                                         SV_Physics();
806
807                                 // if this server frame took too long, break out of the loop
808                                 if (framelimit > 1 && Sys_DoubleTime() >= aborttime)
809                                         break;
810                         }
811
812                         // send all messages to the clients
813                         SV_SendClientMessages();
814                         
815                         if (sv.paused == 1 && realtime > sv.pausedstart && sv.pausedstart > 0) {
816                                 prog->globals.generic[OFS_PARM0] = realtime - sv.pausedstart;
817                                 PRVM_ExecuteProgram(prog->funcoffsets.SV_PausedTic, "QC function SV_PausedTic is missing");
818                         }
819
820                         // end the server VM frame
821                         SV_VM_End();
822
823                         // send an heartbeat if enough time has passed since the last one
824                         NetConn_Heartbeat(0);
825                 }
826
827         //-------------------
828         //
829         // client operations
830         //
831         //-------------------
832
833                 if (cls.state != ca_dedicated && (cl_timer > 0 || cls.timedemo || ((vid_activewindow ? cl_maxfps : cl_maxidlefps).value < 1)))
834                 {
835                         // decide the simulation time
836                         if (cls.capturevideo.active)
837                         {
838                                 //***
839                                 if (cls.capturevideo.realtime)
840                                         clframetime = cl.realframetime = max(cl_timer, 1.0 / cls.capturevideo.framerate);
841                                 else
842                                 {
843                                         clframetime = 1.0 / cls.capturevideo.framerate;
844                                         cl.realframetime = max(cl_timer, clframetime);
845                                 }
846                         }
847                         else if (vid_activewindow && cl_maxfps.value >= 1 && !cls.timedemo)
848                         {
849                                 clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxfps.value);
850                                 // when running slow, we need to sleep to keep input responsive
851                                 wait = bound(0, cl_maxfps_alwayssleep.value * 1000, 100000);
852                                 if (wait > 0)
853                                         Sys_Sleep((int)wait);
854                         }
855                         else if (!vid_activewindow && cl_maxidlefps.value >= 1 && !cls.timedemo)
856                                 clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxidlefps.value);
857                         else
858                                 clframetime = cl.realframetime = cl_timer;
859
860                         // apply slowmo scaling
861                         clframetime *= cl.movevars_timescale;
862                         // scale playback speed of demos by slowmo cvar
863                         if (cls.demoplayback)
864                         {
865                                 clframetime *= slowmo.value;
866                                 // if demo playback is paused, don't advance time at all
867                                 if (cls.demopaused)
868                                         clframetime = 0;
869                         }
870
871                         // host_framerate overrides all else
872                         if (host_framerate.value)
873                                 clframetime = host_framerate.value;
874
875                         if (cl.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive)))
876                                 clframetime = 0;
877
878                         if (cls.timedemo)
879                                 clframetime = cl.realframetime = cl_timer;
880
881                         // deduct the frame time from the accumulator
882                         cl_timer -= cl.realframetime;
883
884                         cl.oldtime = cl.time;
885                         cl.time += clframetime;
886
887                         // update video
888                         if (host_speeds.integer)
889                                 time1 = Sys_DoubleTime();
890
891                         // Collect input into cmd
892                         CL_Input();
893
894                         // check for new packets
895                         NetConn_ClientFrame();
896
897                         // read a new frame from a demo if needed
898                         CL_ReadDemoMessage();
899
900                         // now that packets have been read, send input to server
901                         CL_SendMove();
902
903                         // update client world (interpolate entities, create trails, etc)
904                         CL_UpdateWorld();
905
906                         CL_Video_Frame();
907                         CL_Gecko_Frame();
908
909                         CL_UpdateScreen();
910
911                         if (host_speeds.integer)
912                                 time2 = Sys_DoubleTime();
913
914                         // update audio
915                         if(cl.csqc_usecsqclistener)
916                         {
917                                 S_Update(&cl.csqc_listenermatrix);
918                                 cl.csqc_usecsqclistener = false;
919                         }
920                         else
921                                 S_Update(&r_refdef.view.matrix);
922
923                         CDAudio_Update();
924
925                         // reset gathering of mouse input
926                         in_mouse_x = in_mouse_y = 0;
927
928                         if (host_speeds.integer)
929                         {
930                                 pass1 = (int)((time1 - time3)*1000000);
931                                 time3 = Sys_DoubleTime();
932                                 pass2 = (int)((time2 - time1)*1000000);
933                                 pass3 = (int)((time3 - time2)*1000000);
934                                 Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n",
935                                                         pass1+pass2+pass3, pass1, pass2, pass3);
936                         }
937                 }
938
939 #if MEMPARANOIA
940                 Mem_CheckSentinelsGlobal();
941 #else
942                 if (developer_memorydebug.integer)
943                         Mem_CheckSentinelsGlobal();
944 #endif
945
946                 // if there is some time remaining from this frame, reset the timers
947                 if (cl_timer >= 0)
948                         cl_timer = 0;
949                 if (sv_timer >= 0)
950                 {
951                         svs.perf_acc_lost += sv_timer;
952                         sv_timer = 0;
953                 }
954
955                 host_framecount++;
956         }
957 }
958
959 //============================================================================
960
961 qboolean vid_opened = false;
962 void Host_StartVideo(void)
963 {
964         if (!vid_opened && cls.state != ca_dedicated)
965         {
966                 vid_opened = true;
967                 // make sure we open sockets before opening video because the Windows Firewall "unblock?" dialog can screw up the graphics context on some graphics drivers
968                 NetConn_UpdateSockets();
969                 VID_Start();
970                 CDAudio_Startup();
971         }
972 }
973
974 char engineversion[128];
975
976 qboolean sys_nostdout = false;
977
978 extern void Render_Init(void);
979 extern void Mathlib_Init(void);
980 extern void FS_Init(void);
981 extern void FS_Shutdown(void);
982 extern void PR_Cmd_Init(void);
983 extern void COM_Init_Commands(void);
984 extern void FS_Init_Commands(void);
985 extern qboolean host_stuffcmdsrun;
986
987 /*
988 ====================
989 Host_Init
990 ====================
991 */
992 static void Host_Init (void)
993 {
994         int i;
995         const char* os;
996
997         if (COM_CheckParm("-profilegameonly"))
998                 Sys_AllowProfiling(false);
999
1000         // LordHavoc: quake never seeded the random number generator before... heh
1001         if (COM_CheckParm("-benchmark"))
1002                 srand(0); // predictable random sequence for -benchmark
1003         else
1004                 srand(time(NULL));
1005
1006         // FIXME: this is evil, but possibly temporary
1007         // LordHavoc: doesn't seem very temporary...
1008         // LordHavoc: enabled this by default on debug
1009 #ifndef DEBUG
1010 // COMMANDLINEOPTION: Console: -developer enables warnings and other notices (RECOMMENDED for mod developers)
1011         if (COM_CheckParm("-developer"))
1012 #endif
1013         {
1014                 developer.value = developer.integer = 1;
1015                 developer.string = "1";
1016         }
1017
1018         if (COM_CheckParm("-developer2"))
1019         {
1020                 developer.value = developer.integer = 100;
1021                 developer.string = "100";
1022                 developer_memory.value = developer_memory.integer = 100;
1023                 developer.string = "100";
1024                 developer_memorydebug.value = developer_memorydebug.integer = 100;
1025                 developer_memorydebug.string = "100";
1026         }
1027
1028 // COMMANDLINEOPTION: Console: -nostdout disables text output to the terminal the game was launched from
1029         if (COM_CheckParm("-nostdout"))
1030                 sys_nostdout = 1;
1031
1032         // used by everything
1033         Memory_Init();
1034
1035         // initialize console command/cvar/alias/command execution systems
1036         Cmd_Init();
1037
1038         // initialize memory subsystem cvars/commands
1039         Memory_Init_Commands();
1040
1041         // initialize console and logging and its cvars/commands
1042         Con_Init();
1043
1044         // initialize various cvars that could not be initialized earlier
1045         Curl_Init_Commands();
1046         Cmd_Init_Commands();
1047         Sys_Init_Commands();
1048         COM_Init_Commands();
1049         FS_Init_Commands();
1050
1051         // initialize console window (only used by sys_win.c)
1052         Sys_InitConsole();
1053
1054         // detect gamemode from commandline options or executable name
1055         COM_InitGameType();
1056
1057         // construct a version string for the corner of the console
1058         os = DP_OS_NAME;
1059         dpsnprintf (engineversion, sizeof (engineversion), "%s %s %s", gamename, os, buildstring);
1060         Con_Printf("%s\n", engineversion);
1061
1062         // initialize ixtable
1063         Mathlib_Init();
1064
1065         // initialize filesystem (including fs_basedir, fs_gamedir, -game, scr_screenshot_name)
1066         FS_Init();
1067
1068         NetConn_Init();
1069         Curl_Init();
1070         //PR_Init();
1071         //PR_Cmd_Init();
1072         PRVM_Init();
1073         Mod_Init();
1074         World_Init();
1075         SV_Init();
1076         Host_InitCommands();
1077         Host_InitLocal();
1078         Host_ServerOptions();
1079
1080         if (cls.state == ca_dedicated)
1081                 Cmd_AddCommand ("disconnect", CL_Disconnect_f, "disconnect from server (or disconnect all clients if running a server)");
1082         else
1083         {
1084                 Con_DPrintf("Initializing client\n");
1085
1086                 R_Modules_Init();
1087                 Palette_Init();
1088                 MR_Init_Commands();
1089                 VID_Shared_Init();
1090                 VID_Init();
1091                 Render_Init();
1092                 S_Init();
1093                 CDAudio_Init();
1094                 Key_Init();
1095                 V_Init();
1096                 CL_Init();
1097         }
1098
1099         // set up the default startmap_sp and startmap_dm aliases (mods can
1100         // override these) and then execute the quake.rc startup script
1101         if (gamemode == GAME_NEHAHRA)
1102                 Cbuf_AddText("alias startmap_sp \"map nehstart\"\nalias startmap_dm \"map nehstart\"\nexec quake.rc\n");
1103         else if (gamemode == GAME_TRANSFUSION)
1104                 Cbuf_AddText("alias startmap_sp \"map e1m1\"\n""alias startmap_dm \"map bb1\"\nexec quake.rc\n");
1105         else if (gamemode == GAME_TEU)
1106                 Cbuf_AddText("alias startmap_sp \"map start\"\nalias startmap_dm \"map start\"\nexec teu.rc\n");
1107         else
1108                 Cbuf_AddText("alias startmap_sp \"map start\"\nalias startmap_dm \"map start\"\nexec quake.rc\n");
1109         Cbuf_Execute();
1110
1111         // if stuffcmds wasn't run, then quake.rc is probably missing, use default
1112         if (!host_stuffcmdsrun)
1113         {
1114                 Cbuf_AddText("exec default.cfg\nexec config.cfg\nexec autoexec.cfg\nstuffcmds\n");
1115                 Cbuf_Execute();
1116         }
1117
1118         // put up the loading image so the user doesn't stare at a black screen...
1119         SCR_BeginLoadingPlaque();
1120
1121         // FIXME: put this into some neat design, but the menu should be allowed to crash
1122         // without crashing the whole game, so this should just be a short-time solution
1123
1124         // here comes the not so critical stuff
1125         if (setjmp(host_abortframe)) {
1126                 return;
1127         }
1128
1129         if (cls.state != ca_dedicated)
1130         {
1131                 MR_Init();
1132         }
1133
1134         // check for special benchmark mode
1135 // COMMANDLINEOPTION: Client: -benchmark <demoname> runs a timedemo and quits, results of any timedemo can be found in gamedir/benchmark.log (for example id1/benchmark.log)
1136         i = COM_CheckParm("-benchmark");
1137         if (i && i + 1 < com_argc)
1138         if (!sv.active && !cls.demoplayback && !cls.connect_trying)
1139         {
1140                 Cbuf_AddText(va("timedemo %s\n", com_argv[i + 1]));
1141                 Cbuf_Execute();
1142         }
1143
1144         // check for special demo mode
1145 // COMMANDLINEOPTION: Client: -demo <demoname> runs a playdemo and quits
1146         i = COM_CheckParm("-demo");
1147         if (i && i + 1 < com_argc)
1148         if (!sv.active && !cls.demoplayback && !cls.connect_trying)
1149         {
1150                 Cbuf_AddText(va("playdemo %s\n", com_argv[i + 1]));
1151                 Cbuf_Execute();
1152         }
1153
1154 // COMMANDLINEOPTION: Client: -capturedemo <demoname> captures a playdemo and quits
1155         i = COM_CheckParm("-capturedemo");
1156         if (i && i + 1 < com_argc)
1157         if (!sv.active && !cls.demoplayback && !cls.connect_trying)
1158         {
1159                 Cbuf_AddText(va("playdemo %s\ncl_capturevideo 1\n", com_argv[i + 1]));
1160                 Cbuf_Execute();
1161         }
1162
1163         if (cls.state == ca_dedicated || COM_CheckParm("-listen"))
1164         if (!sv.active && !cls.demoplayback && !cls.connect_trying)
1165         {
1166                 Cbuf_AddText("startmap_dm\n");
1167                 Cbuf_Execute();
1168         }
1169
1170         if (!sv.active && !cls.demoplayback && !cls.connect_trying)
1171         {
1172                 Cbuf_AddText("togglemenu\n");
1173                 Cbuf_Execute();
1174         }
1175
1176         Con_DPrint("========Initialized=========\n");
1177
1178         //Host_StartVideo();
1179 }
1180
1181
1182 /*
1183 ===============
1184 Host_Shutdown
1185
1186 FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
1187 to run quit through here before the final handoff to the sys code.
1188 ===============
1189 */
1190 void Host_Shutdown(void)
1191 {
1192         static qboolean isdown = false;
1193
1194         if (isdown)
1195         {
1196                 Con_Print("recursive shutdown\n");
1197                 return;
1198         }
1199         if (setjmp(host_abortframe))
1200         {
1201                 Con_Print("aborted the quitting frame?!?\n");
1202                 return;
1203         }
1204         isdown = true;
1205
1206         // be quiet while shutting down
1207         S_StopAllSounds();
1208
1209         // disconnect client from server if active
1210         CL_Disconnect();
1211
1212         // shut down local server if active
1213         Host_ShutdownServer ();
1214
1215         // Shutdown menu
1216         if(MR_Shutdown)
1217                 MR_Shutdown();
1218
1219         // AK shutdown PRVM
1220         // AK hmm, no PRVM_Shutdown(); yet
1221
1222         CL_Gecko_Shutdown();
1223         CL_Video_Shutdown();
1224
1225         Host_SaveConfig();
1226
1227         CDAudio_Shutdown ();
1228         S_Terminate ();
1229         Curl_Shutdown ();
1230         NetConn_Shutdown ();
1231         //PR_Shutdown ();
1232
1233         if (cls.state != ca_dedicated)
1234         {
1235                 R_Modules_Shutdown();
1236                 VID_Shutdown();
1237         }
1238
1239         Cmd_Shutdown();
1240         Key_Shutdown();
1241         CL_Shutdown();
1242         Sys_Shutdown();
1243         Log_Close();
1244         FS_Shutdown();
1245         Con_Shutdown();
1246         Memory_Shutdown();
1247 }
1248