/* cl_main.c Client main loop Copyright (C) 1996-1997 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA */ #ifdef HAVE_CONFIG_H # include "config.h" #endif static __attribute__ ((unused)) const char rcsid[] = "$Id$"; #ifdef HAVE_WINDOWS_H # include "winquake.h" #endif #include #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_NETINET_IN_H # define model_t sun_model_t # include # undef model_t #endif #ifdef HAVE_UNISTD_H # include #endif #ifdef HAVE_WINSOCK_H # include #endif #ifdef HAVE_RPC_TYPES_H # include #endif #include #include #include #include "QF/cbuf.h" #include "QF/idparse.h" #include "QF/cdaudio.h" #include "QF/cmd.h" #include "QF/console.h" #include "QF/csqc.h" #include "QF/cvar.h" #include "QF/draw.h" #include "QF/input.h" #include "QF/keys.h" #include "QF/model.h" #include "QF/msg.h" #include "QF/plugin.h" #include "QF/progs.h" #include "QF/qargs.h" #include "QF/qendian.h" #include "QF/quakefs.h" #include "QF/screen.h" #include "QF/sound.h" #include "QF/sys.h" #include "QF/teamplay.h" #include "QF/va.h" #include "QF/vid.h" #include "QF/gib.h" #include "bothdefs.h" #include "buildnum.h" #include "cl_cam.h" #include "cl_chat.h" #include "cl_demo.h" #include "cl_ents.h" #include "cl_input.h" #include "cl_main.h" #include "cl_parse.h" #include "cl_pred.h" #include "cl_skin.h" #include "cl_slist.h" #include "cl_tent.h" #include "client.h" #include "compat.h" #include "game.h" #include "host.h" #include "netchan.h" #include "pmove.h" #include "r_cvar.h" #include "r_dynamic.h" #include "sbar.h" #include "view.h" CLIENT_PLUGIN_PROTOS static plugin_list_t client_plugin_list[] = { CLIENT_PLUGIN_LIST }; // we need to declare some mouse variables here, because the menu system // references them even when on a unix system. qboolean noclip_anglehack; // remnant from old quake cbuf_t *cl_cbuf; cbuf_t *cl_stbuf; cvar_t *fs_globalcfg; cvar_t *fs_usercfg; cvar_t *cl_mem_size; cvar_t *rcon_password; cvar_t *rcon_address; cvar_t *cl_writecfg; cvar_t *cl_allow_cmd_pkt; cvar_t *cl_paranoid; cvar_t *cl_timeout; cvar_t *cl_shownet; cvar_t *cl_autoexec; cvar_t *cl_quakerc; cvar_t *cl_maxfps; cvar_t *cl_usleep; cvar_t *cl_cshift_bonus; cvar_t *cl_cshift_contents; cvar_t *cl_cshift_damage; cvar_t *cl_cshift_powerup; cvar_t *cl_model_crcs; cvar_t *lookspring; cvar_t *m_pitch; cvar_t *m_yaw; cvar_t *m_forward; cvar_t *m_side; cvar_t *cl_predict_players; cvar_t *cl_solid_players; cvar_t *localid; cvar_t *cl_port; cvar_t *cl_autorecord; static qboolean allowremotecmd = true; /* info mirrors */ cvar_t *password; cvar_t *spectator; cvar_t *cl_name; cvar_t *team; cvar_t *rate; cvar_t *noaim; cvar_t *msg; /* GIB events */ gib_event_t *cl_player_health_e, *cl_chat_e; static int cl_usleep_cache; client_static_t cls; client_state_t cl; entity_state_t cl_entities[UPDATE_BACKUP][MAX_DEMO_PACKET_ENTITIES]; entity_state_t cl_baselines[MAX_EDICTS]; efrag_t cl_efrags[MAX_EFRAGS]; entity_t cl_static_entities[MAX_STATIC_ENTITIES]; double connect_time = -1; // for connection retransmits quakeparms_t host_parms; qboolean host_initialized; // true if into command execution qboolean nomaster; double host_frametime; double realtime; // without any filtering or bounding double oldrealtime; // last frame run int host_framecount; double con_frametime; double con_realtime; double oldcon_realtime; int host_hunklevel; byte *host_basepal; byte *vid_colormap; cvar_t *host_speeds; cvar_t *hud_fps; cvar_t *hud_ping; cvar_t *hud_pl; cvar_t *hud_time; int fps_count; jmp_buf host_abort; char *server_version = NULL; // version of server we connected to char emodel_name[] = "emodel"; char pmodel_name[] = "pmodel"; char prespawn_name[] = "prespawn %i 0 %i"; char modellist_name[] = "modellist %i %i"; char soundlist_name[] = "soundlist %i %i"; extern cvar_t *hud_scoreboard_uid; static void CL_Quit_f (void) { if (!con_module) Con_Printf ("I hope you wanted to quit\n"); CL_Disconnect (); Sys_Quit (); } static void CL_Version_f (void) { Con_Printf ("%s Version %s\n", PROGRAM, VERSION); Con_Printf ("Binary: " __TIME__ " " __DATE__ "\n"); } /* CL_SendConnectPacket called by CL_Connect_f and CL_CheckResend */ static void CL_SendConnectPacket (void) { dstring_t *data; double t1, t2; // JACK: Fixed bug where DNS lookups would cause two connects real fast // Now, adds lookup time to the connect time. // Should I add it to realtime instead?!?! if (cls.state != ca_disconnected) return; t1 = Sys_DoubleTime (); if (!NET_StringToAdr (cls.servername, &cls.server_addr)) { Con_Printf ("Bad server address\n"); connect_time = -1; return; } if (cls.server_addr.port == 0) cls.server_addr.port = BigShort (27500); t2 = Sys_DoubleTime (); connect_time = realtime + t2 - t1; // for retransmit requests cls.qport = qport->int_val; data = dstring_new (); dsprintf (data, "%c%c%c%cconnect %i %i %i \"%s\"\n", 255, 255, 255, 255, PROTOCOL_VERSION, cls.qport, cls.challenge, Info_MakeString (cls.userinfo, 0)); Netchan_SendPacket (strlen (data->str), data->str, cls.server_addr); dstring_delete (data); } /* CL_CheckForResend Resend a connect message if the last one has timed out */ static void CL_CheckForResend (void) { static const char *getchallenge = "\377\377\377\377getchallenge\n"; double t1, t2; if (connect_time == -1) return; if (cls.state != ca_disconnected) return; if (connect_time && realtime - connect_time < 5.0) return; t1 = Sys_DoubleTime (); if (!NET_StringToAdr (cls.servername, &cls.server_addr)) { Con_Printf ("Bad server address\n"); connect_time = -1; return; } if (cls.server_addr.port == 0) cls.server_addr.port = BigShort (27500); t2 = Sys_DoubleTime (); connect_time = realtime + t2 - t1; // for retransmit requests VID_SetCaption (va ("Connecting to %s", cls.servername)); Con_Printf ("Connecting to %s...\n", cls.servername); Netchan_SendPacket (strlen (getchallenge), (void *) getchallenge, cls.server_addr); } void CL_BeginServerConnect (void) { connect_time = 0; CL_CheckForResend (); } static void CL_Connect_f (void) { const char *server; if (Cmd_Argc () != 2) { Con_Printf ("usage: connect \n"); return; } server = Cmd_Argv (1); CL_Disconnect (); CL_Chat_Flush_Ignores (); strncpy (cls.servername, server, sizeof (cls.servername) - 1); CL_BeginServerConnect (); } /* CL_Rcon_f Send the rest of the command line over as an unconnected command. */ static void CL_Rcon_f (void) { static dstring_t *message; netadr_t to; if (!message) message = dstring_new (); dsprintf (message, "\377\377\377\377rcon %s %s", rcon_password->string, Cmd_Args (1)); if (cls.state >= ca_connected) to = cls.netchan.remote_address; else { if (!rcon_address->string[0]) { Con_Printf ("You must either be connected, or set the " "'rcon_address' cvar to issue rcon commands\n"); return; } NET_StringToAdr (rcon_address->string, &to); if (to.port == 0) to.port = BigShort (27500); } Netchan_SendPacket (strlen (message->str) + 1, message->str, to); } void CL_ClearState (void) { int i; S_StopAllSounds (true); // wipe the entire cl structure Info_Destroy (cl.serverinfo); memset (&cl, 0, sizeof (cl)); for (i = 0; i < UPDATE_BACKUP; i++) cl.frames[i].packet_entities.entities = cl_entities[i]; memset (cl_entities, 0, sizeof (cl_entities)); cl.serverinfo = Info_ParseString ("", MAX_INFO_STRING, 0); CL_Init_Entity (&cl.viewent); Con_DPrintf ("Clearing memory\n"); D_FlushCaches (); Mod_ClearAll (); if (host_hunklevel) // FIXME: check this... Hunk_FreeToLowMark (host_hunklevel); CL_ClearEnts (); CL_ClearTEnts (); R_ClearEfrags (); R_ClearDlights (); R_ClearParticles (); SZ_Clear (&cls.netchan.message); // clear other arrays memset (cl_efrags, 0, sizeof (cl_efrags)); memset (r_lightstyle, 0, sizeof (r_lightstyle)); } /* CL_StopCshifts Cleans the Cshifts, so your screen doesn't stay red after a timedemo :) */ static void CL_StopCshifts (void) { int i; for (i = 0; i < NUM_CSHIFTS; i++) cl.cshifts[i].percent = 0; for (i = 0; i < MAX_CL_STATS; i++) cl.stats[i] = 0; } static void CL_RemoveQFInfoKeys (void) { Info_RemoveKey (cls.userinfo, "*cap"); Info_RemoveKey (cls.userinfo, "*qf_version"); Info_RemoveKey (cls.userinfo, "*qsg_version"); } /* CL_Disconnect Sends a disconnect message to the server This is also called on Host_Error, so it shouldn't cause any errors */ void CL_Disconnect (void) { byte final[10]; int i; connect_time = -1; VID_SetCaption ("Disconnected"); // stop sounds (especially looping!) S_StopAllSounds (true); // Clean the Cshifts CL_StopCshifts (); // if running a local server, shut it down if (cls.demoplayback) CL_StopPlayback (); else if (cls.state != ca_disconnected) { if (cls.demorecording) CL_Stop_f (); final[0] = clc_stringcmd; strcpy (final + 1, "drop"); Netchan_Transmit (&cls.netchan, 6, final); Netchan_Transmit (&cls.netchan, 6, final); Netchan_Transmit (&cls.netchan, 6, final); CL_SetState (ca_disconnected); cls.demoplayback = cls.demorecording = cls.timedemo = false; cls.demoplayback2 = false; CL_RemoveQFInfoKeys (); } Cam_Reset (); if (cls.download) { Qclose (cls.download); cls.download = NULL; } CL_StopUpload (); Team_ResetTimers (); // remove player info strings for (i = 0; i < MAX_CLIENTS; i++) { if (cl.players[i].userinfo) Info_Destroy (cl.players[i].userinfo); memset (&cl.players[i], 0, sizeof (cl.players[i])); } cl.worldmodel = NULL; cl.validsequence = 0; } void CL_Disconnect_f (void) { CL_Disconnect (); } /* CL_User_f user Dump userdata / masterdata for a user */ static void CL_User_f (void) { int uid, i; if (Cmd_Argc () != 2) { Con_Printf ("Usage: user \n"); return; } uid = atoi (Cmd_Argv (1)); for (i = 0; i < MAX_CLIENTS; i++) { if (!cl.players[i].name[0]) continue; if (cl.players[i].userid == uid || !strcmp (cl.players[i].name, Cmd_Argv (1))) { Info_Print (cl.players[i].userinfo); return; } } Con_Printf ("User not in server.\n"); } /* CL_Users_f Dump userids for all current players */ static void CL_Users_f (void) { int c, i; c = 0; Con_Printf ("userid frags name\n"); Con_Printf ("------ ----- ----\n"); for (i = 0; i < MAX_CLIENTS; i++) { if (cl.players[i].name[0]) { Con_Printf ("%6i %4i %s\n", cl.players[i].userid, cl.players[i].frags, cl.players[i].name); c++; } } Con_Printf ("%i total users\n", c); } /* CL_FullServerinfo_f Sent by server when serverinfo changes */ static void CL_FullServerinfo_f (void) { const char *p; if (Cmd_Argc () != 2) { Con_Printf ("usage: fullserverinfo \n"); return; } Con_DPrintf ("Cmd_Argv (1): '%s'\n", Cmd_Argv (1)); Info_Destroy (cl.serverinfo); cl.serverinfo = Info_ParseString (Cmd_Argv (1), MAX_SERVERINFO_STRING, 0); Con_DPrintf ("cl.serverinfo: '%s'\n", Info_MakeString (cl.serverinfo, 0)); if ((p = Info_ValueForKey (cl.serverinfo, "*qf_version")) && *p) { if (server_version == NULL) Con_Printf ("QuakeForge v%s Server\n", p); server_version = strdup (p); } else if ((p = Info_ValueForKey (cl.serverinfo, "*version")) && *p) { if (server_version == NULL) Con_Printf ("QuakeWorld v%s Server\n", p); server_version = strdup (p); } if ((p = Info_ValueForKey (cl.serverinfo, "*qsg_version")) && *p) { if ((cl.stdver = atof (p))) Con_Printf ("Server supports QSG v%s protocol\n", p); else Con_Printf ("Invalid QSG Protocol number: %s", p); } cl.chase = cl.sv_cshifts = cl.no_pogo_stick = cl.teamplay = 0; if ((p = Info_ValueForKey (cl.serverinfo, "chase")) && *p) { cl.chase = atoi (p); } if ((p = Info_ValueForKey (cl.serverinfo, "cshifts")) && *p) { cl.sv_cshifts = atoi (p); } if ((p = Info_ValueForKey (cl.serverinfo, "no_pogo_stick")) && *p) { cl.no_pogo_stick = atoi (p); } if ((p = Info_ValueForKey (cl.serverinfo, "teamplay")) && *p) { cl.teamplay = atoi (p); Sbar_DMO_Init_f (hud_scoreboard_uid); // HUD setup, cl.teamplay changed } if ((p = Info_ValueForKey (cl.serverinfo, "watervis")) && *p) { cl.watervis = atoi (p); } if ((p = Info_ValueForKey (cl.serverinfo, "skybox")) && *p) { Cvar_Set (r_skyname, p); } } static void CL_AddQFInfoKeys (void) { // set the capabilities info. single char flags (possibly with modifiers) // defined capabilities (* = not implemented): // z client can accept gzipped files. // h * http transfers // f * ftp transfers // a * audio channel (voice chat) // i * irc // p pogo stick control // t team messages static const char *cap = "pt" #ifdef HAVE_ZLIB "z" #endif ; Info_SetValueForStarKey (cls.userinfo, "*cap", cap, 0); Info_SetValueForStarKey (cls.userinfo, "*qf_version", VERSION, 0); Info_SetValueForStarKey (cls.userinfo, "*qsg_version", QW_QSG_VERSION, 0); } /* CL_FullInfo_f Allow clients to change userinfo Casey was here :) */ static void CL_FullInfo_f (void) { info_t *info; if (Cmd_Argc () != 2) { Con_Printf ("fullinfo \n"); return; } info = Info_ParseString (Cmd_Argv (1), MAX_INFO_STRING, 0); Info_AddKeys (cls.userinfo, info); Info_Destroy (info); } /* CL_SetInfo_f Allow clients to change userinfo */ static void CL_SetInfo_f (void) { if (Cmd_Argc () == 1) { Info_Print (cls.userinfo); return; } if (Cmd_Argc () != 3) { Con_Printf ("usage: setinfo [ ]\n"); return; } if (strcaseequal (Cmd_Argv (1), pmodel_name) || strcaseequal (Cmd_Argv (1), emodel_name)) return; Info_SetValueForKey (cls.userinfo, Cmd_Argv (1), Cmd_Argv (2), (!strequal (Cmd_Argv (1), "name")) | (strequal (Cmd_Argv (2), "team") << 1)); if (cls.state >= ca_connected) CL_Cmd_ForwardToServer (); } /* CL_Packet_f packet Contents allows \n escape character */ static void CL_Packet_f (void) { char *send; char *out; const char *in; int i, l; netadr_t adr; if (Cmd_Argc () != 3) { Con_Printf ("packet \n"); return; } if (!NET_StringToAdr (Cmd_Argv (1), &adr)) { Con_Printf ("Bad address\n"); return; } in = Cmd_Argv (2); send = malloc (strlen (in) + 4 + 1); out = send + 4; send[0] = send[1] = send[2] = send[3] = 0xff; l = strlen (in); for (i = 0; i < l; i++) { if (in[i] == '\\' && in[i + 1] == 'n') { *out++ = '\n'; i++; } else *out++ = in[i]; } *out = 0; Netchan_SendPacket (out - send, send, adr); free (send); } /* CL_NextDemo Called to play the next demo in the demo loop */ void CL_NextDemo (void) { if (cls.demonum == -1) return; // don't play demos if (!cls.demos[cls.demonum][0] || cls.demonum == MAX_DEMOS) { cls.demonum = 0; if (!cls.demos[cls.demonum][0]) { cls.demonum = -1; return; } } Cbuf_InsertText (cl_cbuf, va ("playdemo %s\n", cls.demos[cls.demonum])); cls.demonum++; } /* CL_Changing_f Just sent as a hint to the client that they should drop to full console */ static void CL_Changing_f (void) { if (cls.download) // don't change when downloading return; S_StopAllSounds (true); cl.intermission = 0; CL_SetState (ca_connected); // not active anymore, but not // disconnected Con_Printf ("\nChanging map...\n"); } /* CL_Reconnect_f The server is changing levels */ static void CL_Reconnect_f (void) { if (cls.download) // don't change when downloading return; if (cls.demoplayback) return; S_StopAllSounds (true); if (cls.state == ca_connected) { Con_Printf ("reconnecting...\n"); VID_SetCaption ("Reconnecting"); MSG_WriteByte (&cls.netchan.message, clc_stringcmd); MSG_WriteString (&cls.netchan.message, "new"); return; } if (!*cls.servername) { Con_Printf ("No server to reconnect to...\n"); return; } CL_Disconnect (); CL_BeginServerConnect (); } /* CL_ConnectionlessPacket Responses to broadcasts, etc */ static void CL_ConnectionlessPacket (void) { const char *s; int c, clcp_temp; MSG_BeginReading (net_message); MSG_ReadLong (net_message); // skip the -1 c = MSG_ReadByte (net_message); clcp_temp = 0; if (!cls.demoplayback && (cl_paranoid->int_val || !NET_CompareAdr (net_from, cls.server_addr))) Con_Printf ("%s: ", NET_AdrToString (net_from)); if (c == S2C_CONNECTION) { Con_Printf ("connection\n"); if (cls.state >= ca_connected) { if (!cls.demoplayback) Con_Printf ("Dup connect received. Ignored.\n"); return; } Netchan_Setup (&cls.netchan, net_from, cls.qport); MSG_WriteByte (&cls.netchan.message, clc_stringcmd); MSG_WriteString (&cls.netchan.message, "new"); CL_SetState (ca_connected); Con_Printf ("Connected.\n"); allowremotecmd = false; // localid required now for remote // cmds return; } // remote command from gui front end if (c == A2C_CLIENT_COMMAND) { char *cmdtext; int len; Con_Printf ("client command\n"); if (!cl_allow_cmd_pkt->int_val || ((*(unsigned int *) net_from.ip != *(unsigned int *) net_local_adr.ip && *(unsigned int *) net_from.ip != htonl (INADDR_LOOPBACK)))) { Con_Printf ("Command packet from remote host. Ignored.\n"); return; } s = MSG_ReadString (net_message); cmdtext = alloca (strlen (s) + 1); strcpy (cmdtext, s); s = MSG_ReadString (net_message); while (*s && isspace ((byte) *s)) s++; len = strlen (s); while (len && isspace ((byte) s[len - 1])) len--; if (!allowremotecmd && (!*localid->string || (int) strlen (localid->string) > len || strncmp (localid->string, s, len))) { if (!*localid->string) { Con_Printf ("===========================\n"); Con_Printf ("Command packet received from local host, but no " "localid has been set. You may need to upgrade " "your server browser.\n"); Con_Printf ("===========================\n"); return; } Con_Printf ("===========================\n"); Con_Printf ("Invalid localid on command packet received from local host. " "\n|%s| != |%s|\n" "You may need to reload your server browser and %s.\n", s, localid->string, PROGRAM); Con_Printf ("===========================\n"); Cvar_Set (localid, ""); return; } Con_Printf ("%s\n", cmdtext); Cbuf_AddText (cl_cbuf, cmdtext); allowremotecmd = false; return; } // print command from somewhere if (c == A2C_PRINT) { s = MSG_ReadString (net_message); if (SL_CheckStatus (NET_AdrToString (net_from), s)) { Con_Printf ("status response\n"); return; } else if (!cls.demoplayback && (cl_paranoid->int_val || !NET_CompareAdr (net_from, cls.server_addr))) { Con_Printf ("print\n"); } Con_Printf ("%s", s); return; } // ping from somewhere if (c == A2A_PING) { char data[6]; Con_Printf ("ping\n"); data[0] = 0xff; data[1] = 0xff; data[2] = 0xff; data[3] = 0xff; data[4] = A2A_ACK; data[5] = 0; Netchan_SendPacket (6, &data, net_from); return; } if (c == S2C_CHALLENGE) { Con_Printf ("challenge"); if (cls.state >= ca_connected) { if (!cls.demoplayback) Con_Printf ("\nDup challenge received. Ignored.\n"); return; } s = MSG_ReadString (net_message); cls.challenge = atoi (s); if (strstr (s, "QF")) { Con_Printf (": QuakeForge server detected\n"); CL_AddQFInfoKeys (); } else { Con_Printf ("\n"); } CL_SendConnectPacket (); return; } if (c == M2C_MASTER_REPLY) { Con_Printf ("Master Server Reply\n"); clcp_temp = MSG_ReadByte (net_message); s = MSG_ReadString (net_message); MSL_ParseServerList (s); return; } if (c == svc_disconnect) { if (cls.demoplayback) Host_EndGame ("End of demo"); else Con_Printf ("svc_disconnect\n"); return; } Con_Printf ("unknown: %c\n", c); } void CL_ReadPackets (void) { while (CL_GetMessage ()) { if (net_message->message->cursize == -1) continue; if (cls.demoplayback && net_packetlog->int_val) Log_Incoming_Packet (net_message->message->data, net_message->message->cursize, 0); // remote command packet if (*(int *) net_message->message->data == -1) { CL_ConnectionlessPacket (); continue; } if (*(char *) net_message->message->data == A2A_ACK) { SL_CheckPing (NET_AdrToString (net_from)); continue; } if (net_message->message->cursize < 8 && !cls.demoplayback2) { Con_Printf ("%s: Runt packet\n", NET_AdrToString (net_from)); continue; } // packet from server if (!cls.demoplayback && !NET_CompareAdr (net_from, cls.netchan.remote_address)) { Con_DPrintf ("%s:sequenced packet without connection\n", NET_AdrToString (net_from)); continue; } if (!cls.demoplayback2) { if (!Netchan_Process (&cls.netchan)) continue; // wasn't accepted for some reason } else { MSG_BeginReading (net_message); } if (cls.state != ca_disconnected) CL_ParseServerMessage (); } // check timeout if (!cls.demoplayback && cls.state >= ca_connected && realtime - cls.netchan.last_received > cl_timeout->value) { Con_Printf ("\nServer connection timed out.\n"); CL_Disconnect (); return; } } static void CL_Download_f (void) { if (cls.state == ca_disconnected || cls.demoplayback) { Con_Printf ("Must be connected.\n"); return; } if (Cmd_Argc () != 2) { Con_Printf ("Usage: download \n"); return; } snprintf (cls.downloadname, sizeof (cls.downloadname), "%s/%s", qfs_gamedir->dir.def, Cmd_Argv (1)); strncpy (cls.downloadtempname, cls.downloadname, sizeof (cls.downloadtempname)); cls.download = QFS_WOpen (cls.downloadname, 0); if (cls.download) { cls.downloadtype = dl_single; MSG_WriteByte (&cls.netchan.message, clc_stringcmd); SZ_Print (&cls.netchan.message, va ("download %s\n", Cmd_Argv (1))); } else { Con_Printf ("error downloading %s: %s\n", Cmd_Argv (1), strerror (errno)); } } static void Force_CenterView_f (void) { cl.viewangles[PITCH] = 0; } void CL_SetState (cactive_t state) { cactive_t old_state = cls.state; cls.state = state; if (old_state != state) { if (old_state == ca_active) { // leaving active state IN_ClearStates (); r_active = false; game_target = IMT_CONSOLE; key_dest = key_console; // Auto demo recorder stops here if (cl_autorecord->int_val && cls.demorecording) CL_Stop_f (); } else if (state == ca_active) { // entering active state VID_SetCaption (cls.servername); IN_ClearStates (); r_active = true; game_target = IMT_0; key_dest = key_game; // Auto demo recorder starts here if (cl_autorecord->int_val && !cls.demoplayback && !cls.demorecording) CL_Record (0); } } if (con_module) con_module->data->console->force_commandline = (state != ca_active); } void CL_Init (void) { CL_SetState (ca_disconnected); Info_SetValueForStarKey (cls.userinfo, "*ver", QW_VERSION, 0); CL_Input_Init (); CL_Ents_Init (); CL_TEnts_Init (); Pmove_Init (); SL_Init (); // register our commands Cmd_AddCommand ("version", CL_Version_f, "Report version information"); Cmd_AddCommand ("changing", CL_Changing_f, "Used when maps are changing"); Cmd_AddCommand ("disconnect", CL_Disconnect_f, "Disconnect from server"); Cmd_AddCommand ("record", CL_Record_f, "Record a demo, if no filename " "argument is given\n" "the demo will be called Year-Month-Day-Hour-Minute-" "Mapname"); Cmd_AddCommand ("rerecord", CL_ReRecord_f, "Rerecord a demo on the same " "server"); Cmd_AddCommand ("snap", CL_RSShot_f, "Take a screenshot and upload it to " "the server"); Cmd_AddCommand ("stop", CL_Stop_f, "Stop recording a demo"); Cmd_AddCommand ("playdemo", CL_PlayDemo_f, "Play a recorded demo"); Cmd_AddCommand ("timedemo", CL_TimeDemo_f, "Play a demo as fast as your " "hardware can. Useful for benchmarking."); Cmd_AddCommand ("maplist", Con_Maplist_f, "List maps available"); Cmd_AddCommand ("skinlist", Con_Skinlist_f, "List skins available"); Cmd_AddCommand ("skyboxlist", Con_Skyboxlist_f, "List skyboxes available"); Cmd_AddCommand ("demolist", Con_Demolist_QWD_f, "List demos available"); if (!con_module) Cmd_AddCommand ("quit", CL_Quit_f, "Exit the program"); Cmd_AddCommand ("connect", CL_Connect_f, "Connect to a server 'connect " "hostname:port'"); Cmd_AddCommand ("reconnect", CL_Reconnect_f, "Reconnect to the last " "server"); Cmd_AddCommand ("rcon", CL_Rcon_f, "Issue set of commands to the current " "connected server or the one set in rcon_address"); Cmd_AddCommand ("packet", CL_Packet_f, "Send a packet with specified " "contents to the destination"); Cmd_AddCommand ("user", CL_User_f, "Queries the user for his setinfo " "information"); Cmd_AddCommand ("users", CL_Users_f, "Report information on connected " "players and retrieve user ids"); Cmd_AddCommand ("setinfo", CL_SetInfo_f, "Sets information about your " "QuakeWorld user.\n Used without a key it will list all " "of your current settings.\n Specifying a non-existent " "key and a value will create the new key.\n" "Special Keys:\n b_switch - Determines the highest weapon " "that Quake should switch to upon a backpack pickup.\n " "w_switch - Determines the highest weapon that Quake " "should switch to upon a weapon pickup."); Cmd_AddCommand ("fullinfo", CL_FullInfo_f, "Used by GameSpy and Qlist to " "set setinfo variables"); Cmd_AddCommand ("fullserverinfo", CL_FullServerinfo_f, "Used by GameSpy " "and Qlist to obtain server variables"); Cmd_AddCommand ("download", CL_Download_f, "Manually download a quake " "file from the server"); Cmd_AddCommand ("nextul", CL_NextUpload, "Tells the client to send the " "next upload"); Cmd_AddCommand ("stopul", CL_StopUpload, "Tells the client to stop " "uploading"); Cmd_AddCommand ("force_centerview", Force_CenterView_f, "force the view " "to be level"); // forward to server commands Cmd_AddCommand ("kill", CL_Cmd_ForwardToServer, "Suicide :)"); Cmd_AddCommand ("pause", CL_Cmd_ForwardToServer, "Pause the game"); Cmd_AddCommand ("say", CL_Cmd_ForwardToServer, "Say something to all " "other players"); Cmd_AddCommand ("say_team", CL_Cmd_ForwardToServer, "Say something only " "to people on your team"); Cmd_AddCommand ("serverinfo", CL_Cmd_ForwardToServer, "Report the current " "server info"); cl_player_health_e = GIB_Event_New ("player.health"); cl_chat_e = GIB_Event_New ("chat"); } static void cl_usleep_f (cvar_t *var) { cl_usleep_cache = var->int_val; } static void CL_Init_Cvars (void) { cl_model_crcs = Cvar_Get ("cl_model_crcs", "1", CVAR_ARCHIVE, NULL, "Controls setting of emodel and pmodel info " "vars. Required by some servers, but clearing " "this can make the difference between " "connecting and not connecting on some others."); cl_allow_cmd_pkt = Cvar_Get ("cl_allow_cmd_pkt", "1", CVAR_NONE, NULL, "enables packets from the likes of gamespy"); cl_paranoid = Cvar_Get ("cl_paranoid", "1", CVAR_NONE, NULL, "print source address of connectionless packets" " even when coming from the server being connected" " to."); cl_autoexec = Cvar_Get ("cl_autoexec", "0", CVAR_ROM, NULL, "exec autoexec.cfg on gamedir change"); cl_quakerc = Cvar_Get ("cl_quakerc", "1", CVAR_NONE, NULL, "exec quake.rc on startup"); cl_cshift_bonus = Cvar_Get ("cl_cshift_bonus", "1", CVAR_ARCHIVE, NULL, "Show bonus flash on item pickup"); cl_cshift_contents = Cvar_Get ("cl_cshift_content", "1", CVAR_ARCHIVE, NULL, "Shift view colors for contents " "(water, slime, etc)"); cl_cshift_damage = Cvar_Get ("cl_cshift_damage", "1", CVAR_ARCHIVE, NULL, "Shift view colors on damage"); cl_cshift_powerup = Cvar_Get ("cl_cshift_powerup", "1", CVAR_ARCHIVE, NULL, "Shift view colors for powerups"); cl_anglespeedkey = Cvar_Get ("cl_anglespeedkey", "1.5", CVAR_NONE, NULL, "turn `run' speed multiplier"); cl_backspeed = Cvar_Get ("cl_backspeed", "200", CVAR_ARCHIVE, NULL, "backward speed"); cl_forwardspeed = Cvar_Get ("cl_forwardspeed", "200", CVAR_ARCHIVE, NULL, "forward speed"); cl_movespeedkey = Cvar_Get ("cl_movespeedkey", "2.0", CVAR_NONE, NULL, "move `run' speed multiplier"); cl_pitchspeed = Cvar_Get ("cl_pitchspeed", "150", CVAR_NONE, NULL, "look up/down speed"); cl_sidespeed = Cvar_Get ("cl_sidespeed", "350", CVAR_NONE, NULL, "strafe speed"); cl_upspeed = Cvar_Get ("cl_upspeed", "200", CVAR_NONE, NULL, "swim/fly up/down speed"); cl_yawspeed = Cvar_Get ("cl_yawspeed", "140", CVAR_NONE, NULL, "turning speed"); cl_writecfg = Cvar_Get ("cl_writecfg", "1", CVAR_NONE, NULL, "write config files?"); cl_shownet = Cvar_Get ("cl_shownet", "0", CVAR_NONE, NULL, "show network packets. 0=off, 1=basic, 2=verbose"); cl_maxfps = Cvar_Get ("cl_maxfps", "0", CVAR_ARCHIVE, NULL, "maximum frames rendered in one second. 0 == 72"); cl_timeout = Cvar_Get ("cl_timeout", "60", CVAR_ARCHIVE, NULL, "server " "connection timeout (since last packet received)"); host_speeds = Cvar_Get ("host_speeds", "0", CVAR_NONE, NULL, "display host processing times"); lookspring = Cvar_Get ("lookspring", "0", CVAR_ARCHIVE, NULL, "Snap view " "to center when moving and no mlook/klook"); m_forward = Cvar_Get ("m_forward", "1", CVAR_ARCHIVE, NULL, "mouse forward/back speed"); m_pitch = Cvar_Get ("m_pitch", "0.022", CVAR_ARCHIVE, NULL, "mouse pitch (up/down) multipier"); m_side = Cvar_Get ("m_side", "0.8", CVAR_ARCHIVE, NULL, "mouse strafe speed"); m_yaw = Cvar_Get ("m_yaw", "0.022", CVAR_ARCHIVE, NULL, "mouse yaw (left/right) multiplier"); rcon_password = Cvar_Get ("rcon_password", "", CVAR_NONE, NULL, "remote control password"); rcon_address = Cvar_Get ("rcon_address", "", CVAR_NONE, NULL, "server IP " "address when client not connected - for " "sending rcon commands"); hud_fps = Cvar_Get ("hud_fps", "0", CVAR_ARCHIVE, NULL, "display realtime frames per second"); hud_ping = Cvar_Get ("hud_ping", "0", CVAR_ARCHIVE, NULL, "display current ping to server"); hud_pl = Cvar_Get ("hud_pl", "0", CVAR_ARCHIVE, NULL, "display current packet loss to server"); hud_time = Cvar_Get ("hud_time", "0", CVAR_ARCHIVE, NULL, "Display the current time, 1 24hr, 2 AM/PM"); cl_predict_players = Cvar_Get ("cl_predict_players", "1", CVAR_NONE, NULL, "If this is 0, no player prediction is " "done"); cl_solid_players = Cvar_Get ("cl_solid_players", "1", CVAR_NONE, NULL, "Are players solid? If off, you can walk " "through them with difficulty"); localid = Cvar_Get ("localid", "", CVAR_NONE, NULL, "Used by " "gamespy+others to authenticate when sending " "commands to the client"); // info mirrors cl_name = Cvar_Get ("name", "unnamed", CVAR_ARCHIVE | CVAR_USERINFO, Cvar_Info, "Player name"); password = Cvar_Get ("password", "", CVAR_USERINFO, Cvar_Info, "Server password"); spectator = Cvar_Get ("spectator", "", CVAR_USERINFO, Cvar_Info, "Set to 1 before connecting to become a spectator"); team = Cvar_Get ("team", "", CVAR_ARCHIVE | CVAR_USERINFO, Cvar_Info, "Team player is on."); rate = Cvar_Get ("rate", "2500", CVAR_ARCHIVE | CVAR_USERINFO, Cvar_Info, "Amount of bytes per second server will send/download " "to you"); msg = Cvar_Get ("msg", "1", CVAR_ARCHIVE | CVAR_USERINFO, Cvar_Info, "Determines the type of messages reported 0 is maximum, " "4 is none"); noaim = Cvar_Get ("noaim", "0", CVAR_ARCHIVE | CVAR_USERINFO, Cvar_Info, "Auto aim off switch. Set to 1 to turn off."); cl_port = Cvar_Get ("cl_port", PORT_CLIENT, CVAR_NONE, Cvar_Info, "UDP Port for client to use."); cl_usleep = Cvar_Get ("cl_usleep", "0", CVAR_ARCHIVE, cl_usleep_f, "Turn this on to save cpu when fps limited. " "May affect frame rate adversely depending on " "local machine/os conditions"); cl_autorecord = Cvar_Get ("cl_autorecord", "0", CVAR_ARCHIVE, NULL, "Turn " "this on, if you want to record every game"); } /* Host_EndGame Call this to drop to a console without exiting the qwcl */ void Host_EndGame (const char *message, ...) { static dstring_t *str; va_list argptr; if (!str) str = dstring_new (); va_start (argptr, message); dvsprintf (str, message, argptr); va_end (argptr); Con_Printf ("\n===========================\n"); Con_Printf ("Host_EndGame: %s\n", str->str); Con_Printf ("===========================\n\n"); CL_Disconnect (); longjmp (host_abort, 1); } /* Host_Error This shuts down the client and exits qwcl */ void Host_Error (const char *error, ...) { static dstring_t *str; static qboolean inerror = false; va_list argptr; if (inerror) Sys_Error ("Host_Error: recursively entered"); if (!str) str = dstring_new (); inerror = true; va_start (argptr, error); dvsprintf (str, error, argptr); va_end (argptr); Con_Printf ("Host_Error: %s", str->str); CL_Disconnect (); cls.demonum = -1; inerror = false; if (host_initialized) { longjmp (host_abort, 1); } else { Sys_Error ("Host_Error: %s", str->str); } } /* Host_WriteConfiguration Writes key bindings and archived cvars to config.cfg */ void Host_WriteConfiguration (void) { QFile *f; if (host_initialized && cl_writecfg->int_val) { char *path = va ("%s/config.cfg", qfs_gamedir->dir.def); f = QFS_WOpen (path, 0); if (!f) { Con_Printf ("Couldn't write config.cfg.\n"); return; } Key_WriteBindings (f); Cvar_WriteVariables (f); Qclose (f); } } /* Host_SimulationTime This determines if enough time has passed to run a simulation frame, or returns the amount of time that has to be waited */ static inline float Host_SimulationTime (float time) { float fps, timedifference; float timescale = 1.0; con_realtime += time; if (cls.demoplayback) { timescale = max (0, demo_speed->value); time *= timescale; } realtime += time; if (oldrealtime > realtime) oldrealtime = 0; if (cls.timedemo) return 0; if (cl_maxfps->value <= 0) fps = 72; else fps = min (cl_maxfps->value, 72); timedifference = (timescale / fps) - (realtime - oldrealtime); if (timedifference > 0) return timedifference; // framerate is too high return 0; } int nopacketcount; /* Host_Frame Runs all active servers */ void Host_Frame (float time) { static double time1 = 0; static double time2 = 0; static double time3 = 0; float sleeptime; int pass1, pass2, pass3; if (setjmp (host_abort)) // something bad happened, or the server disconnected return; // decide the simulation time if ((sleeptime = Host_SimulationTime (time)) != 0) { #ifdef HAVE_USLEEP if (cl_usleep_cache && sleeptime > 0.002) // minimum sleep time usleep ((unsigned long) (sleeptime * 1000000 / 2)); #endif return; // framerate is too high } host_frametime = realtime - oldrealtime; oldrealtime = realtime; host_frametime = min (host_frametime, 0.2); con_frametime = con_realtime - oldcon_realtime; oldcon_realtime = con_realtime; IN_ProcessEvents (); // process gib threads GIB_Thread_Execute (); // process console commands Cbuf_Execute_Stack (cl_cbuf); Cbuf_Execute_Stack (cl_stbuf); // fetch results from server CL_ReadPackets (); if (cls.demoplayback2) { player_state_t *self, *oldself; self = &cl.frames[cl.parsecount & UPDATE_MASK].playerstate[cl.playernum]; oldself = &cl.frames[(cls.netchan.outgoing_sequence - 1) & UPDATE_MASK].playerstate[cl.playernum]; self->messagenum = cl.parsecount; VectorCopy (oldself->origin, self->origin); VectorCopy (oldself->velocity, self->velocity); VectorCopy (oldself->viewangles, self->viewangles); CL_ParseClientdata (); cls.netchan.outgoing_sequence = cl.parsecount + 1; } // send intentions now // resend a connection request if necessary if (cls.state == ca_disconnected) { CL_CheckForResend (); } else { CL_SendCmd (); // Set up prediction for other players CL_SetUpPlayerPrediction (false); // do client side motion prediction CL_PredictMove (); // Set up prediction for other players CL_SetUpPlayerPrediction (cl_predict_players->int_val); // build a refresh entity list CL_EmitEntities (); } // update video if (host_speeds->int_val) time1 = Sys_DoubleTime (); r_inhibit_viewmodel = (!Cam_DrawViewModel () || (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) || cl.stats[STAT_HEALTH] <= 0); r_force_fullscreen = cl.intermission; r_paused = cl.paused; r_active = cls.state == ca_active; r_view_model = &cl.viewent; r_frametime = host_frametime; CL_UpdateScreen (realtime); if (host_speeds->int_val) time2 = Sys_DoubleTime (); // update audio if (cls.state == ca_active) { S_Update (r_origin, vpn, vright, vup); R_DecayLights (host_frametime); } else S_Update (vec3_origin, vec3_origin, vec3_origin, vec3_origin); CDAudio_Update (); if (host_speeds->int_val) { pass1 = (time1 - time3) * 1000; time3 = Sys_DoubleTime (); pass2 = (time2 - time1) * 1000; pass3 = (time3 - time2) * 1000; Con_Printf ("%3i tot %3i server %3i gfx %3i snd\n", pass1 + pass2 + pass3, pass1, pass2, pass3); } host_framecount++; fps_count++; } static int check_quakerc (void) { const char *l, *p; int ret = 1; QFile *f; QFS_FOpenFile ("quake.rc", &f); if (!f) return 1; while ((l = Qgetline (f))) { if ((p = strstr (l, "stuffcmds"))) { if (p == l) { // only known case so far ret = 0; break; } } } Qclose (f); return ret; } static void CL_Init_Memory (void) { int mem_parm = COM_CheckParm ("-mem"); int mem_size; void *mem_base; cl_mem_size = Cvar_Get ("cl_mem_size", "16", CVAR_NONE, NULL, "Amount of memory (in MB) to allocate for the " PROGRAM " heap"); if (mem_parm) Cvar_Set (cl_mem_size, com_argv[mem_parm + 1]); if (COM_CheckParm ("-minmemory")) Cvar_SetValue (cl_mem_size, MINIMUM_MEMORY / (1024 * 1024.0)); Cvar_SetFlags (cl_mem_size, cl_mem_size->flags | CVAR_ROM); mem_size = (int) (cl_mem_size->value * 1024 * 1024); if (mem_size < MINIMUM_MEMORY) Sys_Error ("Only %4.1f megs of memory reported, can't execute game", mem_size / (float) 0x100000); mem_base = malloc (mem_size); if (!mem_base) Sys_Error ("Can't allocate %d", mem_size); Sys_PageIn (mem_base, mem_size); Memory_Init (mem_base, mem_size); } void Host_Init (void) { cl_cbuf = Cbuf_New (&id_interp); cl_stbuf = Cbuf_New (&id_interp); Cvar_Init_Hash (); Cmd_Init_Hash (); Cvar_Init (); Sys_Init_Cvars (); Sys_Init (); Cmd_Init (); GIB_Init (true); // execute +set as early as possible Cmd_StuffCmds (cl_cbuf); Cbuf_Execute_Sets (cl_cbuf); // execute the global configuration file if it exists // would have been nice if Cmd_Exec_f could have been used, but it // only reads from within the quake file system, and changing that is // probably Not A Good Thing (tm). fs_globalcfg = Cvar_Get ("fs_globalcfg", FS_GLOBALCFG, CVAR_ROM, NULL, "global configuration file"); Cmd_Exec_File (cl_cbuf, fs_globalcfg->string, 0); Cbuf_Execute_Sets (cl_cbuf); // execute +set again to override the config file Cmd_StuffCmds (cl_cbuf); Cbuf_Execute_Sets (cl_cbuf); fs_usercfg = Cvar_Get ("fs_usercfg", FS_USERCFG, CVAR_ROM, NULL, "user configuration file"); Cmd_Exec_File (cl_cbuf, fs_usercfg->string, 0); Cbuf_Execute_Sets (cl_cbuf); // execute +set again to override the config file Cmd_StuffCmds (cl_cbuf); Cbuf_Execute_Sets (cl_cbuf); CL_Init_Memory (); pr_gametype = "quakeworld"; cls.userinfo = Info_ParseString ("", MAX_INFO_STRING, 0); cl.serverinfo = Info_ParseString ("", MAX_INFO_STRING, 0); QFS_Init ("qw"); PI_Init (); CL_Cam_Init_Cvars (); CL_Input_Init_Cvars (); CL_Skin_Init_Cvars (); CL_Init_Cvars (); CL_Prediction_Init_Cvars (); COM_Init_Cvars (); Con_Init_Cvars (); Game_Init_Cvars (); IN_Init_Cvars (); Key_Init_Cvars (); Mod_Init_Cvars (); Netchan_Init_Cvars (); PR_Init_Cvars (); Pmove_Init_Cvars (); R_Init_Cvars (); R_Particles_Init_Cvars (); S_Init_Cvars (); Team_Init_Cvars (); V_Init_Cvars (); VID_Init_Cvars (); PR_Init (); BI_Init (); CL_Chat_Init (); CL_Cmd_Init (); V_Init (); Game_Init (); COM_Init (); PI_RegisterPlugins (client_plugin_list); Con_Init ("client"); if (con_module) { con_module->data->console->dl_name = cls.downloadname; con_module->data->console->dl_percent = &cls.downloadpercent; con_module->data->console->realtime = &con_realtime; con_module->data->console->frametime = &con_frametime; con_module->data->console->quit = CL_Quit_f; con_module->data->console->cbuf = cl_cbuf; } NET_Init (cl_port->int_val); Netchan_Init (); { static const char *sound_precache[MAX_MODELS]; int i; for (i = 0; i < MAX_MODELS; i++) sound_precache[i] = cl.sound_name[i]; Net_Log_Init (sound_precache); } W_LoadWadFile ("gfx.wad"); Key_Init (cl_cbuf); Mod_Init (); CL_Demo_Init (); Con_Printf ("%4.1f megabyte heap.\n", cl_mem_size->value); host_basepal = (byte *) QFS_LoadHunkFile ("gfx/palette.lmp"); if (!host_basepal) Sys_Error ("Couldn't load gfx/palette.lmp"); vid_colormap = (byte *) QFS_LoadHunkFile ("gfx/colormap.lmp"); if (!vid_colormap) Sys_Error ("Couldn't load gfx/colormap.lmp"); VID_Init (host_basepal); Draw_Init (); SCR_Init (); R_Init (); S_Init (&cl.worldmodel, &viewentity, &host_frametime); CDAudio_Init (); Sbar_Init (); CL_Init (); IN_Init (); CL_SetState (ca_disconnected); CL_Skin_Init (); Locs_Init (); CL_UpdateScreen (realtime); CL_UpdateScreen (realtime); if (cl_quakerc->int_val) Cbuf_InsertText (cl_cbuf, "exec quake.rc\n"); Cmd_Exec_File (cl_cbuf, fs_usercfg->string, 0); // Reparse the command line for + commands. // (Note, no non-base commands exist yet) if (!cl_quakerc->int_val || check_quakerc ()) Cmd_StuffCmds (cl_cbuf); Hunk_AllocName (0, "-HOST_HUNKLEVEL-"); host_hunklevel = Hunk_LowMark (); Con_Printf ("\nClient version %s (build %04d)\n\n", VERSION, build_number ()); Con_Printf ("\x80\x81\x81\x82 %s initialized \x80\x81\x81\x82\n", PROGRAM); // make sure all + commands have been executed Cbuf_Execute_Stack (cl_cbuf); host_initialized = true; CL_UpdateScreen (realtime); Con_NewMap (); // force the menus to be loaded CL_UpdateScreen (realtime); CL_UpdateScreen (realtime); if (connect_time == -1) { Cbuf_AddText (cl_cbuf, "echo Type connect or use a " "server browser to connect to a game.\n"); } Cbuf_AddText (cl_cbuf, "set cmd_warncmd 1\n"); } void Host_Shutdown (void) { static qboolean isdown = false; if (isdown) { printf ("recursive shutdown\n"); return; } isdown = true; SL_Shutdown (); Host_WriteConfiguration (); CDAudio_Shutdown (); NET_Shutdown (); S_Shutdown (); IN_Shutdown (); if (host_basepal) VID_Shutdown (); } qboolean ServerPaused (void) { return false; }