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_DoubleTime();
 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_DoubleTime() - 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         cl.frametime = host_frametime = bound(0, host_frametime * slowmo.value, 0.1f); // LordHavoc: the QC code relies on no less than 10fps
 559
 560         return true;
 561 }
 562
 563
 564 /*
 565 ===================
 566 Host_GetConsoleCommands
 567
 568 Add them exactly as if they had been typed at the console
 569 ===================
 570 */
 571 void Host_GetConsoleCommands (void)
 572 {
 573         char    *cmd;
 574
 575         while (1)
 576         {
 577                 cmd = Sys_ConsoleInput ();
 578                 if (!cmd)
 579                         break;
 580                 Cbuf_AddText (cmd);
 581         }
 582 }
 583
 584
 585 /*
 586 ==================
 587 Host_ServerFrame
 588
 589 ==================
 590 */
 591 void Host_ServerFrame (void)
 592 {
 593         static double frametimetotal = 0, lastservertime = 0;
 594         frametimetotal += host_frametime;
 595         // LordHavoc: cap server at sys_ticrate in listen games
 596         if (!isDedicated && svs.maxclients > 1 && ((realtime - lastservertime) < sys_ticrate.value))
 597                 return;
 598 // run the world state
 599         sv.frametime = pr_global_struct->frametime = frametimetotal;
 600         frametimetotal = 0;
 601         lastservertime = realtime;
 602 //      pr_global_struct->frametime = host_frametime;
 603
 604 // set the time and clear the general datagram
 605         SV_ClearDatagram ();
 606
 607 // check for new clients
 608         SV_CheckForNewClients ();
 609
 610 // read client messages
 611         SV_RunClients ();
 612
 613 // move things around and think
 614 // always pause in single player if in console or menus
 615         if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game) )
 616                 SV_Physics ();
 617
 618 // send all messages to the clients
 619         SV_SendClientMessages ();
 620 }
 621
 622
 623 /*
 624 ==================
 625 Host_Frame
 626
 627 Runs all active servers
 628 ==================
 629 */
 630 void _Host_Frame (float time)
 631 {
 632         static double           time1 = 0;
 633         static double           time2 = 0;
 634         static double           time3 = 0;
 635         int                     pass1, pass2, pass3;
 636
 637         if (setjmp (host_abortserver) )
 638                 return;                 // something bad happened, or the server disconnected
 639         hostloopactive = 1;
 640
 641 // keep the random time dependent
 642         rand ();
 643
 644 // decide the simulation time
 645         if (!Host_FilterTime (time))
 646         {
 647                 // if time was rejected, don't totally hog the CPU
 648                 Sys_Sleep();
 649                 return;
 650         }
 651
 652 // get new key events
 653         Sys_SendKeyEvents ();
 654
 655 // allow mice or other external controllers to add commands
 656         IN_Commands ();
 657
 658 // process console commands
 659         Cbuf_Execute ();
 660
 661         NET_Poll();
 662
 663 // if running the server locally, make intentions now
 664         if (sv.active)
 665                 CL_SendCmd ();
 666
 667 //-------------------
 668 //
 669 // server operations
 670 //
 671 //-------------------
 672
 673 // check for commands typed to the host
 674         Host_GetConsoleCommands ();
 675
 676         if (sv.active)
 677                 Host_ServerFrame ();
 678
 679 //-------------------
 680 //
 681 // client operations
 682 //
 683 //-------------------
 684
 685 // if running the server remotely, send intentions now after
 686 // the incoming messages have been read
 687         if (!sv.active)
 688                 CL_SendCmd ();
 689
 690 // fetch results from server
 691         if (cls.state == ca_connected)
 692                 CL_ReadFromServer ();
 693
 694 // update video
 695         if (host_speeds.value)
 696                 time1 = Sys_DoubleTime ();
 697
 698         SCR_UpdateScreen ();
 699
 700         if (host_speeds.value)
 701                 time2 = Sys_DoubleTime ();
 702
 703 // update audio
 704         if (cls.signon == SIGNONS)
 705         {
 706                 S_Update (r_origin, vpn, vright, vup);
 707                 CL_DecayLights ();
 708         }
 709         else
 710                 S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);
 711
 712         CDAudio_Update();
 713
 714         if (host_speeds.value)
 715         {
 716                 pass1 = (time1 - time3)*1000000;
 717                 time3 = Sys_DoubleTime ();
 718                 pass2 = (time2 - time1)*1000000;
 719                 pass3 = (time3 - time2)*1000000;
 720                 Con_Printf ("%6ius total %6ius server %6ius gfx %6ius snd\n",
 721                                         pass1+pass2+pass3, pass1, pass2, pass3);
 722         }
 723
 724         host_framecount++;
 725 }
 726
 727 void Host_Frame (float time)
 728 {
 729         double  time1, time2;
 730         static double   timetotal;
 731         static int              timecount;
 732         int             i, c, m;
 733
 734         if (!serverprofile.value)
 735         {
 736                 _Host_Frame (time);
 737                 return;
 738         }
 739
 740         time1 = Sys_DoubleTime ();
 741         _Host_Frame (time);
 742         time2 = Sys_DoubleTime ();
 743
 744         timetotal += time2 - time1;
 745         timecount++;
 746
 747         if (timecount < 1000)
 748                 return;
 749
 750         m = timetotal*1000/timecount;
 751         timecount = 0;
 752         timetotal = 0;
 753         c = 0;
 754         for (i=0 ; i<svs.maxclients ; i++)
 755         {
 756                 if (svs.clients[i].active)
 757                         c++;
 758         }
 759
 760         Con_Printf ("serverprofile: %2i clients %2i msec\n",  c,  m);
 761 }
 762
 763 //============================================================================
 764
 765 void Render_Init();
 766
 767 /*
 768 ====================
 769 Host_Init
 770 ====================
 771 */
 772 void Host_Init ()
 773 {
 774         int i;
 775         /*
 776         if (standard_quake)
 777                 minimum_memory = MINIMUM_MEMORY;
 778         else
 779                 minimum_memory = MINIMUM_MEMORY_LEVELPAK;
 780
 781         if (COM_CheckParm ("-minmemory"))
 782                 host_parms.memsize = minimum_memory;
 783
 784         if (host_parms.memsize < minimum_memory)
 785                 Sys_Error ("Only %4.1f megs of memory available, can't execute game", host_parms.memsize / (float)0x100000);
 786         */
 787
 788         host_parms.memsize = DEFAULTMEM * 1024 * 1024;
 789
 790         i = COM_CheckParm("-mem");
 791         if (i)
 792                 host_parms.memsize = (int) (atof(com_argv[i+1]) * 1024 * 1024);
 793
 794         i = COM_CheckParm("-winmem");
 795         if (i)
 796                 host_parms.memsize = (int) (atof(com_argv[i+1]) * 1024 * 1024);
 797
 798         i = COM_CheckParm("-heapsize");
 799         if (i)
 800                 host_parms.memsize = (int) (atof(com_argv[i+1]) * 1024);
 801
 802         host_parms.membase = qmalloc(host_parms.memsize);
 803         if (!host_parms.membase)
 804                 Sys_Error("Not enough memory free, close some programs and try again, or free disk space\n");
 805
 806         com_argc = host_parms.argc;
 807         com_argv = host_parms.argv;
 808
 809         Memory_Init (host_parms.membase, host_parms.memsize);
 810         Cbuf_Init ();
 811         Cmd_Init ();
 812         V_Init ();
 813         Chase_Init ();
 814         COM_Init (host_parms.basedir);
 815         Host_InitLocal ();
 816         W_LoadWadFile ("gfx.wad");
 817         Key_Init ();
 818         Con_Init ();
 819         M_Init ();
 820         PR_Init ();
 821         Mod_Init ();
 822         NET_Init ();
 823         SV_Init ();
 824
 825         Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
 826         Con_Printf ("%4.1f megabyte heap\n",host_parms.memsize/(1024*1024.0));
 827
 828         if (cls.state != ca_dedicated)
 829         {
 830                 VID_InitCvars();
 831
 832                 Gamma_Init();
 833
 834                 Palette_Init();
 835
 836 #ifndef _WIN32 // on non win32, mouse comes before video for security reasons
 837                 IN_Init ();
 838 #endif
 839                 VID_Init ();
 840
 841                 Render_Init();
 842                 S_Init ();
 843                 CDAudio_Init ();
 844                 Sbar_Init ();
 845                 CL_Init ();
 846 #ifdef _WIN32 // on non win32, mouse comes before video for security reasons
 847                 IN_Init ();
 848 #endif
 849         }
 850
 851         Cbuf_InsertText ("exec quake.rc\n");
 852
 853         Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
 854         host_hunklevel = Hunk_LowMark ();
 855
 856         host_initialized = true;
 857
 858         Sys_Printf ("========Quake Initialized=========\n");
 859 }
 860
 861
 862 /*
 863 ===============
 864 Host_Shutdown
 865
 866 FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
 867 to run quit through here before the final handoff to the sys code.
 868 ===============
 869 */
 870 void Host_Shutdown(void)
 871 {
 872         static qboolean isdown = false;
 873
 874         if (isdown)
 875         {
 876                 printf ("recursive shutdown\n");
 877                 return;
 878         }
 879         isdown = true;
 880
 881 // keep Con_Printf from trying to update the screen
 882         scr_disabled_for_loading = true;
 883
 884         Host_WriteConfiguration ();
 885
 886         CDAudio_Shutdown ();
 887         NET_Shutdown ();
 888         S_Shutdown();
 889         IN_Shutdown ();
 890
 891         if (cls.state != ca_dedicated)
 892         {
 893                 R_Modules_Shutdown();
 894                 VID_Shutdown();
 895         }
 896 }
 897