Added a "log_file" cvar to control the log file name (default: "" which means no...
[xonotic/darkplaces.git] / host.c
diff --git a/host.c b/host.c
index 32562e1..8a90463 100644 (file)
--- a/host.c
+++ b/host.c
@@ -34,206 +34,201 @@ Memory is cleared / released when a server or client begins, not when they end.
 
 */
 
-quakeparms_t host_parms;
+// true if into command execution
+qboolean host_initialized;
+// LordHavoc: used to turn Host_Error into Sys_Error if starting up or shutting down
+qboolean host_loopactive = false;
+// LordHavoc: set when quit is executed
+qboolean host_shuttingdown = false;
 
-qboolean       host_initialized;               // true if into command execution
-qboolean       host_loopactive = false;        // LordHavoc: used to turn Host_Error into Sys_Error if starting up or shutting down
-qboolean       host_shuttingdown = false;      // LordHavoc: set when quit is executed
+double host_frametime;
+// LordHavoc: the real frametime, before slowmo and clamping are applied (used for console scrolling)
+double host_realframetime;
+// the real time, without any slowmo or clamping
+double realtime;
+// realtime from previous frame
+double oldrealtime;
+// how many frames have occurred
+int host_framecount;
 
-double         host_frametime;
-double         host_realframetime;             // LordHavoc: the real frametime, before slowmo and clamping are applied (used for console scrolling)
-double         realtime;                               // without any filtering or bounding
-double         oldrealtime;                    // last frame run
-int                    host_framecount;
+// used for -developer commandline parameter, hacky hacky
+int forcedeveloper;
 
-int                    forcedeveloper;                 // used for -developer commandline parameter, hacky hacky
+// current client
+client_t *host_client;
 
-client_t       *host_client;                   // current client
+jmp_buf host_abortserver;
 
-jmp_buf        host_abortserver;
+// pretend frames take this amount of time (in seconds), 0 = realtime
+cvar_t host_framerate = {0, "host_framerate","0"};
+// shows time used by certain subsystems
+cvar_t host_speeds = {0, "host_speeds","0"};
+// LordHavoc: framerate independent slowmo
+cvar_t slowmo = {0, "slowmo", "1.0"};
+// LordHavoc: game logic lower cap on framerate (if framerate is below this is, it pretends it is this, so game logic will run normally)
+cvar_t host_minfps = {CVAR_SAVE, "host_minfps", "10"};
+// LordHavoc: framerate upper cap
+cvar_t host_maxfps = {CVAR_SAVE, "host_maxfps", "1000"};
 
-cvar_t host_framerate = {0, "host_framerate","0"};     // set for slow motion
-cvar_t host_speeds = {0, "host_speeds","0"};                   // set for running times
-cvar_t slowmo = {0, "slowmo", "1.0"};                                  // LordHavoc: framerate independent slowmo
-cvar_t host_minfps = {CVAR_SAVE, "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)
-cvar_t host_maxfps = {CVAR_SAVE, "host_maxfps", "1000"};               // LordHavoc: framerate upper cap
+// print broadcast messages in dedicated mode
+cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1"};
 
-cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.05"};
-cvar_t serverprofile = {0, "serverprofile","0"};
+cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.05"};
+cvar_t serverprofile = {0, "serverprofile","0"};
 
-cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0"};
-cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0"};
-cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0"};
+cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0"};
+cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0"};
+cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0"};
 
-cvar_t samelevel = {0, "samelevel","0"};
-cvar_t noexit = {CVAR_NOTIFY, "noexit","0"};
+cvar_t samelevel = {0, "samelevel","0"};
+cvar_t noexit = {CVAR_NOTIFY, "noexit","0"};
 
-cvar_t developer = {0, "developer","0"};
+cvar_t developer = {0, "developer","0"};
 
-cvar_t skill = {0, "skill","1"};                                               // 0 - 3
-cvar_t deathmatch = {0, "deathmatch","0"};                     // 0, 1, or 2
-cvar_t coop = {0, "coop","0"};                 // 0 or 1
+cvar_t skill = {0, "skill","1"};
+cvar_t deathmatch = {0, "deathmatch","0"};
+cvar_t coop = {0, "coop","0"};
 
-cvar_t pausable = {0, "pausable","1"};
+cvar_t pausable = {0, "pausable","1"};
 
-cvar_t temp1 = {0, "temp1","0"};
+cvar_t temp1 = {0, "temp1","0"};
 
-cvar_t timestamps = {CVAR_SAVE, "timestamps", "0"};
-cvar_t timeformat = {CVAR_SAVE, "timeformat", "[%b %e %X] "};
+cvar_t timestamps = {CVAR_SAVE, "timestamps", "0"};
+cvar_t timeformat = {CVAR_SAVE, "timeformat", "[%b %e %X] "};
 
 /*
 ================
-Host_EndGame
+Host_Error
+
+This shuts down both the client and server
 ================
 */
-void Host_EndGame (char *message, ...)
+void PRVM_ProcessError(void);
+static char hosterrorstring1[4096];
+static char hosterrorstring2[4096];
+static qboolean hosterror = false;
+void Host_Error (const char *error, ...)
 {
-       va_list         argptr;
-       char            string[1024];
+       va_list argptr;
 
-       va_start (argptr,message);
-       vsprintf (string,message,argptr);
+       va_start (argptr,error);
+       vsprintf (hosterrorstring1,error,argptr);
        va_end (argptr);
-       Con_DPrintf ("Host_EndGame: %s\n",string);
 
-       if (sv.active)
-               Host_ShutdownServer (false);
+       Con_Printf("Host_Error: %s\n", hosterrorstring1);
 
-       if (cls.state == ca_dedicated)
-               Sys_Error ("Host_EndGame: %s\n",string);        // dedicated servers exit
+       // LordHavoc: if first frame has not been shown, or currently shutting
+       // down, do Sys_Error instead
+       if (!host_loopactive || host_shuttingdown)
+               Sys_Error ("Host_Error: %s", hosterrorstring1);
 
-       if (cls.demonum != -1)
-               CL_NextDemo ();
-       else
-               CL_Disconnect ();
+       if (hosterror)
+               Sys_Error ("Host_Error: recursively entered (original error was: %s    new error is: %s)", hosterrorstring2, hosterrorstring1);
+       hosterror = true;
 
-       longjmp (host_abortserver, 1);
-}
+       strcpy(hosterrorstring2, hosterrorstring1);
 
-/*
-================
-Host_Error
+       CL_Parse_DumpPacket();
 
-This shuts down both the client and server
-================
-*/
-char hosterrorstring[4096];
-void Host_Error (char *error, ...)
-{
-       va_list         argptr;
-       static  qboolean inerror = false;
+       PR_Crash();
 
-       // LordHavoc: if first frame has not been shown, or currently shutting
-       // down, do Sys_Error instead
-       if (!host_loopactive || host_shuttingdown)
-       {
-               char string[4096];
-               va_start (argptr,error);
-               vsprintf (string,error,argptr);
-               va_end (argptr);
-               Sys_Error ("%s", string);
-       }
+       //PRVM_Crash(); // crash current prog
 
-       if (inerror)
-       {
-               char string[4096];
-               va_start (argptr,error);
-               vsprintf (string,error,argptr);
-               va_end (argptr);
-               Sys_Error ("Host_Error: recursively entered (original error was: %s    new error is: %s)", hosterrorstring, string);
-       }
-       inerror = true;
-       
-       va_start (argptr,error);
-       vsprintf (hosterrorstring,error,argptr);
-       va_end (argptr);
-       Con_Printf ("Host_Error: %s\n",hosterrorstring);
-       
-       if (sv.active)
-               Host_ShutdownServer (false);
+       // crash all prvm progs
+       PRVM_CrashAll();
+
+       PRVM_ProcessError();
+
+       Host_ShutdownServer (false);
 
        if (cls.state == ca_dedicated)
-               Sys_Error ("Host_Error: %s\n",hosterrorstring); // dedicated servers exit
+               Sys_Error ("Host_Error: %s\n",hosterrorstring2);        // dedicated servers exit
 
        CL_Disconnect ();
        cls.demonum = -1;
 
-       inerror = false;
+       hosterror = false;
 
        longjmp (host_abortserver, 1);
 }
 
-static mempool_t *clients_mempool;
+mempool_t *sv_clients_mempool = NULL;
 
-/*
-================
-Host_FindMaxClients
-================
-*/
-void   Host_FindMaxClients (void)
+void Host_ServerOptions (void)
 {
-       int             i;
+       int i, numplayers;
 
-       svs.maxclients = 1;
+       // general default
+       numplayers = 8;
 
-       i = COM_CheckParm ("-dedicated");
-       if (i)
+       if (cl_available)
        {
-               cls.state = ca_dedicated;
-               if (i != (com_argc - 1))
+               // client exists, check what mode the user wants
+               i = COM_CheckParm ("-dedicated");
+               if (i)
                {
-                       svs.maxclients = atoi (com_argv[i+1]);
+                       cls.state = ca_dedicated;
+                       // default players unless specified
+                       if (i != (com_argc - 1))
+                               numplayers = atoi (com_argv[i+1]);
+                       if (COM_CheckParm ("-listen"))
+                               Sys_Error ("Only one of -dedicated or -listen can be specified");
                }
                else
-                       svs.maxclients = 8;
+               {
+                       cls.state = ca_disconnected;
+                       i = COM_CheckParm ("-listen");
+                       if (i)
+                       {
+                               // default players unless specified
+                               if (i != (com_argc - 1))
+                                       numplayers = atoi (com_argv[i+1]);
+                       }
+                       else
+                       {
+                               // default players in some games, singleplayer in most
+                               if (gamemode != GAME_TRANSFUSION && gamemode != GAME_GOODVSBAD2 && gamemode != GAME_NEXUIZ && gamemode != GAME_BATTLEMECH)
+                                       numplayers = 1;
+                       }
+               }
        }
        else
-               cls.state = ca_disconnected;
-
-       i = COM_CheckParm ("-listen");
-       if (i)
        {
-               if (cls.state == ca_dedicated)
-                       Sys_Error ("Only one of -dedicated or -listen can be specified");
-               if (i != (com_argc - 1))
-                       svs.maxclients = atoi (com_argv[i+1]);
-               else
-                       svs.maxclients = 8;
+               // no client in the executable, always start dedicated server
+               if (COM_CheckParm ("-listen"))
+                       Sys_Error ("-listen not available in a dedicated server executable");
+               cls.state = ca_dedicated;
+               // check for -dedicated specifying how many players
+               i = COM_CheckParm ("-dedicated");
+               // default players unless specified
+               if (i && i != (com_argc - 1))
+                       numplayers = atoi (com_argv[i+1]);
        }
 
-       // Transfusion doesn't support single player games
-       if (gamemode == GAME_TRANSFUSION && svs.maxclients < 4)
-               svs.maxclients = 4;
-
-       if (svs.maxclients < 1)
-               svs.maxclients = 8;
-       else if (svs.maxclients > MAX_SCOREBOARD)
-               svs.maxclients = MAX_SCOREBOARD;
-
-       svs.maxclientslimit = svs.maxclients;
-       if (svs.maxclientslimit < MAX_SCOREBOARD) // LordHavoc: upped listen mode limit from 4 to MAX_SCOREBOARD
-               svs.maxclientslimit = MAX_SCOREBOARD;
-       if (!clients_mempool)
-               clients_mempool = Mem_AllocPool("clients");
-       if (svs.clients)
-               Mem_Free(svs.clients);
-       svs.clients = Mem_Alloc(clients_mempool, svs.maxclientslimit*sizeof(client_t));
-
-       if (svs.maxclients > 1)
-               Cvar_SetValue ("deathmatch", 1.0);
-       else
-               Cvar_SetValue ("deathmatch", 0.0);
-}
+       if (numplayers < 1)
+               numplayers = 8;
+
+       numplayers = bound(1, numplayers, MAX_SCOREBOARD);
 
+       if (numplayers > 1 && !deathmatch.integer)
+               Cvar_SetValueQuick(&deathmatch, 1);
+
+       svs.maxclients = numplayers;
+       sv_clients_mempool = Mem_AllocPool("server clients");
+       svs.clients = Mem_Alloc(sv_clients_mempool, sizeof(client_t) * svs.maxclients);
+}
 
 /*
 =======================
 Host_InitLocal
 ======================
 */
+void Host_SaveConfig_f(void);
 void Host_InitLocal (void)
 {
        Host_InitCommands ();
+       
+       Cmd_AddCommand("saveconfig", Host_SaveConfig_f);
 
        Cvar_RegisterVariable (&host_framerate);
        Cvar_RegisterVariable (&host_speeds);
@@ -241,6 +236,8 @@ void Host_InitLocal (void)
        Cvar_RegisterVariable (&host_minfps);
        Cvar_RegisterVariable (&host_maxfps);
 
+       Cvar_RegisterVariable (&sv_echobprint);
+
        Cvar_RegisterVariable (&sys_ticrate);
        Cvar_RegisterVariable (&serverprofile);
 
@@ -263,84 +260,116 @@ void Host_InitLocal (void)
        Cvar_RegisterVariable (&timestamps);
        Cvar_RegisterVariable (&timeformat);
 
-       Host_FindMaxClients ();
+       Host_ServerOptions ();
 }
 
 
 /*
 ===============
-Host_WriteConfiguration
+Host_SaveConfig_f
 
 Writes key bindings and archived cvars to config.cfg
 ===============
 */
-void Host_WriteConfiguration (void)
+void Host_SaveConfig_f(void)
 {
-       QFile   *f;
+       qfile_t *f;
 
 // dedicated servers initialize the host but don't parse and set the
 // config.cfg cvars
        if (host_initialized && cls.state != ca_dedicated)
        {
-               f = Qopen (va("%s/config.cfg",com_gamedir), "w");
+               f = FS_Open ("config.cfg", "w", false);
                if (!f)
                {
-                       Con_Print("Couldn't write config.cfg.\n");
+                       Con_Print("Couldn't write config.cfg.\n");
                        return;
                }
-               
+
                Key_WriteBindings (f);
                Cvar_WriteVariables (f);
 
-               Qclose (f);
+               FS_Close (f);
        }
 }
 
 
 /*
 =================
+SV_ClientPrint
+
+Sends text across to be displayed
+FIXME: make this just a stuffed echo?
+=================
+*/
+void SV_ClientPrint(const char *msg)
+{
+       MSG_WriteByte(&host_client->message, svc_print);
+       MSG_WriteString(&host_client->message, msg);
+}
+
+/*
+=================
 SV_ClientPrintf
 
 Sends text across to be displayed
 FIXME: make this just a stuffed echo?
 =================
 */
-void SV_ClientPrintf (char *fmt, ...)
+void SV_ClientPrintf(const char *fmt, ...)
 {
-       va_list         argptr;
-       char            string[1024];
-       
-       va_start (argptr,fmt);
-       vsprintf (string, fmt,argptr);
-       va_end (argptr);
-       
-       MSG_WriteByte (&host_client->message, svc_print);
-       MSG_WriteString (&host_client->message, string);
+       va_list argptr;
+       char msg[4096];
+
+       va_start(argptr,fmt);
+       vsnprintf(msg,sizeof(msg),fmt,argptr);
+       va_end(argptr);
+
+       SV_ClientPrint(msg);
 }
 
 /*
 =================
-SV_BroadcastPrintf
+SV_BroadcastPrint
 
 Sends text to all active clients
 =================
 */
-void SV_BroadcastPrintf (char *fmt, ...)
+void SV_BroadcastPrint(const char *msg)
 {
-       va_list         argptr;
-       char            string[1024];
-       int                     i;
-       
-       va_start (argptr,fmt);
-       vsprintf (string, fmt,argptr);
-       va_end (argptr);
-       
-       for (i=0 ; i<svs.maxclients ; i++)
-               if (svs.clients[i].active && svs.clients[i].spawned)
+       int i;
+       client_t *client;
+
+       for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
+       {
+               if (client->spawned)
                {
-                       MSG_WriteByte (&svs.clients[i].message, svc_print);
-                       MSG_WriteString (&svs.clients[i].message, string);
+                       MSG_WriteByte(&client->message, svc_print);
+                       MSG_WriteString(&client->message, msg);
                }
+       }
+
+       if (sv_echobprint.integer && cls.state == ca_dedicated)
+               Sys_Print(msg);
+}
+
+/*
+=================
+SV_BroadcastPrintf
+
+Sends text to all active clients
+=================
+*/
+void SV_BroadcastPrintf(const char *fmt, ...)
+{
+       va_list argptr;
+       char msg[4096];
+
+       va_start(argptr,fmt);
+       vsnprintf(msg,sizeof(msg),fmt,argptr);
+       va_end(argptr);
+
+       SV_BroadcastPrint(msg);
 }
 
 /*
@@ -350,17 +379,17 @@ Host_ClientCommands
 Send text over to the client to be executed
 =================
 */
-void Host_ClientCommands (char *fmt, ...)
+void Host_ClientCommands(const char *fmt, ...)
 {
-       va_list         argptr;
-       char            string[1024];
-       
-       va_start (argptr,fmt);
-       vsprintf (string, fmt,argptr);
-       va_end (argptr);
+       va_list argptr;
+       char string[1024];
+
+       va_start(argptr,fmt);
+       vsprintf(string, fmt,argptr);
+       va_end(argptr);
 
-       MSG_WriteByte (&host_client->message, svc_stufftext);
-       MSG_WriteString (&host_client->message, string);
+       MSG_WriteByte(&host_client->message, svc_stufftext);
+       MSG_WriteString(&host_client->message, string);
 }
 
 /*
@@ -371,59 +400,65 @@ Called when the player is getting totally kicked off the host
 if (crash = true), don't bother sending signofs
 =====================
 */
-void SV_DropClient (qboolean crash)
+void SV_DropClient(qboolean crash)
 {
-       int             saveSelf;
-       int             i;
+       int saveSelf;
+       int i;
        client_t *client;
 
-       if (!crash)
+       Con_Printf("Client \"%s\" dropped\n", host_client->name);
+
+       // send any final messages (don't check for errors)
+       if (host_client->netconnection)
        {
-               // send any final messages (don't check for errors)
-               if (NET_CanSendMessage (host_client->netconnection))
+               // free the client (the body stays around)
+               if (!crash)
                {
-                       MSG_WriteByte (&host_client->message, svc_disconnect);
-                       NET_SendMessage (host_client->netconnection, &host_client->message);
+                       // LordHavoc: no opportunity for resending, so use unreliable
+                       MSG_WriteByte(&host_client->message, svc_disconnect);
+                       NetConn_SendUnreliableMessage(host_client->netconnection, &host_client->message);
                }
-       
-               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)
+
+               // break the net connection
+               NetConn_Close(host_client->netconnection);
+               host_client->netconnection = NULL;
+
+               // LordHavoc: don't call QC if server is dead (avoids recursive
+               // Host_Error in some mods when they run out of edicts)
+               if (sv.active && host_client->edict && host_client->spawned)
                {
-               // call the prog function for removing a client
-               // this will set the body to a dead frame, among other things
+                       // call the prog function for removing a client
+                       // this will set the body to a dead frame, among other things
                        saveSelf = pr_global_struct->self;
                        pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
-                       PR_ExecuteProgram (pr_global_struct->ClientDisconnect, "QC function ClientDisconnect is missing");
+                       PR_ExecuteProgram(pr_global_struct->ClientDisconnect, "QC function ClientDisconnect is missing");
                        pr_global_struct->self = saveSelf;
                }
-
-               Sys_Printf ("Client %s removed\n",host_client->name);
        }
 
-// break the net connection
-       NET_Close (host_client->netconnection);
-       host_client->netconnection = NULL;
-
-// free the client (the body stays around)
-       host_client->active = false;
-       host_client->name[0] = 0;
-       host_client->old_frags = -999999;
-       net_activeconnections--;
-
-// send notification to all clients
-       for (i=0, client = svs.clients ; i<svs.maxclients ; i++, client++)
+       // send notification to all clients
+       for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
        {
                if (!client->active)
                        continue;
-               MSG_WriteByte (&client->message, svc_updatename);
-               MSG_WriteByte (&client->message, host_client - svs.clients);
-               MSG_WriteString (&client->message, "");
-               MSG_WriteByte (&client->message, svc_updatefrags);
-               MSG_WriteByte (&client->message, host_client - svs.clients);
-               MSG_WriteShort (&client->message, 0);
-               MSG_WriteByte (&client->message, svc_updatecolors);
-               MSG_WriteByte (&client->message, host_client - svs.clients);
-               MSG_WriteByte (&client->message, 0);
+               MSG_WriteByte(&client->message, svc_updatename);
+               MSG_WriteByte(&client->message, host_client->number);
+               MSG_WriteString(&client->message, "");
+               MSG_WriteByte(&client->message, svc_updatefrags);
+               MSG_WriteByte(&client->message, host_client->number);
+               MSG_WriteShort(&client->message, 0);
+               MSG_WriteByte(&client->message, svc_updatecolors);
+               MSG_WriteByte(&client->message, host_client->number);
+               MSG_WriteByte(&client->message, 0);
        }
+
+       NetConn_Heartbeat(1);
+
+       // free the client now
+       if (host_client->entitydatabase4)
+               EntityFrame4_FreeDatabase(host_client->entitydatabase4);
+       // clear the client struct (this sets active to false)
+       memset(host_client, 0, sizeof(*host_client));
 }
 
 /*
@@ -435,64 +470,43 @@ This only happens at the end of a game, not between levels
 */
 void Host_ShutdownServer(qboolean crash)
 {
-       int             i;
-       int             count;
-       sizebuf_t       buf;
-       char            message[4];
-       double  start;
+       int i, count;
+       sizebuf_t buf;
+       char message[4];
+
+       Con_DPrintf("Host_ShutdownServer\n");
 
        if (!sv.active)
                return;
 
-       sv.active = false;
-
-// stop all client sounds immediately
-       CL_Disconnect ();
+       // print out where the crash happened, if it was caused by QC
+       PR_Crash();
 
-// flush any pending messages - like the score!!!
-       start = Sys_DoubleTime();
-       do
-       {
-               count = 0;
-               for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
-               {
-                       if (host_client->active && host_client->message.cursize)
-                       {
-                               if (NET_CanSendMessage (host_client->netconnection))
-                               {
-                                       NET_SendMessage(host_client->netconnection, &host_client->message);
-                                       SZ_Clear (&host_client->message);
-                               }
-                               else
-                               {
-                                       NET_GetMessage(host_client->netconnection);
-                                       count++;
-                               }
-                       }
-               }
-               if ((Sys_DoubleTime() - start) > 3.0)
-                       break;
-       }
-       while (count);
+       NetConn_Heartbeat(2);
+       NetConn_Heartbeat(2);
 
 // make sure all the clients know we're disconnecting
        buf.data = message;
        buf.maxsize = 4;
        buf.cursize = 0;
        MSG_WriteByte(&buf, svc_disconnect);
-       count = NET_SendToAll(&buf, 5);
+       count = NetConn_SendToAll(&buf, 5);
        if (count)
-               Con_Printf("Host_ShutdownServer: NET_SendToAll failed for %u clients\n", count);
+               Con_Printf("Host_ShutdownServer: NetConn_SendToAll failed for %u clients\n", count);
 
-       for (i=0, host_client = svs.clients ; i<svs.maxclients ; i++, host_client++)
+       for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
                if (host_client->active)
-                       SV_DropClient(crash);
+                       SV_DropClient(crash); // server shutdown
+
+       NetConn_CloseServerPorts();
+
+       sv.active = false;
 
 //
 // clear structures
 //
-       memset (&sv, 0, sizeof(sv));
-       memset (svs.clients, 0, svs.maxclientslimit*sizeof(client_t));
+       memset(&sv, 0, sizeof(sv));
+       memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
 }
 
 
