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 /*
  25
  26 A server can always be started, even if the system started out as a client
  27 to a remote system.
  28
  29 A client can NOT be started if the system started as a dedicated server.
  30
  31 Memory is cleared / released when a server or client begins, not when they end.
  32
  33 */
  34
  35 quakeparms_t host_parms;
  36
  37 qboolean        host_initialized;               // true if into command execution
  38 qboolean        hostloopactive = 0;             // LordHavoc: used to turn Host_Error into Sys_Error if Host_Frame has not yet run
  39
  40 double          host_frametime;
  41 double          host_realframetime;             // LordHavoc: the real frametime, before slowmo and clamping are applied (used for console scrolling)
  42 double          realtime;                               // without any filtering or bounding
  43 double          oldrealtime;                    // last frame run
  44 int                     host_framecount;
  45
  46 double          sv_frametime;
  47
  48 int                     host_hunklevel;
  49
  50 int                     minimum_memory;
  51
  52 client_t        *host_client;                   // current client
  53
  54 jmp_buf         host_abortserver;
  55
  56 cvar_t  host_framerate = {"host_framerate","0"};        // set for slow motion
  57 cvar_t  host_speeds = {"host_speeds","0"};                      // set for running times
  58 cvar_t  slowmo = {"slowmo", "1.0"};                                     // LordHavoc: framerate independent slowmo
  59 cvar_t  host_minfps = {"host_minfps", "10"};            // LordHavoc: game logic lower cap on framerate (if framerate is below this is, it pretends it is this, so game logic will run normally)
  60 cvar_t  host_maxfps = {"host_maxfps", "1000"};          // LordHavoc: framerate upper cap
  61
  62 cvar_t  sys_ticrate = {"sys_ticrate","0.05"};
  63 cvar_t  serverprofile = {"serverprofile","0"};
  64
  65 cvar_t  fraglimit = {"fraglimit","0",false,true};
  66 cvar_t  timelimit = {"timelimit","0",false,true};
  67 cvar_t  teamplay = {"teamplay","0",false,true};
  68
  69 cvar_t  samelevel = {"samelevel","0"};
  70 cvar_t  noexit = {"noexit","0",false,true};
  71
  72 cvar_t  developer = {"developer","0"};
  73
  74 cvar_t  skill = {"skill","1"};                                          // 0 - 3
  75 cvar_t  deathmatch = {"deathmatch","0"};                        // 0, 1, or 2
  76 cvar_t  coop = {"coop","0"};                    // 0 or 1
  77
  78 cvar_t  pausable = {"pausable","1"};
  79
  80 cvar_t  temp1 = {"temp1","0"};
  81
  82 cvar_t  timestamps = {"timestamps", "0", true};
  83 cvar_t  timeformat = {"timeformat", "[%b %e %X] ", true};
  84
  85 /*
  86 ================
  87 Host_EndGame
  88 ================
  89 */
  90 void Host_EndGame (char *message, ...)
  91 {
  92         va_list         argptr;
  93         char            string[1024];
  94
  95         va_start (argptr,message);
  96         vsprintf (string,message,argptr);
  97         va_end (argptr);
  98         Con_DPrintf ("Host_EndGame: %s\n",string);
  99
 100         if (sv.active)
 101                 Host_ShutdownServer (false);
 102
 103         if (cls.state == ca_dedicated)
 104                 Sys_Error ("Host_EndGame: %s\n",string);        // dedicated servers exit
 105
 106         if (cls.demonum != -1)
 107                 CL_NextDemo ();
 108         else
 109                 CL_Disconnect ();
 110
 111         longjmp (host_abortserver, 1);
 112 }
 113
 114 /*
 115 ================
 116 Host_Error
 117
 118 This shuts down both the client and server
 119 ================
 120 */
 121 char hosterrorstring[4096];
 122 extern qboolean hostloopactive;
 123 void Host_Error (char *error, ...)
 124 {
 125         va_list         argptr;
 126         static  qboolean inerror = false;
 127
 128         // LordHavoc: if host_frame loop has not been run yet, do a Sys_Error instead
 129         if (!hostloopactive)
 130         {
 131                 char string[4096];
 132                 va_start (argptr,error);
 133                 vsprintf (string,error,argptr);
 134                 va_end (argptr);
 135                 Sys_Error ("%s", string);
 136         }
 137
 138         if (inerror)
 139         {
 140                 char string[4096];
 141                 va_start (argptr,error);
 142                 vsprintf (string,error,argptr);
 143                 va_end (argptr);
 144                 Sys_Error ("Host_Error: recursively entered (original error was: %s    new error is: %s)", hosterrorstring, string);
 145         }
 146         inerror = true;
 147
 148 //      SCR_EndLoadingPlaque ();                // reenable screen updates
 149
 150         va_start (argptr,error);
 151         vsprintf (hosterrorstring,error,argptr);
 152         va_end (argptr);
 153         Con_Printf ("Host_Error: %s\n",hosterrorstring);
 154
 155         if (sv.active)
 156                 Host_ShutdownServer (false);
 157
 158         if (cls.state == ca_dedicated)
 159                 Sys_Error ("Host_Error: %s\n",hosterrorstring); // dedicated servers exit
 160
 161         CL_Disconnect ();
 162         cls.demonum = -1;
 163
 164         inerror = false;
 165
 166         longjmp (host_abortserver, 1);
 167 }
 168
 169 /*
 170 ================
 171 Host_FindMaxClients
 172 ================
 173 */
 174 void    Host_FindMaxClients (void)
 175 {
 176         int             i;
 177
 178         svs.maxclients = 1;
 179
 180         i = COM_CheckParm ("-dedicated");
 181         if (i)
 182         {
 183                 cls.state = ca_dedicated;
 184                 if (i != (com_argc - 1))
 185                 {
 186                         svs.maxclients = atoi (com_argv[i+1]);
 187                 }
 188                 else
 189                         svs.maxclients = 8;
 190         }
 191         else
 192                 cls.state = ca_disconnected;
 193
 194         i = COM_CheckParm ("-listen");
 195         if (i)
 196         {
 197                 if (cls.state == ca_dedicated)
 198                         Sys_Error ("Only one of -dedicated or -listen can be specified");
 199                 if (i != (com_argc - 1))
 200                         svs.maxclients = atoi (com_argv[i+1]);
 201                 else
 202                         svs.maxclients = 8;
 203         }
 204         if (svs.maxclients < 1)
 205                 svs.maxclients = 8;
 206         else if (svs.maxclients > MAX_SCOREBOARD)
 207                 svs.maxclients = MAX_SCOREBOARD;
 208
 209         svs.maxclientslimit = svs.maxclients;
 210         if (svs.maxclientslimit < MAX_SCOREBOARD) // LordHavoc: upped listen mode limit from 4 to MAX_SCOREBOARD
 211                 svs.maxclientslimit = MAX_SCOREBOARD;
 212         svs.clients = Hunk_AllocName (svs.maxclientslimit*sizeof(client_t), "clients");
 213
 214         if (svs.maxclients > 1)
 215                 Cvar_SetValue ("deathmatch", 1.0);
 216         else
 217                 Cvar_SetValue ("deathmatch", 0.0);
 218 }
 219
 220
 221 /*
 222 =======================
 223 Host_InitLocal
 224 ======================
 225 */
 226 void Host_InitLocal (void)
 227 {
 228         Host_InitCommands ();
 229
 230         Cvar_RegisterVariable (&host_framerate);
 231         Cvar_RegisterVariable (&host_speeds);
 232         Cvar_RegisterVariable (&slowmo);
 233         Cvar_RegisterVariable (&host_minfps);
 234         Cvar_RegisterVariable (&host_maxfps);
 235
 236         Cvar_RegisterVariable (&sys_ticrate);
 237         Cvar_RegisterVariable (&serverprofile);
 238
 239         Cvar_RegisterVariable (&fraglimit);
 240         Cvar_RegisterVariable (&timelimit);
 241         Cvar_RegisterVariable (&teamplay);
 242         Cvar_RegisterVariable (&samelevel);
 243         Cvar_RegisterVariable (&noexit);
 244         Cvar_RegisterVariable (&skill);
 245         Cvar_RegisterVariable (&developer);
 246         Cvar_RegisterVariable (&deathmatch);
 247         Cvar_RegisterVariable (&coop);
 248
 249         Cvar_RegisterVariable (&pausable);
 250
 251         Cvar_RegisterVariable (&temp1);
 252
 253         Cvar_RegisterVariable (&timestamps);
 254         Cvar_RegisterVariable (&timeformat);
 255
 256         Host_FindMaxClients ();
 257 }
 258
 259
 260 /*
 261 ===============
 262 Host_WriteConfiguration
 263
 264 Writes key bindings and archived cvars to config.cfg
 265 ===============
 266 */
 267 void Host_WriteConfiguration (void)
 268 {
 269         FILE    *f;
 270
 271 // dedicated servers initialize the host but don't parse and set the
 272 // config.cfg cvars
 273         if (host_initialized & !isDedicated)
 274         {
 275                 f = fopen (va("%s/config.cfg",com_gamedir), "w");
 276                 if (!f)
 277                 {
 278                         Con_Printf ("Couldn't write config.cfg.\n");
 279                         return;
 280                 }
 281
 282                 Key_WriteBindings (f);
 283                 Cvar_WriteVariables (f);
 284
 285                 fclose (f);
 286         }
 287 }
 288
 289
 290 /*
 291 =================
 292 SV_ClientPrintf
 293
 294 Sends text across to be displayed
 295 FIXME: make this just a stuffed echo?
 296 =================
 297 */
 298 void SV_ClientPrintf (char *fmt, ...)
 299 {
 300         va_list         argptr;
 301         char            string[1024];
 302
 303         va_start (argptr,fmt);
 304         vsprintf (string, fmt,argptr);
 305         va_end (argptr);
 306
 307         MSG_WriteByte (&host_client->message, svc_print);
 308         MSG_WriteString (&host_client->message, string);
 309 }
 310
 311 /*
 312 =================
 313 SV_BroadcastPrintf
 314
 315 Sends text to all active clients
 316 =================
 317 */
 318 void SV_BroadcastPrintf (char *fmt, ...)
 319 {
 320         va_list         argptr;
 321         char            string[1024];
 322         int                     i;
 323
 324         va_start (argptr,fmt);
 325         vsprintf (string, fmt,argptr);
 326         va_end (argptr);
 327
 328         for (i=0 ; i<svs.maxclients ; i++)
 329                 if (svs.clients[i].active && svs.clients[i].spawned)
 330                 {
 331                         MSG_WriteByte (&svs.clients[i].message, svc_print);
 332                         MSG_WriteString (&svs.clients[i].message, string);
 333                 }
 334 }
 335
 336 /*
 337 =================
 338 Host_ClientCommands
 339
 340 Send text over to the client to be executed
 341 =================
 342 */
 343 void Host_ClientCommands (char *fmt, ...)
 344 {
 345         va_list         argptr;
 346         char            string[1024];
 347
 348         va_start (argptr,fmt);
 349         vsprintf (string, fmt,argptr);
 350         va_end (argptr);
 351
 352         MSG_WriteByte (&host_client->message, svc_stufftext);
 353         MSG_WriteString (&host_client->message, string);
 354 }
 355
 356 /*
 357 =====================
 358 SV_DropClient
 359
 360 Called when the player is getting totally kicked off the host
 361 if (crash = true), don't bother sending signofs
 362 =====================
 363 */
 364 void SV_DropClient (qboolean crash)
 365 {
 366         int             saveSelf;
 367         int             i;
 368         client_t *client;
 369
 370         if (!crash)
 371         {
 372                 // send any final messages (don't check for errors)
 373                 if (NET_CanSendMessage (host_client->netconnection))
 374                 {
 375                         MSG_WriteByte (&host_client->message, svc_disconnect);
 376                         NET_SendMessage (host_client->netconnection, &host_client->message);
 377                 }
 378
 379                 if (sv.active && host_client->edict && host_client->spawned) // LordHavoc: don't call QC if server is dead (avoids recursive Host_Error in some mods when they run out of edicts)
 380                 {
 381                 // call the prog function for removing a client
 382                 // this will set the body to a dead frame, among other things
 383                         saveSelf = pr_global_struct->self;
 384                         pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
 385                         PR_ExecuteProgram (pr_global_struct->ClientDisconnect, "QC function ClientDisconnect is missing");
 386                         pr_global_struct->self = saveSelf;
 387                 }
 388
 389                 Sys_Printf ("Client %s removed\n",host_client->name);
 390         }
 391
 392 // break the net connection
 393         NET_Close (host_client->netconnection);
 394         host_client->netconnection = NULL;
 395
 396 // free the client (the body stays around)
 397         host_client->active = false;
 398         host_client->name[0] = 0;
 399         host_client->old_frags = -999999;
 400         net_activeconnections--;
 401
 402 // send notification to all clients
 403         for (i=0, client = svs.clients ; i<svs.maxclients ; i++, client++)
 404         {
 405                 if (!client->active)
 406                         continue;
 407                 MSG_WriteByte (&client->message, svc_updatename);
 408                 MSG_WriteByte (&client->message, host_client - svs.clients);
 409                 MSG_WriteString (&client->message, "");
 410                 MSG_WriteByte (&client->message, svc_updatefrags);
 411                 MSG_WriteByte (&client->message, host_client - svs.clients);
 412                 MSG_WriteShort (&client->message, 0);
 413                 MSG_WriteByte (&client->message, svc_updatecolors);
 414                 MSG_WriteByte (&client->message, host_client - svs.clients);
 415                 MSG_WriteByte (&client->message, 0);
 416         }
 417 }
 418
 419 /*
 420 ==================
 421 Host_ShutdownServer
 422
 423 This only happens at the end of a game, not between levels
 424 ==================
 425 */
 426 void Host_ShutdownServer(qboolean crash)
 427 {
 428         int             i;
 429         int             count;
 430         sizebuf_t       buf;
 431         char            message[4];
 432         double  start;
 433
 434         if (!sv.active)
 435                 return;
 436
 437         sv.active = false;
 438
 439 // stop all client sounds immediately
 440         if (cls.state == ca_connected)
 441                 CL_Disconnect ();
 442
 443 // flush any pending messages - like the score!!!
 444         start = Sys_FloatTime();
 445         do
 446         {
 447                 count = 0;
 448                 for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
 449                 {
 450                         if (host_client->active && host_client->message.cursize)
 451                         {
 452                                 if (NET_CanSendMessage (host_client->netconnection))
 453                                 {
 454                                         NET_SendMessage(host_client->netconnection, &host_client->message);
 455                                         SZ_Clear (&host_client->message);
 456                                 }
 457                                 else
 458                                 {
 459                                         NET_GetMessage(host_client->netconnection);
 460                                         count++;
 461                                 }
 462                         }
 463                 }
 464                 if ((Sys_FloatTime() - start) > 3.0)
 465                         break;
 466         }
 467         while (count);
 468
 469 // make sure all the clients know we're disconnecting
 470         buf.data = message;
 471         buf.maxsize = 4;
 472         buf.cursize = 0;
 473         MSG_WriteByte(&buf, svc_disconnect);
 474         count = NET_SendToAll(&buf, 5);
 475         if (count)
 476                 Con_Printf("Host_ShutdownServer: NET_SendToAll failed for %u clients\n", count);
 477
 478         for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
 479                 if (host_client->active)
 480                         SV_DropClient(crash);
 481
 482 //
 483 // clear structures
 484 //
 485         memset (&sv, 0, sizeof(sv));
 486         memset (svs.clients, 0, svs.maxclientslimit*sizeof(client_t));
 487 }
 488
 489
 490 /*
 491 ================
 492 Host_ClearMemory
 493
 494 This clears all the memory used by both the client and server, but does
 495 not reinitialize anything.
 496 ================
 497 */
 498 void Host_ClearMemory (void)
 499 {
 500         Con_DPrintf ("Clearing memory\n");
 501         Mod_ClearAll ();
 502         if (host_hunklevel)
 503                 Hunk_FreeToLowMark (host_hunklevel);
 504
 505         cls.signon = 0;
 506         memset (&sv, 0, sizeof(sv));
 507         memset (&cl, 0, sizeof(cl));
 508 }
 509
 510
 511 //============================================================================
 512
 513 /*
 514 ===================
 515 Host_FilterTime
 516
 517 Returns false if the time is too short to run a frame
 518 ===================
 519 */
 520 qboolean Host_FilterTime (double time)
 521 {
 522         double timecap;
 523         realtime += time;
 524
 525         if (slowmo.value < 0.0f)
 526                 Cvar_SetValue("slowmo", 0.0f);
 527         if (host_minfps.value < 10.0f)
 528                 Cvar_SetValue("host_minfps", 10.0f);
 529         if (host_maxfps.value < host_minfps.value)
 530                 Cvar_SetValue("host_maxfps", host_minfps.value);
 531
 532          // check if framerate is too high
 533         if (!cls.timedemo)
 534         {
 535                 timecap = sys_ticrate.value;
 536                 if (cls.state == ca_connected)
 537                         timecap = 1.0 / host_maxfps.value;
 538
 539                 if ((realtime - oldrealtime) < timecap)
 540                         return false;
 541         }
 542
 543         host_realframetime = host_frametime = realtime - oldrealtime; // LordHavoc: copy into host_realframetime as well
 544         oldrealtime = realtime;
 545
 546         if (cls.timedemo)
 547                 return true; // disable time effects
 548
 549         if (host_framerate.value > 0)
 550                 host_frametime = host_framerate.value;
 551         else
 552         {
 553                 // don't allow really short frames
 554                 if (host_frametime > (1.0 / host_minfps.value))
 555                         host_frametime = (1.0 / host_minfps.value);
 556         }
 557
 558         host_frametime *= slowmo.value;
 559         cl.frametime = host_frametime;
 560
 561         return true;
 562 }
 563
 564
 565 /*
 566 ===================
 567 Host_GetConsoleCommands
 568
 569 Add them exactly as if they had been typed at the console
 570 ===================
 571 */
 572 void Host_GetConsoleCommands (void)
 573 {
 574         char    *cmd;
 575
 576         while (1)
 577         {
 578                 cmd = Sys_ConsoleInput ();
 579                 if (!cmd)
 580                         break;
 581                 Cbuf_AddText (cmd);
 582         }
 583 }
 584
 585
 586 /*
 587 ==================
 588 Host_ServerFrame
 589
 590 ==================
 591 */
 592 void Host_ServerFrame (void)
 593 {
 594         static double frametimetotal = 0, lastservertime = 0;
 595         frametimetotal += host_frametime;
 596         // LordHavoc: cap server at sys_ticrate in listen games
 597         if (!isDedicated && svs.maxclients > 1 && ((realtime - lastservertime) < sys_ticrate.value))
 598                 return;
 599 // run the world state
 600         sv.frametime = pr_global_struct->frametime = frametimetotal;
 601         frametimetotal = 0;
 602         lastservertime = realtime;
 603 //      pr_global_struct->frametime = host_frametime;
 604
 605 // set the time and clear the general datagram
 606         SV_ClearDatagram ();
 607
 608 // check for new clients
 609         SV_CheckForNewClients ();
 610
 611 // read client messages
 612         SV_RunClients ();
 613
 614 // move things around and think
 615 // always pause in single player if in console or menus
 616         if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game) )
 617                 SV_Physics ();
 618
 619 // send all messages to the clients
 620         SV_SendClientMessages ();
 621 }
 622
 623
 624 /*
 625 ==================
 626 Host_Frame
 627
 628 Runs all active servers
 629 ==================
 630 */
 631 void _Host_Frame (float time)
 632 {
 633         static double           time1 = 0;
 634         static double           time2 = 0;
 635         static double           time3 = 0;
 636         int                     pass1, pass2, pass3;
 637
 638         if (setjmp (host_abortserver) )
 639                 return;                 // something bad happened, or the server disconnected
 640         hostloopactive = 1;
 641
 642 // keep the random time dependent
 643         rand ();
 644
 645 // decide the simulation time
 646         if (!Host_FilterTime (time))
 647         {
 648                 // if time was rejected, don't totally hog the CPU
 649                 Sys_Sleep();
 650                 return;
 651         }
 652
 653 // get new key events
 654         Sys_SendKeyEvents ();
 655
 656 // allow mice or other external controllers to add commands
 657         IN_Commands ();
 658
 659 // process console commands
 660         Cbuf_Execute ();
 661
 662         NET_Poll();
 663
 664 // if running the server locally, make intentions now
 665         if (sv.active)
 666                 CL_SendCmd ();
 667
 668 //-------------------
 669 //
 670 // server operations
 671 //
 672 //-------------------
 673
 674 // check for commands typed to the host
 675         Host_GetConsoleCommands ();
 676
 677         if (sv.active)
 678                 Host_ServerFrame ();
 679
 680 //-------------------
 681 //
 682 // client operations
 683 //
 684 //-------------------
 685
 686 // if running the server remotely, send intentions now after
 687 // the incoming messages have been read
 688         if (!sv.active)
 689                 CL_SendCmd ();
 690
 691 // fetch results from server
 692         if (cls.state == ca_connected)
 693                 CL_ReadFromServer ();
 694
 695 // update video
 696         if (host_speeds.value)
 697                 time1 = Sys_FloatTime ();
 698
 699         SCR_UpdateScreen ();
 700
 701         if (host_speeds.value)
 702                 time2 = Sys_FloatTime ();
 703
 704 // update audio
 705         if (cls.signon == SIGNONS)
 706         {
 707                 S_Update (r_origin, vpn, vright, vup);
 708                 CL_DecayLights ();
 709         }
 710         else
 711                 S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);
 712
 713         CDAudio_Update();
 714
 715         if (host_speeds.value)
 716         {
 717                 pass1 = (time1 - time3)*1000000;
 718                 time3 = Sys_FloatTime ();
 719                 pass2 = (time2 - time1)*1000000;
 720                 pass3 = (time3 - time2)*1000000;
 721                 Con_Printf ("%6ius total %6ius server %6ius gfx %6ius snd\n",
 722                                         pass1+pass2+pass3, pass1, pass2, pass3);
 723         }
 724
 725         host_framecount++;
 726 }
 727
 728 void Host_Frame (float time)
 729 {
 730         double  time1, time2;
 731         static double   timetotal;
 732         static int              timecount;
 733         int             i, c, m;
 734
 735         if (!serverprofile.value)
 736         {
 737                 _Host_Frame (time);
 738                 return;
 739         }
 740
 741         time1 = Sys_FloatTime ();
 742         _Host_Frame (time);
 743         time2 = Sys_FloatTime ();
 744
 745         timetotal += time2 - time1;
 746         timecount++;
 747
 748         if (timecount < 1000)
 749                 return;
 750
 751         m = timetotal*1000/timecount;
 752         timecount = 0;
 753         timetotal = 0;
 754         c = 0;
 755         for (i=0 ; i<svs.maxclients ; i++)
 756         {
 757                 if (svs.clients[i].active)
 758                         c++;
 759         }
 760
 761         Con_Printf ("serverprofile: %2i clients %2i msec\n",  c,  m);
 762 }
 763
 764 //============================================================================
 765
 766 void Render_Init();
 767
 768 /*
 769 ====================
 770 Host_Init
 771 ====================
 772 */
 773 void Host_Init ()
 774 {
 775         int i;
 776         /*
 777         if (standard_quake)
 778                 minimum_memory = MINIMUM_MEMORY;
 779         else
 780                 minimum_memory = MINIMUM_MEMORY_LEVELPAK;
 781
 782         if (COM_CheckParm ("-minmemory"))
 783                 host_parms.memsize = minimum_memory;
 784
 785         if (host_parms.memsize < minimum_memory)
 786                 Sys_Error ("Only %4.1f megs of memory available, can't execute game", host_parms.memsize / (float)0x100000);
 787         */
 788
 789         host_parms.memsize = DEFAULTMEM * 1024 * 1024;
 790
 791         i = COM_CheckParm("-mem");
 792         if (i)
 793                 host_parms.memsize = (int) (atof(com_argv[i+1]) * 1024 * 1024);
 794
 795         i = COM_CheckParm("-winmem");
 796         if (i)
 797                 host_parms.memsize = (int) (atof(com_argv[i+1]) * 1024 * 1024);
 798
 799         i = COM_CheckParm("-heapsize");
 800         if (i)
 801                 host_parms.memsize = (int) (atof(com_argv[i+1]) * 1024);
 802
 803         host_parms.membase = qmalloc(host_parms.memsize);
 804         if (!host_parms.membase)
 805                 Sys_Error("Not enough memory free, close some programs and try again, or free disk space\n");
 806
 807         com_argc = host_parms.argc;
 808         com_argv = host_parms.argv;
 809
 810         Memory_Init (host_parms.membase, host_parms.memsize);
 811         Cbuf_Init ();
 812         Cmd_Init ();
 813         V_Init ();
 814         Chase_Init ();
 815         COM_Init (host_parms.basedir);
 816         Host_InitLocal ();
 817         W_LoadWadFile ("gfx.wad");
 818         Key_Init ();
 819         Con_Init ();
 820         M_Init ();
 821         PR_Init ();
 822         Mod_Init ();
 823         NET_Init ();
 824         SV_Init ();
 825
 826         Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
 827         Con_Printf ("%4.1f megabyte heap\n",host_parms.memsize/(1024*1024.0));
 828
 829         if (cls.state != ca_dedicated)
 830         {
 831                 Palette_Init("gfx/palette.lmp");
 832
 833 #ifndef _WIN32 // on non win32, mouse comes before video for security reasons
 834                 IN_Init ();
 835 #endif
 836                 VID_Init ();
 837
 838                 Render_Init();
 839                 S_Init ();
 840                 CDAudio_Init ();
 841                 Sbar_Init ();
 842                 CL_Init ();
 843 #ifdef _WIN32 // on non win32, mouse comes before video for security reasons
 844                 IN_Init ();
 845 #endif
 846         }
 847
 848         Cbuf_InsertText ("exec quake.rc\n");
 849
 850         Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
 851         host_hunklevel = Hunk_LowMark ();
 852
 853         host_initialized = true;
 854
 855         Sys_Printf ("========Quake Initialized=========\n");
 856 }
 857
 858
 859 /*
 860 ===============
 861 Host_Shutdown
 862
 863 FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
 864 to run quit through here before the final handoff to the sys code.
 865 ===============
 866 */
 867 void Host_Shutdown(void)
 868 {
 869         static qboolean isdown = false;
 870
 871         if (isdown)
 872         {
 873                 printf ("recursive shutdown\n");
 874                 return;
 875         }
 876         isdown = true;
 877
 878 // keep Con_Printf from trying to update the screen
 879         scr_disabled_for_loading = true;
 880
 881         Host_WriteConfiguration ();
 882
 883         CDAudio_Shutdown ();
 884         NET_Shutdown ();
 885         S_Shutdown();
 886         IN_Shutdown ();
 887
 888         if (cls.state != ca_dedicated)
 889         {
 890                 R_Modules_Shutdown();
 891                 VID_Shutdown();
 892         }
 893 }
 894