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