@@ -506,7 +520,7 @@ not reinitialize anything.
 */
 void Host_ClearMemory (void)
 {
-       Con_DPrint("Clearing memory\n");
+       Con_DPrint("Clearing memory\n");
        Mod_ClearAll ();
 
        cls.signon = 0;
@@ -527,7 +541,7 @@ Returns false if the time is too short to run a frame
 extern cvar_t cl_avidemo;
 qboolean Host_FilterTime (double time)
 {
-       double timecap;
+       double timecap, timeleft;
        realtime += time;
 
        if (slowmo.value < 0.0f)
@@ -540,21 +554,27 @@ qboolean Host_FilterTime (double time)
                Cvar_SetValue("cl_avidemo", 0.0f);
 
        // check if framerate is too high
-       if (cl_avidemo.value >= 0.1f)
+       if (!cls.timedemo)
        {
-               timecap = 1.0 / (double)cl_avidemo.value;
-               if ((realtime - oldrealtime) < timecap)
-                       return false;
-       }
-       else if (!cls.timedemo)
-       {
-               // default to sys_ticrate (server framerate - presumably low) unless we're the active window and either connected to a server or playing a video
+               // default to sys_ticrate (server framerate - presumably low) unless we
+               // have a good reason to run faster
                timecap = sys_ticrate.value;
-               if (vid_activewindow && (cls.state == ca_connected || cl_videoplaying))
-                       timecap = 1.0 / host_maxfps.value;
+               if (cls.state != ca_dedicated)
+               {
+                       if (cl_avidemo.value >= 0.1f)
+                               timecap = 1.0 / (double)cl_avidemo.value;
+                       else if (vid_activewindow)
+                               timecap = 1.0 / host_maxfps.value;
+               }
 
-               if ((realtime - oldrealtime) < timecap)
+               timeleft = oldrealtime + timecap - realtime;
+               if (timeleft > 0)
+               {
+                       // don't totally hog the CPU
+                       if (timeleft >= 0.02)
+                               Sys_Sleep((int)(timeleft * 1000) - 5);
                        return false;
+               }
        }
 
        // LordHavoc: copy into host_realframetime as well
@@ -594,7 +614,7 @@ Add them exactly as if they had been typed at the console
 */
 void Host_GetConsoleCommands (void)
 {
-       char    *cmd;
+       char *cmd;
 
        while (1)
        {
@@ -616,11 +636,14 @@ void Host_ServerFrame (void)
 {
        static double frametimetotal = 0, lastservertime = 0;
        frametimetotal += host_frametime;
-       // LordHavoc: cap server at sys_ticrate in listen games
-       if (cls.state != ca_dedicated && svs.maxclients > 1 && ((realtime - lastservertime) < sys_ticrate.value))
+       // LordHavoc: cap server at sys_ticrate in networked games
+       if (!cl.islocalgame && ((realtime - lastservertime) < sys_ticrate.value))
                return;
+
+       NetConn_ServerFrame();
+
 // run the world state
-       if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game) )
+       if (!sv.paused && (!cl.islocalgame || (key_dest == key_game && !key_consoleactive)))
                sv.frametime = pr_global_struct->frametime = frametimetotal;
        else
                sv.frametime = 0;
@@ -628,21 +651,21 @@ void Host_ServerFrame (void)
        lastservertime = realtime;
 
 // set the time and clear the general datagram
-       SV_ClearDatagram ();
-
-// check for new clients
-       SV_CheckForNewClients ();
+       SV_ClearDatagram();
 
 // read client messages
-       SV_RunClients ();
+       SV_RunClients();
 
 // move things around and think
 // always pause in single player if in console or menus
-       if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game) )
-               SV_Physics ();
+       if (sv.frametime)
+               SV_Physics();
 
 // send all messages to the clients
-       SV_SendClientMessages ();
+       SV_SendClientMessages();
+
+// send an heartbeat if enough time has passed since the last one
+       NetConn_Heartbeat(0);
 }
 
 
