fixed very annoying '5 second timeout' bug in Host_ShutdownServer (the local client...
[xonotic/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 <time.h>
23 #include "quakedef.h"
24 #include "cl_video.h"
25
26 /*
27
28 A server can always be started, even if the system started out as a client
29 to a remote system.
30
31 A client can NOT be started if the system started as a dedicated server.
32
33 Memory is cleared / released when a server or client begins, not when they end.
34
35 */
36
37 // true if into command execution
38 qboolean host_initialized;
39 // LordHavoc: used to turn Host_Error into Sys_Error if starting up or shutting down
40 qboolean host_loopactive = false;
41 // LordHavoc: set when quit is executed
42 qboolean host_shuttingdown = false;
43
44 double host_frametime;
45 // LordHavoc: the real frametime, before slowmo and clamping are applied (used for console scrolling)
46 double host_realframetime;
47 // the real time, without any slowmo or clamping
48 double realtime;
49 // realtime from previous frame
50 double oldrealtime;
51 // how many frames have occurred
52 int host_framecount;
53
54 // used for -developer commandline parameter, hacky hacky
55 int forcedeveloper;
56
57 // current client
58 client_t *host_client;
59
60 jmp_buf host_abortserver;
61
62 // pretend frames take this amount of time (in seconds), 0 = realtime
63 cvar_t host_framerate = {0, "host_framerate","0"};
64 // shows time used by certain subsystems
65 cvar_t host_speeds = {0, "host_speeds","0"};
66 // LordHavoc: framerate independent slowmo
67 cvar_t slowmo = {0, "slowmo", "1.0"};
68 // LordHavoc: game logic lower cap on framerate (if framerate is below this is, it pretends it is this, so game logic will run normally)
69 cvar_t host_minfps = {CVAR_SAVE, "host_minfps", "10"};
70 // LordHavoc: framerate upper cap
71 cvar_t host_maxfps = {CVAR_SAVE, "host_maxfps", "1000"};
72
73 // print broadcast messages in dedicated mode
74 cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1"};
75
76 cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.05"};
77 cvar_t serverprofile = {0, "serverprofile","0"};
78
79 cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0"};
80 cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0"};
81 cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0"};
82
83 cvar_t samelevel = {0, "samelevel","0"};
84 cvar_t noexit = {CVAR_NOTIFY, "noexit","0"};
85
86 cvar_t developer = {0, "developer","0"};
87
88 cvar_t skill = {0, "skill","1"};
89 cvar_t deathmatch = {0, "deathmatch","0"};
90 cvar_t coop = {0, "coop","0"};
91
92 cvar_t pausable = {0, "pausable","1"};
93
94 cvar_t temp1 = {0, "temp1","0"};
95
96 cvar_t timestamps = {CVAR_SAVE, "timestamps", "0"};
97 cvar_t timeformat = {CVAR_SAVE, "timeformat", "[%b %e %X] "};
98
99 /*
100 ================
101 Host_EndGame
102 ================
103 */
104 void Host_EndGame (const char *format, ...)
105 {
106         va_list argptr;
107         char string[1024];
108
109         va_start (argptr,format);
110         vsprintf (string,format,argptr);
111         va_end (argptr);
112         Con_DPrintf("Host_EndGame: %s\n",string);
113
114         Host_ShutdownServer (false);
115
116         if (cls.state == ca_dedicated)
117                 Sys_Error ("Host_EndGame: %s\n",string);        // dedicated servers exit
118
119         if (cls.demonum != -1)
120                 CL_NextDemo ();
121         else
122                 CL_Disconnect ();
123
124         longjmp (host_abortserver, 1);
125 }
126
127 /*
128 ================
129 Host_Error
130
131 This shuts down both the client and server
132 ================
133 */
134 void PRVM_ProcessError(void);
135 static char hosterrorstring1[4096];
136 static char hosterrorstring2[4096];
137 static qboolean hosterror = false;
138 void Host_Error (const char *error, ...)
139 {
140         va_list argptr;
141
142         va_start (argptr,error);
143         vsprintf (hosterrorstring1,error,argptr);
144         va_end (argptr);
145
146         Con_Printf("Host_Error: %s\n", hosterrorstring1);
147
148         // LordHavoc: if first frame has not been shown, or currently shutting
149         // down, do Sys_Error instead
150         if (!host_loopactive || host_shuttingdown)
151                 Sys_Error ("Host_Error: %s", hosterrorstring1);
152
153         if (hosterror)
154                 Sys_Error ("Host_Error: recursively entered (original error was: %s    new error is: %s)", hosterrorstring2, hosterrorstring1);
155         hosterror = true;
156
157         strcpy(hosterrorstring2, hosterrorstring1);
158
159         CL_Parse_DumpPacket();
160
161         PR_Crash();
162
163         //PRVM_Crash(); // crash current prog
164
165         // crash all prvm progs
166         PRVM_CrashAll();
167
168         PRVM_ProcessError();
169
170         Host_ShutdownServer (false);
171
172         if (cls.state == ca_dedicated)
173                 Sys_Error ("Host_Error: %s\n",hosterrorstring2);        // dedicated servers exit
174
175         CL_Disconnect ();
176         cls.demonum = -1;
177
178         hosterror = false;
179
180         longjmp (host_abortserver, 1);
181 }
182
183 mempool_t *sv_clients_mempool = NULL;
184
185 void Host_ServerOptions (void)
186 {
187         int i, numplayers;
188
189         // general default
190         numplayers = 8;
191
192         if (cl_available)
193         {
194                 // client exists, check what mode the user wants
195                 i = COM_CheckParm ("-dedicated");
196                 if (i)
197                 {
198                         cls.state = ca_dedicated;
199                         // default players unless specified
200                         if (i != (com_argc - 1))
201                                 numplayers = atoi (com_argv[i+1]);
202                         if (COM_CheckParm ("-listen"))
203                                 Sys_Error ("Only one of -dedicated or -listen can be specified");
204                 }
205                 else
206                 {
207                         cls.state = ca_disconnected;
208                         i = COM_CheckParm ("-listen");
209                         if (i)
210                         {
211                                 // default players unless specified
212                                 if (i != (com_argc - 1))
213                                         numplayers = atoi (com_argv[i+1]);
214                         }
215                         else
216                         {
217                                 // default players in some games, singleplayer in most
218                                 if (gamemode != GAME_TRANSFUSION && gamemode != GAME_GOODVSBAD2 && gamemode != GAME_NEXUIZ && gamemode != GAME_BATTLEMECH)
219                                         numplayers = 1;
220                         }
221                 }
222         }
223         else
224         {
225                 // no client in the executable, always start dedicated server
226                 if (COM_CheckParm ("-listen"))
227                         Sys_Error ("-listen not available in a dedicated server executable");
228                 cls.state = ca_dedicated;
229                 // check for -dedicated specifying how many players
230                 i = COM_CheckParm ("-dedicated");
231                 // default players unless specified
232                 if (i && i != (com_argc - 1))
233                         numplayers = atoi (com_argv[i+1]);
234         }
235
236         if (numplayers < 1)
237                 numplayers = 8;
238
239         numplayers = bound(1, numplayers, MAX_SCOREBOARD);
240
241         if (numplayers > 1 && !deathmatch.integer)
242                 Cvar_SetValueQuick(&deathmatch, 1);
243
244         svs.maxclients = numplayers;
245         sv_clients_mempool = Mem_AllocPool("server clients");
246         svs.clients = Mem_Alloc(sv_clients_mempool, sizeof(client_t) * svs.maxclients);
247 }
248
249 /*
250 =======================
251 Host_InitLocal
252 ======================
253 */
254 void Host_SaveConfig_f(void);
255 void Host_InitLocal (void)
256 {
257         Host_InitCommands ();
258         
259         Cmd_AddCommand("saveconfig", Host_SaveConfig_f);
260
261         Cvar_RegisterVariable (&host_framerate);
262         Cvar_RegisterVariable (&host_speeds);
263         Cvar_RegisterVariable (&slowmo);
264         Cvar_RegisterVariable (&host_minfps);
265         Cvar_RegisterVariable (&host_maxfps);
266
267         Cvar_RegisterVariable (&sv_echobprint);
268
269         Cvar_RegisterVariable (&sys_ticrate);
270         Cvar_RegisterVariable (&serverprofile);
271
272         Cvar_RegisterVariable (&fraglimit);
273         Cvar_RegisterVariable (&timelimit);
274         Cvar_RegisterVariable (&teamplay);
275         Cvar_RegisterVariable (&samelevel);
276         Cvar_RegisterVariable (&noexit);
277         Cvar_RegisterVariable (&skill);
278         Cvar_RegisterVariable (&developer);
279         if (forcedeveloper) // make it real now that the cvar is registered
280                 Cvar_SetValue("developer", 1);
281         Cvar_RegisterVariable (&deathmatch);
282         Cvar_RegisterVariable (&coop);
283
284         Cvar_RegisterVariable (&pausable);
285
286         Cvar_RegisterVariable (&temp1);
287
288         Cvar_RegisterVariable (&timestamps);
289         Cvar_RegisterVariable (&timeformat);
290
291         Host_ServerOptions ();
292 }
293
294
295 /*
296 ===============
297 Host_SaveConfig_f
298
299 Writes key bindings and archived cvars to config.cfg
300 ===============
301 */
302 void Host_SaveConfig_f(void)
303 {
304         qfile_t *f;
305
306 // dedicated servers initialize the host but don't parse and set the
307 // config.cfg cvars
308         if (host_initialized && cls.state != ca_dedicated)
309         {
310                 f = FS_Open ("config.cfg", "w", false);
311                 if (!f)
312                 {
313                         Con_Print("Couldn't write config.cfg.\n");
314                         return;
315                 }
316
317                 Key_WriteBindings (f);
318                 Cvar_WriteVariables (f);
319
320                 FS_Close (f);
321         }
322 }
323
324
325 /*
326 =================
327 SV_ClientPrint
328
329 Sends text across to be displayed
330 FIXME: make this just a stuffed echo?
331 =================
332 */
333 void SV_ClientPrint(const char *msg)
334 {
335         MSG_WriteByte(&host_client->message, svc_print);
336         MSG_WriteString(&host_client->message, msg);
337 }
338
339 /*
340 =================
341 SV_ClientPrintf
342
343 Sends text across to be displayed
344 FIXME: make this just a stuffed echo?
345 =================
346 */
347 void SV_ClientPrintf(const char *fmt, ...)
348 {
349         va_list argptr;
350         char msg[4096];
351
352         va_start(argptr,fmt);
353         vsnprintf(msg,sizeof(msg),fmt,argptr);
354         va_end(argptr);
355
356         SV_ClientPrint(msg);
357 }
358
359 /*
360 =================
361 SV_BroadcastPrint
362
363 Sends text to all active clients
364 =================
365 */
366 void SV_BroadcastPrint(const char *msg)
367 {
368         int i;
369         client_t *client;
370
371         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
372         {
373                 if (client->spawned)
374                 {
375                         MSG_WriteByte(&client->message, svc_print);
376                         MSG_WriteString(&client->message, msg);
377                 }
378         }
379
380         if (sv_echobprint.integer && cls.state == ca_dedicated)
381                 Sys_Print(msg);
382 }
383
384 /*
385 =================
386 SV_BroadcastPrintf
387
388 Sends text to all active clients
389 =================
390 */
391 void SV_BroadcastPrintf(const char *fmt, ...)
392 {
393         va_list argptr;
394         char msg[4096];
395
396         va_start(argptr,fmt);
397         vsnprintf(msg,sizeof(msg),fmt,argptr);
398         va_end(argptr);
399
400         SV_BroadcastPrint(msg);
401 }
402
403 /*
404 =================
405 Host_ClientCommands
406
407 Send text over to the client to be executed
408 =================
409 */
410 void Host_ClientCommands(const char *fmt, ...)
411 {
412         va_list argptr;
413         char string[1024];
414
415         va_start(argptr,fmt);
416         vsprintf(string, fmt,argptr);
417         va_end(argptr);
418
419         MSG_WriteByte(&host_client->message, svc_stufftext);
420         MSG_WriteString(&host_client->message, string);
421 }
422
423 /*
424 =====================
425 SV_DropClient
426
427 Called when the player is getting totally kicked off the host
428 if (crash = true), don't bother sending signofs
429 =====================
430 */
431 void SV_DropClient(qboolean crash)
432 {
433         int saveSelf;
434         int i;
435         client_t *client;
436
437         Con_Printf("Client \"%s\" dropped\n", host_client->name);
438
439         // send any final messages (don't check for errors)
440         if (host_client->netconnection)
441         {
442                 // free the client (the body stays around)
443                 if (!crash)
444                 {
445                         // LordHavoc: no opportunity for resending, so use unreliable
446                         MSG_WriteByte(&host_client->message, svc_disconnect);
447                         NetConn_SendUnreliableMessage(host_client->netconnection, &host_client->message);
448                 }
449
450                 // break the net connection
451                 NetConn_Close(host_client->netconnection);
452                 host_client->netconnection = NULL;
453
454                 // LordHavoc: don't call QC if server is dead (avoids recursive
455                 // Host_Error in some mods when they run out of edicts)
456                 if (sv.active && host_client->edict && host_client->spawned)
457                 {
458                         // call the prog function for removing a client
459                         // this will set the body to a dead frame, among other things
460                         saveSelf = pr_global_struct->self;
461                         pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
462                         PR_ExecuteProgram(pr_global_struct->ClientDisconnect, "QC function ClientDisconnect is missing");
463                         pr_global_struct->self = saveSelf;
464                 }
465         }
466
467         // send notification to all clients
468         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
469         {
470                 if (!client->active)
471                         continue;
472                 MSG_WriteByte(&client->message, svc_updatename);
473                 MSG_WriteByte(&client->message, host_client->number);
474                 MSG_WriteString(&client->message, "");
475                 MSG_WriteByte(&client->message, svc_updatefrags);
476                 MSG_WriteByte(&client->message, host_client->number);
477                 MSG_WriteShort(&client->message, 0);
478                 MSG_WriteByte(&client->message, svc_updatecolors);
479                 MSG_WriteByte(&client->message, host_client->number);
480                 MSG_WriteByte(&client->message, 0);
481         }
482
483         NetConn_Heartbeat(1);
484
485         // free the client now
486         if (host_client->entitydatabase4)
487                 EntityFrame4_FreeDatabase(host_client->entitydatabase4);
488         // clear the client struct (this sets active to false)
489         memset(host_client, 0, sizeof(*host_client));
490 }
491
492 /*
493 ==================
494 Host_ShutdownServer
495
496 This only happens at the end of a game, not between levels
497 ==================
498 */
499 void Host_ShutdownServer(qboolean crash)
500 {
501         int i, count;
502         sizebuf_t buf;
503         char message[4];
504
505         if (!sv.active)
506                 return;
507
508         Con_DPrintf("Host_ShutdownServer\n");
509
510         // print out where the crash happened, if it was caused by QC
511         PR_Crash();
512
513         NetConn_Heartbeat(2);
514         NetConn_Heartbeat(2);
515
516 // make sure all the clients know we're disconnecting
517         buf.data = message;
518         buf.maxsize = 4;
519         buf.cursize = 0;
520         MSG_WriteByte(&buf, svc_disconnect);
521         count = NetConn_SendToAll(&buf, 5);
522         if (count)
523                 Con_Printf("Host_ShutdownServer: NetConn_SendToAll failed for %u clients\n", count);
524
525         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
526                 if (host_client->active)
527                         SV_DropClient(crash); // server shutdown
528
529         NetConn_CloseServerPorts();
530
531         sv.active = false;
532
533 //
534 // clear structures
535 //
536         memset(&sv, 0, sizeof(sv));
537         memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
538 }
539
540
541 /*
542 ================
543 Host_ClearMemory
544
545 This clears all the memory used by both the client and server, but does
546 not reinitialize anything.
547 ================
548 */
549 void Host_ClearMemory (void)
550 {
551         Con_DPrint("Clearing memory\n");
552         Mod_ClearAll ();
553
554         cls.signon = 0;
555         memset (&sv, 0, sizeof(sv));
556         memset (&cl, 0, sizeof(cl));
557 }
558
559
560 //============================================================================
561
562 /*
563 ===================
564 Host_FilterTime
565
566 Returns false if the time is too short to run a frame
567 ===================
568 */
569 extern cvar_t cl_avidemo;
570 qboolean Host_FilterTime (double time)
571 {
572         double timecap, timeleft;
573         realtime += time;
574
575         if (slowmo.value < 0.0f)
576                 Cvar_SetValue("slowmo", 0.0f);
577         if (host_minfps.value < 10.0f)
578                 Cvar_SetValue("host_minfps", 10.0f);
579         if (host_maxfps.value < host_minfps.value)
580                 Cvar_SetValue("host_maxfps", host_minfps.value);
581         if (cl_avidemo.value < 0.1f && cl_avidemo.value != 0.0f)
582                 Cvar_SetValue("cl_avidemo", 0.0f);
583
584         // check if framerate is too high
585         if (!cls.timedemo)
586         {
587                 // default to sys_ticrate (server framerate - presumably low) unless we
588                 // have a good reason to run faster
589                 timecap = sys_ticrate.value;
590                 if (cls.state != ca_dedicated)
591                 {
592                         if (cl_avidemo.value >= 0.1f)
593                                 timecap = 1.0 / (double)cl_avidemo.value;
594                         else if (vid_activewindow)
595                                 timecap = 1.0 / host_maxfps.value;
596                 }
597
598                 timeleft = oldrealtime + timecap - realtime;
599                 if (timeleft > 0)
600                 {
601                         // don't totally hog the CPU
602                         if (timeleft >= 0.02)
603                                 Sys_Sleep((int)(timeleft * 1000) - 5);
604                         return false;
605                 }
606         }
607
608         // LordHavoc: copy into host_realframetime as well
609         host_realframetime = host_frametime = realtime - oldrealtime;
610         oldrealtime = realtime;
611
612         if (cls.timedemo)
613         {
614                 // disable time effects
615                 cl.frametime = host_frametime;
616                 return true;
617         }
618
619         if (host_framerate.value > 0)
620                 host_frametime = host_framerate.value;
621         else if (cl_avidemo.value >= 0.1f)
622                 host_frametime = (1.0 / cl_avidemo.value);
623         else
624         {
625                 // don't allow really short frames
626                 if (host_frametime > (1.0 / host_minfps.value))
627                         host_frametime = (1.0 / host_minfps.value);
628         }
629
630         cl.frametime = host_frametime = bound(0, host_frametime * slowmo.value, 0.1f); // LordHavoc: the QC code relies on no less than 10fps
631
632         return true;
633 }
634
635
636 /*
637 ===================
638 Host_GetConsoleCommands
639
640 Add them exactly as if they had been typed at the console
641 ===================
642 */
643 void Host_GetConsoleCommands (void)
644 {
645         char *cmd;
646
647         while (1)
648         {
649                 cmd = Sys_ConsoleInput ();
650                 if (!cmd)
651                         break;
652                 Cbuf_AddText (cmd);
653         }
654 }
655
656
657 /*
658 ==================
659 Host_ServerFrame
660
661 ==================
662 */
663 void Host_ServerFrame (void)
664 {
665         static double frametimetotal = 0, lastservertime = 0;
666         frametimetotal += host_frametime;
667         // LordHavoc: cap server at sys_ticrate in networked games
668         if (!cl.islocalgame && ((realtime - lastservertime) < sys_ticrate.value))
669                 return;
670
671         NetConn_ServerFrame();
672
673 // run the world state
674         if (!sv.paused && (!cl.islocalgame || (key_dest == key_game && !key_consoleactive)))
675                 sv.frametime = pr_global_struct->frametime = frametimetotal;
676         else
677                 sv.frametime = 0;
678         frametimetotal = 0;
679         lastservertime = realtime;
680
681 // set the time and clear the general datagram
682         SV_ClearDatagram();
683
684 // read client messages
685         SV_RunClients();
686
687 // move things around and think
688 // always pause in single player if in console or menus
689         if (sv.frametime)
690                 SV_Physics();
691
692 // send all messages to the clients
693         SV_SendClientMessages();
694
695 // send an heartbeat if enough time has passed since the last one
696         NetConn_Heartbeat(0);
697 }
698
699
700 /*
701 ==================
702 Host_Frame
703
704 Runs all active servers
705 ==================
706 */
707 void _Host_Frame (float time)
708 {
709         static double time1 = 0;
710         static double time2 = 0;
711         static double time3 = 0;
712         int pass1, pass2, pass3;
713         usercmd_t cmd; // Used for receiving input
714
715         if (setjmp(host_abortserver))
716                 return;                 // something bad happened, or the server disconnected
717
718         // keep the random time dependent
719         rand();
720
721         // decide the simulation time
722         if (!Host_FilterTime(time))
723                 return;
724
725         cl.islocalgame = NetConn_IsLocalGame();
726
727         // get new key events
728         Sys_SendKeyEvents();
729
730         // allow mice or other external controllers to add commands
731         IN_Commands();
732
733         // Collect input into cmd
734         IN_ProcessMove(&cmd);
735
736         // process console commands
737         Cbuf_Execute();
738
739         // if running the server locally, make intentions now
740         if (cls.state == ca_connected && sv.active)
741                 CL_SendCmd(&cmd);
742
743 //-------------------
744 //
745 // server operations
746 //
747 //-------------------
748
749         // check for commands typed to the host
750         Host_GetConsoleCommands();
751
752         if (sv.active)
753                 Host_ServerFrame();
754
755 //-------------------
756 //
757 // client operations
758 //
759 //-------------------
760
761         cl.oldtime = cl.time;
762         cl.time += cl.frametime;
763
764         NetConn_ClientFrame();
765
766         if (cls.state == ca_connected)
767         {
768                 // if running the server remotely, send intentions now after
769                 // the incoming messages have been read
770                 if (!sv.active)
771                         CL_SendCmd(&cmd);
772                 CL_ReadFromServer();
773         }
774
775         //ui_update();
776
777         CL_VideoFrame();
778
779         // update video
780         if (host_speeds.integer)
781                 time1 = Sys_DoubleTime();
782
783         R_UpdateWorld();
784         CL_UpdateScreen();
785
786         if (host_speeds.integer)
787                 time2 = Sys_DoubleTime();
788
789         // update audio
790         if (cls.signon == SIGNONS && cl.viewentity >= 0 && cl.viewentity < MAX_EDICTS && cl_entities[cl.viewentity].state_current.active)
791         {
792                 // LordHavoc: this used to use renderer variables (eww)
793                 vec3_t forward, left, up, origin;
794                 Matrix4x4_ToVectors(&cl_entities[cl.viewentity].render.matrix, forward, left, up, origin);
795                 S_Update(origin, forward, left, up);
796         }
797         else
798                 S_Update(vec3_origin, vec3_origin, vec3_origin, vec3_origin);
799
800         CDAudio_Update();
801
802         if (host_speeds.integer)
803         {
804                 pass1 = (time1 - time3)*1000000;
805                 time3 = Sys_DoubleTime();
806                 pass2 = (time2 - time1)*1000000;
807                 pass3 = (time3 - time2)*1000000;
808                 Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n",
809                                         pass1+pass2+pass3, pass1, pass2, pass3);
810         }
811
812         host_framecount++;
813         host_loopactive = true;
814
815 }
816
817 void Host_Frame (float time)
818 {
819         double time1, time2;
820         static double timetotal;
821         static int timecount;
822         int i, c, m;
823
824         if (!serverprofile.integer)
825         {
826                 _Host_Frame (time);
827                 return;
828         }
829
830         time1 = Sys_DoubleTime ();
831         _Host_Frame (time);
832         time2 = Sys_DoubleTime ();
833
834         timetotal += time2 - time1;
835         timecount++;
836
837         if (timecount < 1000)
838                 return;
839
840         m = timetotal*1000/timecount;
841         timecount = 0;
842         timetotal = 0;
843         c = 0;
844         for (i=0 ; i<svs.maxclients ; i++)
845         {
846                 if (svs.clients[i].active)
847                         c++;
848         }
849
850         Con_Printf("serverprofile: %2i clients %2i msec\n",  c,  m);
851 }
852
853 //============================================================================
854
855 void Render_Init(void);
856
857 /*
858 ====================
859 Host_Init
860 ====================
861 */
862 void Host_Init (void)
863 {
864         int i;
865
866         // LordHavoc: quake never seeded the random number generator before... heh
867         srand(time(NULL));
868
869         // FIXME: this is evil, but possibly temporary
870         if (COM_CheckParm("-developer"))
871         {
872                 forcedeveloper = true;
873                 developer.integer = 1;
874                 developer.value = 1;
875         }
876
877         Cmd_Init();
878         Memory_Init_Commands();
879         R_Modules_Init();
880         Cbuf_Init();
881         V_Init();
882         COM_Init();
883         Host_InitLocal();
884         Key_Init();
885         Con_Init();
886         PR_Init();
887         PRVM_Init();
888         Mod_Init();
889         NetConn_Init();
890         SV_Init();
891
892         Con_Printf("Builddate: %s\n", buildstring);
893
894         if (cls.state != ca_dedicated)
895         {
896                 Palette_Init();
897                 VID_Shared_Init();
898                 VID_Init();
899
900                 Render_Init();
901                 S_Init();
902                 CDAudio_Init();
903                 CL_Init();
904         }
905
906         // only cvars are executed when host_initialized == false
907         if (gamemode == GAME_TEU)
908                 Cbuf_InsertText("exec teu.rc\n");
909         else
910                 Cbuf_InsertText("exec quake.rc\n");
911         Cbuf_Execute();
912
913         host_initialized = true;
914
915         Con_DPrint("========Initialized=========\n");
916
917         if (cls.state != ca_dedicated)
918         {
919                 VID_Open();
920                 SCR_BeginLoadingPlaque();
921                 MR_Init();
922         }
923
924         // stuff it again so the first host frame will execute it again, this time
925         // in its entirety
926         if (gamemode == GAME_TEU)
927                 Cbuf_InsertText("exec teu.rc\n");
928         else
929                 Cbuf_InsertText("exec quake.rc\n");
930
931         // check for special benchmark mode
932         i = COM_CheckParm("-benchmark");
933         if (i && i + 1 < com_argc)
934                 Cbuf_InsertText(va("timedemo %s\n", com_argv[i + 1]));
935
936         Cbuf_Execute();
937 }
938
939
940 /*
941 ===============
942 Host_Shutdown
943
944 FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
945 to run quit through here before the final handoff to the sys code.
946 ===============
947 */
948 void Host_Shutdown(void)
949 {
950         static qboolean isdown = false;
951
952         if (isdown)
953         {
954                 Con_Print("recursive shutdown\n");
955                 return;
956         }
957         isdown = true;
958
959         // Shutdown menu
960         if(MR_Shutdown)
961                 MR_Shutdown();
962
963         // AK shutdown PRVM
964         // AK hmm, no PRVM_Shutdown(); yet
965
966
967         Host_SaveConfig_f();
968
969         CDAudio_Shutdown ();
970         NetConn_Shutdown ();
971
972         if (cls.state != ca_dedicated)
973         {
974                 R_Modules_Shutdown();
975                 VID_Shutdown();
976         }
977 }
978