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