@@ -655,39 +678,39 @@ Runs all active servers
 */
 void _Host_Frame (float time)
 {
-       static double           time1 = 0;
-       static double           time2 = 0;
-       static double           time3 = 0;
-       int                     pass1, pass2, pass3;
+       static double time1 = 0;
+       static double time2 = 0;
+       static double time3 = 0;
+       int pass1, pass2, pass3;
+       usercmd_t cmd; // Used for receiving input
 
-       if (setjmp (host_abortserver) )
+       if (setjmp(host_abortserver))
                return;                 // something bad happened, or the server disconnected
 
-// keep the random time dependent
-       rand ();
+       // keep the random time dependent
+       rand();
 
-// decide the simulation time
-       if (!Host_FilterTime (time))
-       {
-               // if time was rejected, don't totally hog the CPU
-               Sys_Sleep();
+       // decide the simulation time
+       if (!Host_FilterTime(time))
                return;
-       }
 
-// get new key events
-       Sys_SendKeyEvents ();
+       cl.islocalgame = NetConn_IsLocalGame();
 
-// allow mice or other external controllers to add commands
-       IN_Commands ();
+       // get new key events
+       Sys_SendKeyEvents();
 
-// process console commands
-       Cbuf_Execute ();
+       // allow mice or other external controllers to add commands
+       IN_Commands();
 
-       NET_Poll();
+       // Collect input into cmd
+       IN_ProcessMove(&cmd);
 
-// if running the server locally, make intentions now
-       if (sv.active)
-               CL_SendCmd ();
+       // process console commands
+       Cbuf_Execute();
+
+       // if running the server locally, make intentions now
+       if (cls.state == ca_connected && sv.active)
+               CL_SendCmd(&cmd);
 
 //-------------------
 //
@@ -695,11 +718,11 @@ void _Host_Frame (float time)
 //
 //-------------------
 
-// check for commands typed to the host
-       Host_GetConsoleCommands ();
+       // check for commands typed to the host
+       Host_GetConsoleCommands();
 
        if (sv.active)
-               Host_ServerFrame ();
+               Host_ServerFrame();
 
 //-------------------
 //
@@ -707,61 +730,68 @@ void _Host_Frame (float time)
 //
 //-------------------
 
-// if running the server remotely, send intentions now after
-// the incoming messages have been read
-       if (!sv.active)
-               CL_SendCmd ();
+       cl.oldtime = cl.time;
+       cl.time += cl.frametime;
+
+       NetConn_ClientFrame();
 
-// fetch results from server
        if (cls.state == ca_connected)
-               CL_ReadFromServer ();
+       {
+               // if running the server remotely, send intentions now after
+               // the incoming messages have been read
+               if (!sv.active)
+                       CL_SendCmd(&cmd);
+               CL_ReadFromServer();
+       }
 
-       ui_update();
+       //ui_update();
 
        CL_VideoFrame();
 
-// update video
+       // update video
        if (host_speeds.integer)
-               time1 = Sys_DoubleTime ();
+               time1 = Sys_DoubleTime();
 
-       CL_UpdateScreen ();
+       R_UpdateWorld();
+       CL_UpdateScreen();
 
        if (host_speeds.integer)
-               time2 = Sys_DoubleTime ();
+               time2 = Sys_DoubleTime();
 
-// update audio
-       if (cls.signon == SIGNONS)
+       // update audio
+       if (cls.signon == SIGNONS && cl.viewentity >= 0 && cl.viewentity < MAX_EDICTS && cl_entities[cl.viewentity].state_current.active)
        {
                // LordHavoc: this used to use renderer variables (eww)
-               vec3_t forward, right, up;
-               AngleVectors(cl.viewangles, forward, right, up);
-               S_Update (cl_entities[cl.viewentity].render.origin, forward, right, up);
+               vec3_t forward, left, up, origin;
+               Matrix4x4_ToVectors(&cl_entities[cl.viewentity].render.matrix, forward, left, up, origin);
+               S_Update(origin, forward, left, up);
        }
        else
-               S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin);
+               S_Update(vec3_origin, vec3_origin, vec3_origin, vec3_origin);
 
        CDAudio_Update();
 
        if (host_speeds.integer)
        {
                pass1 = (time1 - time3)*1000000;
-               time3 = Sys_DoubleTime ();
+               time3 = Sys_DoubleTime();
                pass2 = (time2 - time1)*1000000;
                pass3 = (time3 - time2)*1000000;
-               Con_Printf ("%6ius total %6ius server %6ius gfx %6ius snd\n",
+               Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n",
                                        pass1+pass2+pass3, pass1, pass2, pass3);
        }
 
        host_framecount++;
        host_loopactive = true;
