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