+
 }
 
 void Host_Frame (float time)
 {
-       double  time1, time2;
-       static double   timetotal;
-       static int              timecount;
-       int             i, c, m;
+       double time1, time2;
+       static double timetotal;
+       static int timecount;
+       int i, c, m;
 
        if (!serverprofile.integer)
        {
@@ -771,11 +801,11 @@ void Host_Frame (float time)
 
        time1 = Sys_DoubleTime ();
        _Host_Frame (time);
-       time2 = Sys_DoubleTime ();      
-       
+       time2 = Sys_DoubleTime ();
+
        timetotal += time2 - time1;
        timecount++;
-       
+
        if (timecount < 1000)
                return;
 
@@ -789,13 +819,12 @@ void Host_Frame (float time)
                        c++;
        }
 
-       Con_Printf ("serverprofile: %2i clients %2i msec\n",  c,  m);
+       Con_Printf("serverprofile: %2i clients %2i msec\n",  c,  m);
 }
 
 //============================================================================
 
 void Render_Init(void);
-void QuakeIO_Init(void);
 
 /*
 ====================
@@ -804,6 +833,8 @@ Host_Init
 */
 void Host_Init (void)
 {
+       int i;
+
        // LordHavoc: quake never seeded the random number generator before... heh
        srand(time(NULL));
 
@@ -815,54 +846,69 @@ void Host_Init (void)
                developer.value = 1;
        }
 
-       Cmd_Init ();
+       Cmd_Init();
        Memory_Init_Commands();
        R_Modules_Init();
-       Cbuf_Init ();
-       QuakeIO_Init ();
-       V_Init ();
-       COM_Init ();
-       Host_InitLocal ();
-       W_LoadWadFile ("gfx.wad");
-       Key_Init ();
-       Con_Init ();
-       Chase_Init ();
-       M_Init ();
-       PR_Init ();
-       Mod_Init ();
-       NET_Init ();
-       SV_Init ();
-
-       Con_Printf ("Builddate: %s\n", buildstring);
+       Cbuf_Init();
+       V_Init();
+       COM_Init();
+       Host_InitLocal();
+       Key_Init();
+       Con_Init();
+       PR_Init();
+       PRVM_Init();
+       Mod_Init();
+       NetConn_Init();
+       SV_Init();
+
+       Con_Printf("Builddate: %s\n", buildstring);
 
        if (cls.state != ca_dedicated)
        {
-               VID_InitCvars();
-
-               Gamma_Init();
-
                Palette_Init();
-
-#ifndef _WIN32 // on non win32, mouse comes before video for security reasons
-               IN_Init ();
-#endif
-               VID_Init ();
+               VID_Shared_Init();
+               VID_Init();
 
                Render_Init();
-               S_Init ();
-               CDAudio_Init ();
-               Sbar_Init ();
-               CL_Init ();
-#ifdef _WIN32 // on non win32, mouse comes before video for security reasons
-               IN_Init ();
-#endif
+               S_Init();
+               CDAudio_Init();
+               CL_Init();
        }
 
-       Cbuf_InsertText ("exec quake.rc\n");
+       // only cvars are executed when host_initialized == false
+       if (gamemode == GAME_TEU)
+               Cbuf_InsertText("exec teu.rc\n");
+       else
+               Cbuf_InsertText("exec quake.rc\n");
+       Cbuf_Execute();
 
        host_initialized = true;
-       
-       Sys_Printf ("========Quake Initialized=========\n");    
+
+       Con_DPrint("========Initialized=========\n");
+
+       if (cls.state != ca_dedicated)
+       {
+               VID_Open();
+               SCR_BeginLoadingPlaque();
+               MR_Init();
+       }
+
+       // stuff it again so the first host frame will execute it again, this time
+       // in its entirety
+       if (gamemode == GAME_TEU)
+               Cbuf_InsertText("exec teu.rc\n");
+       else
+               Cbuf_InsertText("exec quake.rc\n");
+
+       // check for special benchmark mode
+       i = COM_CheckParm("-benchmark");
+       if (i && i + 1 < com_argc)
+               Cbuf_InsertText(va("timedemo %s\n", com_argv[i + 1]));
+
+       Cbuf_Execute();
+
+       // We must wait for the log_file cvar to be initialized to start the log
+       Log_Start ();
 }
 
 
@@ -877,20 +923,26 @@ to run quit through here before the final handoff to the sys code.
 void Host_Shutdown(void)
 {
        static qboolean isdown = false;
-       
+
        if (isdown)
        {
-               printf ("recursive shutdown\n");
+               Con_Print("recursive shutdown\n");
                return;
        }
        isdown = true;
 
-       Host_WriteConfiguration (); 
+       // Shutdown menu
+       if(MR_Shutdown)
+               MR_Shutdown();
+
+       // AK shutdown PRVM
+       // AK hmm, no PRVM_Shutdown(); yet
+
+
+       Host_SaveConfig_f();
 
        CDAudio_Shutdown ();
-       NET_Shutdown ();
-       S_Shutdown();
-       IN_Shutdown ();
+       NetConn_Shutdown ();
 
        if (cls.state != ca_dedicated)
        {