mirror of https://bitbucket.org/CPMADevs/cnq3
3046 lines
85 KiB
C++
3046 lines
85 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code 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.
|
|
|
|
Quake III Arena source code 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 Quake III Arena source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
// cl_main.c -- client main loop
|
|
|
|
#include "client.h"
|
|
#include "client_help.h"
|
|
|
|
|
|
cvar_t *cl_debugMove;
|
|
|
|
cvar_t *rconPassword;
|
|
cvar_t *rconAddress;
|
|
|
|
cvar_t* cl_timeout;
|
|
cvar_t* cl_maxpackets;
|
|
cvar_t* cl_packetdup;
|
|
cvar_t* cl_showTimeDelta;
|
|
cvar_t* cl_serverStatusResendTime;
|
|
cvar_t* cl_shownet;
|
|
cvar_t* cl_showSend;
|
|
|
|
cvar_t *cl_timedemo;
|
|
cvar_t *cl_aviFrameRate;
|
|
cvar_t *cl_aviMotionJpeg;
|
|
cvar_t *cl_ffmpeg;
|
|
cvar_t *cl_ffmpegCommand;
|
|
cvar_t *cl_ffmpegExePath;
|
|
cvar_t *cl_ffmpegOutPath;
|
|
cvar_t *cl_ffmpegOutExt;
|
|
cvar_t *cl_ffmpegLog;
|
|
|
|
cvar_t *cl_allowDownload;
|
|
cvar_t *cl_inGameVideo;
|
|
|
|
cvar_t *cl_matchAlerts;
|
|
cvar_t *cl_demoPlayer;
|
|
cvar_t *cl_escapeAbortsDemo;
|
|
|
|
cvar_t *net_proxy;
|
|
|
|
clientActive_t cl;
|
|
clientConnection_t clc;
|
|
clientStatic_t cls;
|
|
vm_t *cgvm;
|
|
|
|
refexport_t re; // functions exported from refresh DLL
|
|
|
|
#define RETRANSMIT_TIMEOUT 3000 // time between connection packet retransmits
|
|
|
|
|
|
/*
|
|
===============
|
|
CL_CDDialog
|
|
|
|
Called by Com_Error when a cd is needed
|
|
===============
|
|
*/
|
|
void CL_CDDialog( void ) {
|
|
cls.cddialog = qtrue; // start it next frame
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================
|
|
|
|
CLIENT RELIABLE COMMAND COMMUNICATION
|
|
|
|
=======================================================================
|
|
*/
|
|
|
|
/*
|
|
======================
|
|
CL_AddReliableCommand
|
|
|
|
The given command will be transmitted to the server, and is guaranteed to
|
|
not have future usercmd_t executed before it is executed
|
|
======================
|
|
*/
|
|
void CL_AddReliableCommand( const char *cmd ) {
|
|
if ( clc.demoplaying ) {
|
|
return;
|
|
}
|
|
|
|
// if we would be losing an old command that hasn't been acknowledged,
|
|
// we must drop the connection
|
|
if ( clc.reliableSequence - clc.reliableAcknowledge > MAX_RELIABLE_COMMANDS ) {
|
|
Com_Error( ERR_DROP, "Client command overflow" );
|
|
}
|
|
clc.reliableSequence++;
|
|
const int index = clc.reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
|
|
Q_strncpyz( clc.reliableCommands[ index ], cmd, sizeof( clc.reliableCommands[ index ] ) );
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================
|
|
|
|
CLIENT SIDE DEMO RECORDING
|
|
|
|
=======================================================================
|
|
*/
|
|
|
|
|
|
// saves the current net message to file, prefixed by the length
|
|
|
|
static void CL_WriteDemoMessage ( msg_t *msg, int headerBytes )
|
|
{
|
|
int len, swlen;
|
|
|
|
// write the packet sequence
|
|
len = clc.serverMessageSequence;
|
|
swlen = LittleLong( len );
|
|
FS_Write( &swlen, 4, clc.demofile );
|
|
|
|
// skip the packet sequencing information
|
|
len = msg->cursize - headerBytes;
|
|
swlen = LittleLong(len);
|
|
FS_Write( &swlen, 4, clc.demofile );
|
|
FS_Write( msg->data + headerBytes, len, clc.demofile );
|
|
}
|
|
|
|
|
|
static void CL_StopRecord_f( void )
|
|
{
|
|
if ( !clc.demorecording ) {
|
|
Com_Printf ("Not recording a demo.\n");
|
|
return;
|
|
}
|
|
|
|
// finish up
|
|
int len = -1;
|
|
FS_Write (&len, 4, clc.demofile);
|
|
FS_Write (&len, 4, clc.demofile);
|
|
FS_FCloseFile (clc.demofile);
|
|
clc.demofile = 0;
|
|
clc.demorecording = qfalse;
|
|
clc.showAnnoyingDemoRecordMessage = qfalse;
|
|
Com_Printf ("Stopped demo.\n");
|
|
}
|
|
|
|
|
|
static const char* CL_DemoFilename()
|
|
{
|
|
static char s[MAX_OSPATH];
|
|
|
|
qtime_t t;
|
|
Com_RealTime( &t );
|
|
Com_sprintf( s, sizeof(s), "demos/%d_%02d_%02d-%02d_%02d_%02d.dm_%d",
|
|
1900+t.tm_year, 1+t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, PROTOCOL_VERSION );
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
// record [demoname]
|
|
// starts recording a demo from the current position
|
|
|
|
static void CL_Record_f()
|
|
{
|
|
if ( Cmd_Argc() > 2 ) {
|
|
Com_Printf ("record [demoname]\n");
|
|
return;
|
|
}
|
|
|
|
if ( clc.demorecording ) {
|
|
if (!clc.showAnnoyingDemoRecordMessage) {
|
|
Com_Printf ("Already recording.\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( cls.state != CA_ACTIVE ) {
|
|
Com_Printf ("You must be in a level to record.\n");
|
|
return;
|
|
}
|
|
|
|
char name[MAX_OSPATH];
|
|
int i;
|
|
const char* s;
|
|
if ( Cmd_Argc() == 2 ) {
|
|
Com_sprintf( name, sizeof(name), "demos/%s.dm_%d", Cmd_Argv(1), PROTOCOL_VERSION );
|
|
s = name;
|
|
} else {
|
|
s = CL_DemoFilename();
|
|
}
|
|
|
|
clc.demofile = FS_FOpenFileWrite( s );
|
|
if ( !clc.demofile ) {
|
|
Com_Printf( "ERROR: couldn't open %s\n", s );
|
|
return;
|
|
}
|
|
|
|
Com_Printf( "recording to %s\n", s );
|
|
clc.demorecording = qtrue;
|
|
clc.showAnnoyingDemoRecordMessage = !Cvar_VariableValue("ui_recordSPDemo");
|
|
|
|
Q_strncpyz( clc.demoName, s, sizeof( clc.demoName ) );
|
|
|
|
// don't start saving messages until a non-delta compressed message is received
|
|
clc.demowaiting = qtrue;
|
|
|
|
// write out the gamestate message
|
|
msg_t msg;
|
|
byte buf[MAX_MSGLEN];
|
|
MSG_Init( &msg, buf, sizeof(buf) );
|
|
MSG_Bitstream( &msg );
|
|
|
|
// NOTE, MRE: all server->client messages now acknowledge
|
|
MSG_WriteLong( &msg, clc.reliableSequence );
|
|
|
|
MSG_WriteByte( &msg, svc_gamestate );
|
|
MSG_WriteLong( &msg, clc.serverCommandSequence );
|
|
|
|
// configstrings
|
|
for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
|
|
if ( !cl.gameState.stringOffsets[i] )
|
|
continue;
|
|
MSG_WriteByte( &msg, svc_configstring );
|
|
MSG_WriteShort( &msg, i );
|
|
MSG_WriteBigString( &msg, cl.gameState.stringData + cl.gameState.stringOffsets[i] );
|
|
}
|
|
|
|
// baselines
|
|
entityState_t nullstate;
|
|
Com_Memset( &nullstate, 0, sizeof(nullstate) );
|
|
for ( i = 0; i < MAX_GENTITIES ; i++ ) {
|
|
entityState_t* ent = &cl.entityBaselines[i];
|
|
if (!ent->number)
|
|
continue;
|
|
MSG_WriteByte( &msg, svc_baseline );
|
|
MSG_WriteDeltaEntity( &msg, &nullstate, ent, qtrue );
|
|
}
|
|
|
|
MSG_WriteByte( &msg, svc_EOF ); // finished writing the gamestate stuff
|
|
|
|
MSG_WriteLong( &msg, clc.clientNum );
|
|
MSG_WriteLong( &msg, clc.checksumFeed );
|
|
|
|
MSG_WriteByte( &msg, svc_EOF ); // finished writing the client packet
|
|
|
|
int len;
|
|
// write it to the demo file
|
|
len = LittleLong( clc.serverMessageSequence - 1 );
|
|
FS_Write( &len, 4, clc.demofile );
|
|
|
|
len = LittleLong( msg.cursize );
|
|
FS_Write( &len, 4, clc.demofile );
|
|
FS_Write( msg.data, msg.cursize, clc.demofile );
|
|
|
|
// the rest of the demo file will be copied from net messages
|
|
}
|
|
|
|
|
|
static void CL_CompleteDemoRecord_f( int startArg, int compArg )
|
|
{
|
|
if ( startArg + 1 == compArg )
|
|
Field_AutoCompleteCustom( startArg, compArg, &Field_AutoCompleteDemoNameWrite );
|
|
}
|
|
|
|
|
|
/*
|
|
=======================================================================
|
|
|
|
CLIENT SIDE DEMO PLAYBACK
|
|
|
|
=======================================================================
|
|
*/
|
|
|
|
|
|
void CL_DemoCompleted()
|
|
{
|
|
if (cl_timedemo && cl_timedemo->integer) {
|
|
int time = Sys_Milliseconds() - clc.timeDemoStart;
|
|
if ( time > 0 ) {
|
|
Com_Printf ("%i frames, %3.1f seconds: %3.1f fps\n", clc.timeDemoFrames,
|
|
time/1000.0, clc.timeDemoFrames*1000.0 / time);
|
|
}
|
|
}
|
|
|
|
CL_Disconnect( qtrue );
|
|
CL_NextDemo();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CL_ReadDemoMessage
|
|
=================
|
|
*/
|
|
void CL_ReadDemoMessage( void ) {
|
|
|
|
if ( !clc.demofile ) {
|
|
CL_DemoCompleted();
|
|
return;
|
|
}
|
|
|
|
// get the sequence number
|
|
int s;
|
|
int r = FS_Read( &s, 4, clc.demofile);
|
|
if ( r != 4 ) {
|
|
CL_DemoCompleted();
|
|
return;
|
|
}
|
|
clc.serverMessageSequence = LittleLong( s );
|
|
|
|
msg_t buf;
|
|
byte bufData[ MAX_MSGLEN ];
|
|
// init the message
|
|
MSG_Init( &buf, bufData, sizeof( bufData ) );
|
|
|
|
// get the length
|
|
r = FS_Read (&buf.cursize, 4, clc.demofile);
|
|
if ( r != 4 ) {
|
|
CL_DemoCompleted();
|
|
return;
|
|
}
|
|
buf.cursize = LittleLong( buf.cursize );
|
|
if ( buf.cursize == -1 ) {
|
|
CL_DemoCompleted();
|
|
return;
|
|
}
|
|
if ( buf.cursize > buf.maxsize ) {
|
|
Com_Error (ERR_DROP, "CL_ReadDemoMessage: demoMsglen > MAX_MSGLEN");
|
|
}
|
|
r = FS_Read( buf.data, buf.cursize, clc.demofile );
|
|
if ( r != buf.cursize ) {
|
|
Com_Printf( "Demo file was truncated.\n");
|
|
CL_DemoCompleted();
|
|
return;
|
|
}
|
|
|
|
clc.lastPacketTime = cls.realtime;
|
|
buf.readcount = 0;
|
|
CL_ParseServerMessage( &buf );
|
|
}
|
|
|
|
|
|
static void CL_WalkDemoExt( const char* path, fileHandle_t* fh )
|
|
{
|
|
const int protocols[] = { 68, 67, 66 };
|
|
char fullPath[MAX_OSPATH];
|
|
|
|
*fh = 0;
|
|
|
|
if (Sys_IsAbsolutePath( path )) {
|
|
FS_FOpenAbsoluteRead( path, fh );
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < ARRAY_LEN(protocols); ++i) {
|
|
Com_sprintf( fullPath, sizeof( fullPath ), "demos/%s.dm_%d", path, protocols[i] );
|
|
FS_FOpenFileRead( fullPath, fh, qtrue );
|
|
if (*fh) {
|
|
Com_Printf( "Demo file: %s\n", fullPath );
|
|
return;
|
|
}
|
|
}
|
|
|
|
Com_Printf( "No match: demos/%s.dm_*\n", path );
|
|
}
|
|
|
|
|
|
static void CL_PlayDemo( qbool videoRestart )
|
|
{
|
|
if (Cmd_Argc() != 2) {
|
|
Com_Printf( "demo <demoname>\n" );
|
|
return;
|
|
}
|
|
|
|
const char* const demoPath = Cmd_Argv(1);
|
|
fileHandle_t fh;
|
|
CL_WalkDemoExt( demoPath, &fh );
|
|
if ( fh == 0 ) {
|
|
Com_Printf( "Couldn't open demo %s\n", demoPath );
|
|
CL_NextDemo();
|
|
return;
|
|
}
|
|
|
|
// CL_Disconnect uses the tokenizer, so we save the demo path now
|
|
char shortPath[MAX_OSPATH];
|
|
Q_strncpyz( shortPath, demoPath, sizeof( shortPath ) );
|
|
|
|
// CL_Disconnect closes clc.demofile, so we set it after the call
|
|
SV_Shutdown( "closing for demo playback" );
|
|
CL_Disconnect( qfalse );
|
|
clc.demofile = fh;
|
|
|
|
Q_strncpyz( clc.demoName, shortPath, sizeof( clc.demoName ) );
|
|
Con_Close();
|
|
cls.state = CA_CONNECTED;
|
|
clc.demoplaying = qtrue;
|
|
Q_strncpyz( cls.servername, shortPath, sizeof( cls.servername ) );
|
|
|
|
if ( cl_demoPlayer->integer ) {
|
|
while ( CL_MapDownload_Active() ) {
|
|
Sys_Sleep( 50 );
|
|
}
|
|
CL_NDP_PlayDemo( videoRestart );
|
|
return;
|
|
}
|
|
|
|
// read demo messages until connected
|
|
while ( cls.state >= CA_CONNECTED && cls.state < CA_PRIMED && !CL_MapDownload_Active() ) {
|
|
CL_ReadDemoMessage();
|
|
}
|
|
|
|
// don't get the first snapshot this frame, to prevent the long
|
|
// time from the gamestate load from messing causing a time skip
|
|
clc.firstDemoFrameSkipped = qfalse;
|
|
}
|
|
|
|
|
|
static void CL_CompleteDemoPlay_f( int startArg, int compArg )
|
|
{
|
|
if ( startArg + 1 == compArg )
|
|
Field_AutoCompleteCustom( startArg, compArg, &Field_AutoCompleteDemoNameRead );
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
CL_StartDemoLoop
|
|
|
|
Closing the main menu will restart the demo loop
|
|
====================
|
|
*/
|
|
void CL_StartDemoLoop( void ) {
|
|
// start the demo loop again
|
|
Cbuf_AddText ("d1\n");
|
|
cls.keyCatchers = 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
CL_NextDemo
|
|
|
|
Called when a demo or cinematic finishes
|
|
If the "nextdemo" cvar is set, that command will be issued
|
|
==================
|
|
*/
|
|
void CL_NextDemo( void ) {
|
|
char v[MAX_STRING_CHARS];
|
|
|
|
Q_strncpyz( v, Cvar_VariableString ("nextdemo"), sizeof(v) );
|
|
v[MAX_STRING_CHARS-1] = 0;
|
|
Com_DPrintf("CL_NextDemo: %s\n", v );
|
|
if (!v[0]) {
|
|
return;
|
|
}
|
|
|
|
Cvar_Set ("nextdemo","");
|
|
Cbuf_AddText (v);
|
|
Cbuf_AddText ("\n");
|
|
Cbuf_Execute();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
|
|
/*
|
|
=====================
|
|
CL_ShutdownAll
|
|
=====================
|
|
*/
|
|
void CL_ShutdownAll(void)
|
|
{
|
|
cls.fullClientShutDown = qtrue;
|
|
|
|
// clear sounds
|
|
S_DisableSounds();
|
|
// shutdown CGame
|
|
CL_ShutdownCGame();
|
|
// shutdown UI
|
|
CL_ShutdownUI();
|
|
|
|
// shutdown the renderer
|
|
if ( re.Shutdown ) {
|
|
re.Shutdown( qfalse );
|
|
}
|
|
|
|
cls.uiStarted = qfalse;
|
|
cls.cgameStarted = qfalse;
|
|
cls.rendererStarted = qfalse;
|
|
cls.soundRegistered = qfalse;
|
|
}
|
|
|
|
|
|
/*
|
|
Authorization server protocol
|
|
-----------------------------
|
|
|
|
All commands are text in Q3 out of band packets (leading 0xff 0xff 0xff 0xff).
|
|
|
|
Whenever the client tries to get a challenge from the server it wants to
|
|
connect to, it also blindly fires off a packet to the authorize server:
|
|
|
|
getKeyAuthorize <challenge> <cdkey>
|
|
|
|
cdkey may be "demo"
|
|
|
|
|
|
#OLD The authorize server returns a:
|
|
#OLD
|
|
#OLD keyAthorize <challenge> <accept | deny>
|
|
#OLD
|
|
#OLD A client will be accepted if the cdkey is valid and it has not been used by any other IP
|
|
#OLD address in the last 15 minutes.
|
|
|
|
|
|
The server sends a:
|
|
|
|
getIpAuthorize <challenge> <ip>
|
|
|
|
The authorize server returns a:
|
|
|
|
ipAuthorize <challenge> <accept | deny | demo | unknown >
|
|
|
|
A client will be accepted if a valid cdkey was sent by that ip (only) in the last 15 minutes.
|
|
If no response is received from the authorize server after two tries, the client will be let
|
|
in anyway.
|
|
*/
|
|
static void CL_RequestAuthorization()
|
|
{
|
|
char key[CDKEY_LEN + 1];
|
|
|
|
if ( !cls.authorizeServer.port ) {
|
|
Com_Printf( "Resolving %s\n", AUTHORIZE_SERVER_NAME );
|
|
if ( !NET_StringToAdr( AUTHORIZE_SERVER_NAME, &cls.authorizeServer ) ) {
|
|
Com_Printf( "Couldn't resolve address\n" );
|
|
return;
|
|
}
|
|
|
|
cls.authorizeServer.port = BigShort( PORT_AUTHORIZE );
|
|
Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", AUTHORIZE_SERVER_NAME,
|
|
cls.authorizeServer.ip[0], cls.authorizeServer.ip[1],
|
|
cls.authorizeServer.ip[2], cls.authorizeServer.ip[3],
|
|
BigShort( cls.authorizeServer.port ) );
|
|
}
|
|
if ( cls.authorizeServer.type == NA_BAD ) {
|
|
return;
|
|
}
|
|
|
|
int i;
|
|
for (i = 0; (i < CDKEY_LEN) && cl_cdkey[i]; ++i) {
|
|
// the cd key should have already been checked for validity, but just in case:
|
|
if ( ( cl_cdkey[i] >= '0' && cl_cdkey[i] <= '9' )
|
|
|| ( cl_cdkey[i] >= 'a' && cl_cdkey[i] <= 'z' )
|
|
|| ( cl_cdkey[i] >= 'A' && cl_cdkey[i] <= 'Z' )
|
|
) {
|
|
key[i] = cl_cdkey[i];
|
|
} else {
|
|
Com_Error( ERR_DROP, "Invalid CD Key" );
|
|
}
|
|
}
|
|
key[i] = 0;
|
|
|
|
int anonymous = 0; // previously set by cl_anonymous
|
|
NET_OutOfBandPrint( NS_CLIENT, cls.authorizeServer, va("getKeyAuthorize %i %s", anonymous, key) );
|
|
}
|
|
|
|
|
|
// resend a connect message if the last one has timed out
|
|
|
|
static void CL_CheckForResend()
|
|
{
|
|
// don't send anything if playing back a demo
|
|
if ( clc.demoplaying ) {
|
|
return;
|
|
}
|
|
|
|
// resend if we haven't gotten a reply yet
|
|
if ( cls.state != CA_CONNECTING && cls.state != CA_CHALLENGING ) {
|
|
return;
|
|
}
|
|
|
|
if ( cls.realtime - clc.connectTime < RETRANSMIT_TIMEOUT ) {
|
|
return;
|
|
}
|
|
|
|
clc.connectTime = cls.realtime; // for retransmit requests
|
|
clc.connectPacketCount++;
|
|
|
|
|
|
switch ( cls.state ) {
|
|
case CA_CONNECTING:
|
|
// requesting a challenge
|
|
if ( !Sys_IsLANAddress( clc.serverAddress ) ) {
|
|
CL_RequestAuthorization();
|
|
}
|
|
NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "getchallenge");
|
|
break;
|
|
|
|
case CA_CHALLENGING:
|
|
{
|
|
int port, i;
|
|
|
|
char info[MAX_INFO_STRING];
|
|
char data[MAX_INFO_STRING];
|
|
// sending back the challenge
|
|
port = Cvar_VariableIntegerValue ("net_qport");
|
|
|
|
Q_strncpyz( info, Cvar_InfoString( CVAR_USERINFO ), sizeof( info ) );
|
|
Info_SetValueForKey( info, "protocol", va("%i", PROTOCOL_VERSION ) );
|
|
Info_SetValueForKey( info, "qport", va("%i", port ) );
|
|
Info_SetValueForKey( info, "challenge", va("%i", clc.challenge ) );
|
|
|
|
strcpy(data, "connect ");
|
|
// TTimo adding " " around the userinfo string to avoid truncated userinfo on the server
|
|
// (Com_TokenizeString tokenizes around spaces)
|
|
data[8] = '"';
|
|
|
|
for(i=0;i<strlen(info);i++) {
|
|
data[9+i] = info[i]; // + (clc.challenge)&0x3;
|
|
}
|
|
data[9+i] = '"';
|
|
data[10+i] = 0;
|
|
|
|
NET_OutOfBandData( NS_CLIENT, clc.serverAddress, (byte *) &data[0], i+10 );
|
|
// the most current userinfo has been sent, so watch for any
|
|
// newer changes to userinfo variables
|
|
cvar_modifiedFlags &= ~CVAR_USERINFO;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Com_Error( ERR_FATAL, "CL_CheckForResend: bad cls.state" );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Called by CL_MapLoading, CL_Connect_f, CL_PlayDemo_f, and CL_ParseGamestate, the only
|
|
ways a client gets into a game
|
|
Also called by Com_Error
|
|
*/
|
|
void CL_FlushMemory()
|
|
{
|
|
// shutdown all the client stuff
|
|
CL_ShutdownAll();
|
|
|
|
// if not running a server clear the whole hunk
|
|
if ( !com_sv_running->integer ) {
|
|
// clear the whole hunk
|
|
Hunk_Clear();
|
|
// clear collision map data
|
|
CM_ClearMap();
|
|
}
|
|
else {
|
|
// clear all the client data on the hunk
|
|
Hunk_ClearToMark();
|
|
}
|
|
|
|
CL_StartHunkUsers();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
CL_MapLoading
|
|
|
|
A local server is starting to load a map, so update the
|
|
screen to let the user know about it, then dump all client
|
|
memory on the hunk from cgame, ui, and renderer
|
|
=====================
|
|
*/
|
|
void CL_MapLoading( void ) {
|
|
if ( !com_cl_running->integer ) {
|
|
return;
|
|
}
|
|
|
|
Con_Close();
|
|
cls.keyCatchers = 0;
|
|
|
|
// if we are already connected to the local host, stay connected
|
|
if ( cls.state >= CA_CONNECTED && !Q_stricmp( cls.servername, "localhost" ) ) {
|
|
cls.state = CA_CONNECTED; // so the connect screen is drawn
|
|
Com_Memset( cls.updateInfoString, 0, sizeof( cls.updateInfoString ) );
|
|
Com_Memset( clc.serverMessage, 0, sizeof( clc.serverMessage ) );
|
|
Com_Memset( &cl.gameState, 0, sizeof( cl.gameState ) );
|
|
clc.lastPacketSentTime = -9999;
|
|
SCR_UpdateScreen();
|
|
} else {
|
|
CL_Disconnect( qtrue );
|
|
Q_strncpyz( cls.servername, "localhost", sizeof(cls.servername) );
|
|
cls.state = CA_CHALLENGING; // so the connect screen is drawn
|
|
cls.keyCatchers = 0;
|
|
SCR_UpdateScreen();
|
|
clc.connectTime = -RETRANSMIT_TIMEOUT;
|
|
NET_StringToAdr( cls.servername, &clc.serverAddress);
|
|
// we don't need a challenge on the localhost
|
|
|
|
CL_CheckForResend();
|
|
}
|
|
}
|
|
|
|
|
|
// called before parsing a gamestate
|
|
|
|
void CL_ClearState()
|
|
{
|
|
//S_StopAllSounds();
|
|
Com_Memset( &cl, 0, sizeof( cl ) );
|
|
}
|
|
|
|
|
|
/*
|
|
=====================
|
|
CL_Disconnect
|
|
|
|
Called when a connection, demo, or cinematic is being terminated.
|
|
Goes from a connected state to either a menu state or a console state
|
|
Sends a disconnect message to the server
|
|
This is also called on Com_Error and Com_Quit, so it shouldn't cause any errors
|
|
=====================
|
|
*/
|
|
void CL_Disconnect( qbool showMainMenu ) {
|
|
if ( !com_cl_running || !com_cl_running->integer ) {
|
|
return;
|
|
}
|
|
|
|
// shutting down the client so enter full screen ui mode
|
|
Cvar_Set("r_uiFullScreen", "1");
|
|
|
|
if ( clc.demorecording ) {
|
|
CL_StopRecord_f ();
|
|
}
|
|
|
|
if (clc.download) {
|
|
FS_FCloseFile( clc.download );
|
|
clc.download = 0;
|
|
}
|
|
*clc.downloadTempName = *clc.downloadName = 0;
|
|
Cvar_Set( "cl_downloadName", "" );
|
|
|
|
if ( clc.demofile ) {
|
|
FS_FCloseFile( clc.demofile );
|
|
clc.demofile = 0;
|
|
}
|
|
clc.demoplaying = qfalse;
|
|
|
|
if ( uivm && showMainMenu ) {
|
|
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_NONE );
|
|
}
|
|
|
|
SCR_StopCinematic ();
|
|
S_ClearSoundBuffer();
|
|
|
|
// send a disconnect message to the server
|
|
// send it a few times in case one is dropped
|
|
if ( cls.state >= CA_CONNECTED ) {
|
|
CL_AddReliableCommand( "disconnect" );
|
|
CL_WritePacket();
|
|
CL_WritePacket();
|
|
CL_WritePacket();
|
|
}
|
|
|
|
CL_ClearState();
|
|
|
|
// wipe the client connection
|
|
Com_Memset( &clc, 0, sizeof( clc ) );
|
|
|
|
cls.state = CA_DISCONNECTED;
|
|
|
|
// allow cheats locally
|
|
Cvar_Set( "sv_cheats", "1" );
|
|
|
|
// not connected to a pure server anymore
|
|
cl_connectedToPureServer = qfalse;
|
|
|
|
// let the FS know we're not connected to a pure server
|
|
// and clear all pak references except to the game QVM
|
|
FS_PureServerSetLoadedPaks( "" );
|
|
FS_PureServerSetReferencedPaks( "", "" );
|
|
FS_ClearPakReferences( FS_CGAME_REF | FS_UI_REF | FS_GENERAL_REF );
|
|
|
|
// Stop recording any video
|
|
CL_CloseAVI();
|
|
}
|
|
|
|
|
|
/*
|
|
adds the current command line as a clientCommand
|
|
things like godmode, noclip, etc, are commands directed to the server,
|
|
so when they are typed in at the console, they will need to be forwarded.
|
|
*/
|
|
void CL_ForwardCommandToServer( const char *string )
|
|
{
|
|
const char* cmd = Cmd_Argv(0);
|
|
|
|
// ignore key up commands
|
|
if ( cmd[0] == '-' ) {
|
|
return;
|
|
}
|
|
|
|
if ( clc.demoplaying || cls.state < CA_CONNECTED || cmd[0] == '+' ) {
|
|
Com_Printf ("Unknown command \"%s\"\n", cmd);
|
|
return;
|
|
}
|
|
|
|
if ( Cmd_Argc() > 1 ) {
|
|
CL_AddReliableCommand( string );
|
|
} else {
|
|
CL_AddReliableCommand( cmd );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
======================================================================
|
|
|
|
CONSOLE COMMANDS
|
|
|
|
======================================================================
|
|
*/
|
|
|
|
|
|
static void CL_ForwardToServer_f()
|
|
{
|
|
if ( cls.state != CA_ACTIVE || clc.demoplaying ) {
|
|
Com_Printf ("Not connected to a server.\n");
|
|
return;
|
|
}
|
|
// don't forward the first argument
|
|
if ( Cmd_Argc() > 1 ) {
|
|
CL_AddReliableCommand( Cmd_Args() );
|
|
}
|
|
}
|
|
|
|
|
|
void CL_Disconnect_f( void )
|
|
{
|
|
SCR_StopCinematic();
|
|
if ( cls.state != CA_DISCONNECTED && cls.state != CA_CINEMATIC ) {
|
|
Com_ErrorExt( ERR_DISCONNECT, EXT_ERRMOD_ENGINE, qfalse, "Disconnected from server" );
|
|
}
|
|
}
|
|
|
|
|
|
static void CL_Reconnect( qbool whileConnectingToProxy )
|
|
{
|
|
if ( !strlen( cls.servername ) || !strcmp( cls.servername, "localhost" ) ) {
|
|
Com_Printf( "Can't reconnect to localhost.\n" );
|
|
return;
|
|
}
|
|
|
|
// Reconnecting via the same proxy doesn't seem to work with QWFWD
|
|
// ("illegible server message" drop error),
|
|
// so we disconnect and wait a bit first to make it work.
|
|
// One second seems to work well enough but let's pad it a bit.
|
|
if ( !whileConnectingToProxy &&
|
|
net_proxy->string[0] != '\0' &&
|
|
!Q_stricmp( net_proxy->string, cls.proxyname ) ) {
|
|
Cbuf_AddText( va( "disconnect\nwaitms 1500\nconnect %s\n", cls.servername ) );
|
|
} else {
|
|
Cbuf_AddText( va( "connect %s\n", cls.servername ) );
|
|
}
|
|
}
|
|
|
|
|
|
static void CL_Reconnect_f()
|
|
{
|
|
CL_Reconnect( qfalse );
|
|
}
|
|
|
|
|
|
static void CL_Connect_f()
|
|
{
|
|
if ( Cmd_Argc() != 2 ) {
|
|
Com_Printf( "usage: connect <server>\n");
|
|
return;
|
|
}
|
|
|
|
// clear any previous "server full" type messages
|
|
clc.serverMessage[0] = 0;
|
|
|
|
const char* const requestedAddress = Cmd_Argv(1);
|
|
const char* connectionAddress = requestedAddress;
|
|
|
|
// ye old switcheroo
|
|
if ( net_proxy->string[0] != '\0' && Q_stricmp( net_proxy->string, requestedAddress ) != 0 ) {
|
|
Cvar_Get( "prx", requestedAddress, CVAR_USERINFO );
|
|
Cvar_Set( "prx", requestedAddress );
|
|
connectionAddress = net_proxy->string;
|
|
Q_strncpyz( cls.proxyname, net_proxy->string, sizeof(cls.proxyname) );
|
|
} else {
|
|
// it's not really necessary but it's nice to reflect the changes
|
|
Cvar_Get( "prx", "", CVAR_USERINFO );
|
|
Cvar_Set( "prx", "" );
|
|
cls.proxyname[0] = '\0';
|
|
}
|
|
|
|
if ( com_sv_running->integer && !strcmp( requestedAddress, "localhost" ) ) {
|
|
// if running a local server, kill it
|
|
SV_Shutdown( "Server quit" );
|
|
}
|
|
|
|
// make sure a local server is killed
|
|
Cvar_Set( "sv_killserver", "1" );
|
|
SV_Frame( 0 );
|
|
|
|
CL_Disconnect( qtrue );
|
|
Con_Close();
|
|
|
|
Q_strncpyz( cls.servername, requestedAddress, sizeof(cls.servername) );
|
|
|
|
if (!NET_StringToAdr( connectionAddress, &clc.serverAddress) ) {
|
|
Com_Printf ("Bad server address\n");
|
|
cls.state = CA_DISCONNECTED;
|
|
return;
|
|
}
|
|
if (clc.serverAddress.port == 0) {
|
|
clc.serverAddress.port = BigShort( PORT_SERVER );
|
|
}
|
|
Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", connectionAddress,
|
|
clc.serverAddress.ip[0], clc.serverAddress.ip[1],
|
|
clc.serverAddress.ip[2], clc.serverAddress.ip[3],
|
|
BigShort( clc.serverAddress.port ) );
|
|
|
|
// if we aren't playing on a lan, we need to authenticate
|
|
// with the cd key
|
|
if ( NET_IsLocalAddress( clc.serverAddress ) ) {
|
|
cls.state = CA_CHALLENGING;
|
|
} else {
|
|
cls.state = CA_CONNECTING;
|
|
}
|
|
|
|
cls.keyCatchers = 0;
|
|
clc.connectTime = -99999; // CL_CheckForResend() will fire immediately
|
|
clc.connectPacketCount = 0;
|
|
|
|
// server connection string
|
|
Cvar_Set( "cl_currentServerAddress", connectionAddress );
|
|
}
|
|
|
|
|
|
#define MAX_RCON_MESSAGE 1024
|
|
|
|
// send the rest of the command line over as an unconnected command
|
|
|
|
static void CL_Rcon_f( void )
|
|
{
|
|
if ( !rconPassword->string ) {
|
|
Com_Printf ("You must set 'rconpassword' before\n"
|
|
"issuing an rcon command.\n");
|
|
return;
|
|
}
|
|
|
|
char message[MAX_RCON_MESSAGE];
|
|
message[0] = -1;
|
|
message[1] = -1;
|
|
message[2] = -1;
|
|
message[3] = -1;
|
|
message[4] = 0;
|
|
|
|
Q_strcat (message, MAX_RCON_MESSAGE, "rcon ");
|
|
|
|
Q_strcat (message, MAX_RCON_MESSAGE, rconPassword->string);
|
|
Q_strcat (message, MAX_RCON_MESSAGE, " ");
|
|
|
|
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=543
|
|
Q_strcat (message, MAX_RCON_MESSAGE, Cmd_Cmd()+5);
|
|
|
|
netadr_t to;
|
|
if ( cls.state >= CA_CONNECTED ) {
|
|
to = clc.netchan.remoteAddress;
|
|
} else {
|
|
if (!strlen(rconAddress->string)) {
|
|
Com_Printf ("You must either be connected,\n"
|
|
"or set the 'rconAddress' cvar\n"
|
|
"to issue rcon commands\n");
|
|
|
|
return;
|
|
}
|
|
NET_StringToAdr (rconAddress->string, &to);
|
|
if (to.port == 0) {
|
|
to.port = BigShort (PORT_SERVER);
|
|
}
|
|
}
|
|
|
|
NET_SendPacket (NS_CLIENT, strlen(message)+1, message, to);
|
|
}
|
|
|
|
|
|
static void CL_CompleteRcon_f( int startArg, int compArg )
|
|
{
|
|
if ( startArg < compArg )
|
|
Field_AutoCompleteFrom( startArg + 1, compArg, qtrue, qtrue );
|
|
}
|
|
|
|
|
|
// if we are pure we need to send back a command with our referenced pk3 checksums
|
|
|
|
static void CL_SendPureChecksums()
|
|
{
|
|
char cMsg[MAX_INFO_VALUE];
|
|
Com_sprintf( cMsg, sizeof(cMsg), "cp " );
|
|
Q_strcat( cMsg, sizeof(cMsg), va("%d ", cl.serverId) );
|
|
Q_strcat( cMsg, sizeof(cMsg), FS_ReferencedPakPureChecksums() );
|
|
CL_AddReliableCommand( cMsg );
|
|
}
|
|
|
|
|
|
static void CL_ResetPureClientAtServer()
|
|
{
|
|
CL_AddReliableCommand( "vdr" );
|
|
}
|
|
|
|
|
|
static void CL_ReferencedPK3List_f( void )
|
|
{
|
|
Com_Printf( "Referenced PK3 Names: %s\n", FS_ReferencedPakNames() );
|
|
}
|
|
|
|
|
|
static void CL_Configstrings_f( void )
|
|
{
|
|
int i;
|
|
int ofs;
|
|
|
|
if ( cls.state != CA_ACTIVE ) {
|
|
Com_Printf( "Not connected to a server.\n");
|
|
return;
|
|
}
|
|
|
|
for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
|
|
ofs = cl.gameState.stringOffsets[ i ];
|
|
if ( !ofs ) {
|
|
continue;
|
|
}
|
|
Com_Printf( "%4i: %s\n", i, cl.gameState.stringData + ofs );
|
|
}
|
|
}
|
|
|
|
|
|
static void CL_Clientinfo_f( void )
|
|
{
|
|
Com_Printf( "--------- Client Information ---------\n" );
|
|
Com_Printf( "state: %i\n", cls.state );
|
|
Com_Printf( "Server: %s\n", cls.servername );
|
|
Com_Printf( "User info settings:\n" );
|
|
Info_Print( Cvar_InfoString_Big( CVAR_USERINFO ) ); // 1024 chars + 'userinfo '
|
|
Com_Printf( "--------------------------------------\n" );
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
|
|
void CL_DownloadsComplete()
|
|
{
|
|
// if we downloaded files we need to restart the file system
|
|
if (clc.downloadRestart) {
|
|
clc.downloadRestart = qfalse;
|
|
|
|
FS_Restart(clc.checksumFeed); // we possibly downloaded a pak, restart the file system to load it
|
|
|
|
// inform the server so we get new gamestate info
|
|
CL_AddReliableCommand( "donedl" );
|
|
|
|
// by sending the donedl command we request a new gamestate
|
|
// so we don't want to load stuff yet
|
|
return;
|
|
}
|
|
|
|
// let the client game init and load data
|
|
cls.state = CA_LOADING;
|
|
|
|
// Pump the loop, this may change gamestate!
|
|
Com_EventLoop();
|
|
|
|
// if the gamestate was changed by calling Com_EventLoop
|
|
// then we loaded everything already and we don't want to do it again.
|
|
if ( cls.state != CA_LOADING ) {
|
|
return;
|
|
}
|
|
|
|
// starting to load a map so we get out of full screen ui mode
|
|
Cvar_Set("r_uiFullScreen", "0");
|
|
|
|
// flush client memory and start loading stuff
|
|
// this will also (re)load the UI
|
|
// if this is a local client then only the client part of the hunk
|
|
// will be cleared, note that this is done after the hunk mark has been set
|
|
CL_FlushMemory();
|
|
|
|
// initialize the CGame
|
|
cls.cgameStarted = qtrue;
|
|
CL_InitCGame();
|
|
|
|
// set pure checksums
|
|
CL_SendPureChecksums();
|
|
|
|
CL_WritePacket();
|
|
CL_WritePacket();
|
|
CL_WritePacket();
|
|
}
|
|
|
|
|
|
// requests a file to download from the server
|
|
// stores it in the current game directory
|
|
|
|
static void CL_BeginDownload( const char *localName, const char *remoteName )
|
|
{
|
|
Com_DPrintf("***** CL_BeginDownload *****\n"
|
|
"Localname: %s\n"
|
|
"Remotename: %s\n"
|
|
"****************************\n", localName, remoteName);
|
|
|
|
Q_strncpyz ( clc.downloadName, localName, sizeof(clc.downloadName) );
|
|
Com_sprintf( clc.downloadTempName, sizeof(clc.downloadTempName), "%s.tmp", localName );
|
|
|
|
// Set so UI gets access to it
|
|
Cvar_Set( "cl_downloadName", remoteName );
|
|
Cvar_Set( "cl_downloadSize", "0" );
|
|
Cvar_Set( "cl_downloadCount", "0" );
|
|
Cvar_SetValue( "cl_downloadTime", cls.realtime );
|
|
|
|
clc.downloadBlock = 0;
|
|
clc.downloadCount = 0;
|
|
|
|
CL_AddReliableCommand( va("download %s", remoteName) );
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
CL_NextDownload
|
|
|
|
A download completed or failed
|
|
=================
|
|
*/
|
|
void CL_NextDownload(void) {
|
|
char *s;
|
|
char *remoteName, *localName;
|
|
|
|
// We are looking to start a download here
|
|
if (*clc.downloadList) {
|
|
s = clc.downloadList;
|
|
|
|
// format is:
|
|
// @remotename@localname@remotename@localname, etc.
|
|
|
|
if (*s == '@')
|
|
s++;
|
|
remoteName = s;
|
|
|
|
if ( (s = strchr(s, '@')) == NULL ) {
|
|
CL_DownloadsComplete();
|
|
return;
|
|
}
|
|
|
|
*s++ = 0;
|
|
localName = s;
|
|
if ( (s = strchr(s, '@')) != NULL )
|
|
*s++ = 0;
|
|
else
|
|
s = localName + strlen(localName); // point at the nul byte
|
|
|
|
if( cl_allowDownload->integer != -1 ) {
|
|
Com_Error(ERR_DROP, "The id download system is disabled (cl_allowDownload must be -1)");
|
|
return;
|
|
} else {
|
|
CL_BeginDownload( localName, remoteName );
|
|
}
|
|
|
|
clc.downloadRestart = qtrue;
|
|
|
|
// move over the rest
|
|
memmove( clc.downloadList, s, strlen(s) + 1);
|
|
|
|
return;
|
|
}
|
|
|
|
CL_DownloadsComplete();
|
|
}
|
|
|
|
|
|
// qtrue if found in either "$(fs_gamedir)" or in "baseq3"
|
|
static qbool MapDL_FileExists( const char* path )
|
|
{
|
|
return FS_FileExistsEx( path, qtrue ) || FS_FileExistsEx( path, qfalse );
|
|
}
|
|
|
|
|
|
// returns qtrue if a download started
|
|
static qbool CL_StartDownloads()
|
|
{
|
|
static unsigned int pakChecksums[MAX_PAKFILES];
|
|
|
|
// never launch a download when starting a listen server...
|
|
if (com_sv_running->integer)
|
|
return qfalse;
|
|
|
|
// note that CL_SystemInfoChanged won't change our local values of "sv_pure" and "sv_currentPak",
|
|
// so we have to read them from the server's gamestate data
|
|
char mapName[MAX_NAME_LENGTH];
|
|
char mapPath[MAX_NAME_LENGTH];
|
|
const char* const systemInfo = cl.gameState.stringData + cl.gameState.stringOffsets[CS_SYSTEMINFO];
|
|
const char* const serverInfo = cl.gameState.stringData + cl.gameState.stringOffsets[CS_SERVERINFO];
|
|
const qbool pureServer = atoi(Info_ValueForKey(systemInfo, "sv_pure")) == 1;
|
|
const qbool exactMatch = !clc.demoplaying && pureServer;
|
|
Q_strncpyz(mapName, Info_ValueForKey(serverInfo, "mapname"), sizeof(mapName));
|
|
Q_strncpyz(mapPath, va("maps/%s.bsp", mapName), sizeof(mapPath));
|
|
const int mode = cl_allowDownload->integer;
|
|
unsigned int pakChecksum = 0;
|
|
if (sscanf(Info_ValueForKey(serverInfo, "sv_currentPak"), "%d", &pakChecksum) != 1)
|
|
pakChecksum = 0;
|
|
|
|
// downloads disabled
|
|
if (mode == 0) {
|
|
if (exactMatch && pakChecksum != 0) {
|
|
// don't allow connections to pure CNQ3 servers if we don't have the right file
|
|
int pakCount;
|
|
FS_MissingPaks(pakChecksums, &pakCount, ARRAY_LEN(pakChecksums));
|
|
for (int i = 0; i < pakCount; ++i) {
|
|
if (pakChecksums[i] == pakChecksum) {
|
|
Com_Printf("\nERROR: You are missing the PK3 file the pure server has loaded the current map from. "
|
|
"To enable downloads, set cl_allowDownload to 1 (new) or -1 (old).\n\n");
|
|
Com_Error(ERR_DROP, "Missing map! Try cl_allowDownload 1");
|
|
break;
|
|
}
|
|
}
|
|
} else if (exactMatch) {
|
|
// we can't be sure whether we're about to break sv_pure or not :-(
|
|
// it's possible that some referenced files on the server are missing
|
|
char missingfiles[1024];
|
|
if (FS_ComparePaks(missingfiles, sizeof(missingfiles), qfalse)) {
|
|
// NOTE TTimo I would rather have that printed as a modal message box
|
|
// but at this point while joining the game we don't know whether we will successfully join or not
|
|
Com_Printf("\nWARNING: You are missing some files referenced by the server:\n%s\n"
|
|
"To enable downloads, set cl_allowDownload to 1 (new) or -1 (old)\n\n", missingfiles);
|
|
}
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
// legacy id downloads
|
|
if (mode == -1) {
|
|
if (FS_ComparePaks(clc.downloadList, sizeof(clc.downloadList), qtrue)) {
|
|
Com_Printf("Need paks: %s\n", clc.downloadList);
|
|
if (*clc.downloadList) {
|
|
cls.state = CA_CONNECTED;
|
|
CL_NextDownload();
|
|
return qtrue;
|
|
}
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
//
|
|
// CNQ3 downloads
|
|
//
|
|
|
|
// handle the non-exact case first
|
|
if (!exactMatch) {
|
|
// if we have something of the same name, we're good (enough)
|
|
if (FS_FileIsInPAK(mapPath, NULL, NULL) || MapDL_FileExists(mapPath))
|
|
return qfalse;
|
|
|
|
// if we don't, we look for anything of the same name
|
|
if (CL_MapDownload_Start(mapName, qfalse)) {
|
|
cls.state = CA_CONNECTED;
|
|
return qtrue;
|
|
}
|
|
|
|
// the above code will trigger a drop error if it fails
|
|
return qfalse;
|
|
}
|
|
|
|
// let's first see if we can assume we have the right file
|
|
if (pakChecksum != 0) {
|
|
// CNQ3 pure server: we can directly look for a specific pak file and be 100% sure
|
|
if (FS_PakExists(pakChecksum)) {
|
|
return qfalse;
|
|
}
|
|
} else {
|
|
// other server: no way to 100% prove we have the pak file the server loaded the map from,
|
|
// unless we make sure we have every single pak file the server has...
|
|
|
|
// let's suppose we have the following scenario:
|
|
// - the server has bad_a.pk3 and bad_b.pk3 in baseq3
|
|
// - both paks contains "maps/bad.bsp"
|
|
// - bad_a.pk3 and bad_b.pk3 are different files with different (Quake 3 FS) checksums
|
|
// - the server loads the map "bad" from bad_b.pk3 because of search path ordering
|
|
// - the client only has bad_a.pk3 and tries to connect
|
|
// - the client decides everything is fine and connects anyway... oops
|
|
|
|
// This happens with the original quake3.exe too and is a design flaw of the pure system.
|
|
// The alternative is for the client to decide not to connect whenever a single pak is missing,
|
|
// but that's just going to unjustifiably antagonize users for the sake of an infrequent issue.
|
|
// Server owners forgetting to delete old paks certainly isn't rare, however.
|
|
// The simplest solutions are diligence and having servers check and warn about duplicate maps.
|
|
if (FS_FileIsInPAK(mapPath, NULL, NULL))
|
|
return qfalse;
|
|
}
|
|
|
|
// generate a checksum list of all the pure paks we're missing
|
|
int pakCount;
|
|
if (pakChecksum != 0) {
|
|
pakChecksums[0] = pakChecksum;
|
|
pakCount = 1;
|
|
} else {
|
|
FS_MissingPaks(pakChecksums, &pakCount, ARRAY_LEN(pakChecksums));
|
|
}
|
|
|
|
if (pakCount > 0) {
|
|
const qbool dlStarted = pakCount == 1 ?
|
|
// we know exactly which pk3 we need, we don't send a map name to the server
|
|
// (but we use one for error messages)
|
|
CL_PakDownload_Start(pakChecksums[0], qfalse, mapName) :
|
|
// we send the map's name and a list of pk3 checksums (qmd4) to the server
|
|
CL_MapDownload_Start_PakChecksums(mapName, pakChecksums, pakCount, exactMatch);
|
|
|
|
if (dlStarted) {
|
|
cls.state = CA_CONNECTED;
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
CL_InitDownloads
|
|
|
|
After receiving a valid game state, we valid the cgame and local zip files here
|
|
and determine if we need to download them
|
|
=================
|
|
*/
|
|
void CL_InitDownloads(void) {
|
|
|
|
if(!CL_StartDownloads())
|
|
{
|
|
CL_DownloadsComplete();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Sometimes the server can drop the client and the netchan based
|
|
disconnect can be lost. If the client continues to send packets
|
|
to the server, the server will send out of band disconnect packets
|
|
to the client so it doesn't have to wait for the full timeout period.
|
|
*/
|
|
static void CL_DisconnectPacket( const netadr_t& from )
|
|
{
|
|
if ( cls.state < CA_AUTHORIZING ) {
|
|
return;
|
|
}
|
|
|
|
// if not from our server, ignore it
|
|
if ( !NET_CompareAdr( from, clc.netchan.remoteAddress ) ) {
|
|
return;
|
|
}
|
|
|
|
// if we have received packets within three seconds, ignore it
|
|
// (it might be a malicious spoof)
|
|
if ( cls.realtime - clc.lastPacketTime < 3000 ) {
|
|
return;
|
|
}
|
|
|
|
// drop the connection
|
|
Com_Printf( "Server disconnected for unknown reason\n" );
|
|
Cvar_Set("com_errorMessage", "Server disconnected for unknown reason\n" );
|
|
CL_Disconnect( qtrue );
|
|
}
|
|
|
|
|
|
// responses to broadcasts, etc
|
|
|
|
static void CL_ConnectionlessPacket( const netadr_t& from, msg_t* msg )
|
|
{
|
|
MSG_BeginReadingOOB( msg );
|
|
MSG_ReadLong( msg ); // skip the -1
|
|
|
|
char* s = MSG_ReadStringLine( msg );
|
|
Cmd_TokenizeString( s );
|
|
|
|
const char* c = Cmd_Argv(0);
|
|
Com_DPrintf ("CL packet %s: %s\n", NET_AdrToString(from), c);
|
|
|
|
// challenge from the server we are connecting to
|
|
if ( !Q_stricmp(c, "challengeResponse") ) {
|
|
if ( cls.state != CA_CONNECTING ) {
|
|
Com_Printf( "Unwanted challenge response received. Ignored.\n" );
|
|
} else {
|
|
// start sending challenge repsonse instead of challenge request packets
|
|
clc.challenge = atoi(Cmd_Argv(1));
|
|
cls.state = CA_CHALLENGING;
|
|
clc.connectPacketCount = 0;
|
|
clc.connectTime = -99999;
|
|
|
|
// take this address as the new server address. This allows
|
|
// a server proxy to hand off connections to multiple servers
|
|
clc.serverAddress = from;
|
|
Com_DPrintf ("challengeResponse: %d\n", clc.challenge);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// server connection
|
|
if ( !Q_stricmp(c, "connectResponse") ) {
|
|
if ( cls.state >= CA_CONNECTED ) {
|
|
Com_Printf ("Dup connect received. Ignored.\n");
|
|
return;
|
|
}
|
|
if ( cls.state != CA_CHALLENGING ) {
|
|
Com_Printf ("connectResponse packet while not connecting. Ignored.\n");
|
|
return;
|
|
}
|
|
if ( !NET_CompareBaseAdr( from, clc.serverAddress ) ) {
|
|
Com_Printf( "connectResponse from a different address. Ignored.\n" );
|
|
Com_Printf( "%s should have been %s\n", NET_AdrToString( from ),
|
|
NET_AdrToString( clc.serverAddress ) );
|
|
return;
|
|
}
|
|
Netchan_Setup (NS_CLIENT, &clc.netchan, from, Cvar_VariableIntegerValue( "net_qport" ) );
|
|
cls.state = CA_CONNECTED;
|
|
clc.lastPacketSentTime = -9999; // send first packet immediately
|
|
return;
|
|
}
|
|
|
|
// server responding to an info broadcast
|
|
if ( !Q_stricmp(c, "infoResponse") ) {
|
|
CL_ServerInfoPacket( from, msg );
|
|
return;
|
|
}
|
|
|
|
// server responding to a get playerlist
|
|
if ( !Q_stricmp(c, "statusResponse") ) {
|
|
CL_ServerStatusResponse( from, msg );
|
|
return;
|
|
}
|
|
|
|
// a disconnect message from the server, which will happen if the server
|
|
// dropped the connection but it is still getting packets from us
|
|
if (!Q_stricmp(c, "disconnect")) {
|
|
CL_DisconnectPacket( from );
|
|
return;
|
|
}
|
|
|
|
// echo request from server
|
|
if ( !Q_stricmp(c, "echo") ) {
|
|
NET_OutOfBandPrint( NS_CLIENT, from, "%s", Cmd_Argv(1) );
|
|
return;
|
|
}
|
|
|
|
// cd check
|
|
if ( !Q_stricmp(c, "keyAuthorize") ) {
|
|
// we don't use these now, so dump them on the floor
|
|
return;
|
|
}
|
|
|
|
// global MOTD from id
|
|
if ( !Q_stricmp(c, "motd") ) {
|
|
return;
|
|
}
|
|
|
|
// echo request from server
|
|
if ( !Q_stricmp(c, "print") ) {
|
|
s = MSG_ReadString( msg );
|
|
Q_strncpyz( clc.serverMessage, s, sizeof( clc.serverMessage ) );
|
|
Com_Printf( "%s", s );
|
|
if ( !Q_stricmpn(s, "/reconnect ASAP!", 16) ) {
|
|
CL_Reconnect( qtrue );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// echo request from server
|
|
if ( !Q_strncmp(c, "getserversResponse", 18) ) {
|
|
CL_ServersResponsePacket( from, msg );
|
|
return;
|
|
}
|
|
|
|
Com_DPrintf ("Unknown connectionless packet command.\n");
|
|
}
|
|
|
|
|
|
// a packet has arrived from the main event loop
|
|
|
|
void CL_PacketEvent( netadr_t from, msg_t* msg )
|
|
{
|
|
clc.lastPacketTime = cls.realtime;
|
|
|
|
if ( msg->cursize >= 4 && *(int *)msg->data == -1 ) {
|
|
CL_ConnectionlessPacket( from, msg );
|
|
return;
|
|
}
|
|
|
|
if ( cls.state < CA_CONNECTED ) {
|
|
return; // can't be a valid sequenced packet
|
|
}
|
|
|
|
if ( msg->cursize < 4 ) {
|
|
Com_Printf( "%s: Runt packet\n", NET_AdrToString( from ) );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// packet from server
|
|
//
|
|
if ( !NET_CompareAdr( from, clc.netchan.remoteAddress ) ) {
|
|
Com_DPrintf( "%s:sequenced packet without connection\n", NET_AdrToString( from ) );
|
|
// FIXME: send a client disconnect?
|
|
return;
|
|
}
|
|
|
|
if (!CL_Netchan_Process( &clc.netchan, msg )) {
|
|
return; // out of order, duplicated, etc
|
|
}
|
|
|
|
// the header is different lengths for reliable and unreliable messages
|
|
int headerBytes = msg->readcount;
|
|
|
|
// track the last message received so it can be returned in
|
|
// client messages, allowing the server to detect a dropped
|
|
// gamestate
|
|
clc.serverMessageSequence = LittleLong( *(int *)msg->data );
|
|
|
|
clc.lastPacketTime = cls.realtime;
|
|
CL_ParseServerMessage( msg );
|
|
|
|
//
|
|
// we don't know if it is ok to save a demo message until
|
|
// after we have parsed the frame
|
|
//
|
|
if ( clc.demorecording && !clc.demowaiting ) {
|
|
CL_WriteDemoMessage( msg, headerBytes );
|
|
}
|
|
}
|
|
|
|
|
|
static void CL_CheckTimeout()
|
|
{
|
|
if (clc.demoplaying && (com_timescale->value == 0)) {
|
|
cl.timeoutcount = 0;
|
|
return;
|
|
}
|
|
|
|
const int timeout = clc.download ? 5000 : (cl_timeout->integer * 1000);
|
|
if ( ( !CL_Paused() || !sv_paused->integer )
|
|
&& cls.state >= CA_CONNECTED && cls.state != CA_CINEMATIC
|
|
&& cls.realtime - clc.lastPacketTime > timeout) {
|
|
if (++cl.timeoutcount > 5) { // timeoutcount saves debugger
|
|
Com_Error( ERR_DROP, "Server connection timed out" );
|
|
return;
|
|
}
|
|
} else {
|
|
cl.timeoutcount = 0;
|
|
}
|
|
}
|
|
|
|
|
|
static void CL_CheckUserinfo()
|
|
{
|
|
// don't add reliable commands when not yet connected
|
|
if ( cls.state < CA_CHALLENGING ) {
|
|
return;
|
|
}
|
|
// don't overflow the reliable command buffer when paused
|
|
if ( CL_Paused() ) {
|
|
return;
|
|
}
|
|
// send a reliable userinfo update if needed
|
|
if ( cvar_modifiedFlags & CVAR_USERINFO ) {
|
|
cvar_modifiedFlags &= ~CVAR_USERINFO;
|
|
CL_AddReliableCommand( va("userinfo \"%s\"", Cvar_InfoString( CVAR_USERINFO ) ) );
|
|
}
|
|
}
|
|
|
|
|
|
static void CL_CheckCRP()
|
|
{
|
|
// demo playback and listen servers are always OK
|
|
if ( Cvar_VariableIntegerValue( "r_pipeline" ) != 1 ||
|
|
CL_DemoPlaying() ||
|
|
Cvar_VariableIntegerValue( "sv_running" ) )
|
|
return;
|
|
|
|
switch ( cls.state ) {
|
|
case CA_CHALLENGING:
|
|
case CA_CONNECTING:
|
|
case CA_CONNECTED:
|
|
Cbuf_AddText( "r_pipeline 0\nvid_restart\nreconnect\n" );
|
|
Com_Printf( "^3WARNING: switched to GRP (r_pipeline 0) for online play\n" );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void CL_Frame( int msec )
|
|
{
|
|
if ( !com_cl_running->integer ) {
|
|
return;
|
|
}
|
|
|
|
CL_CheckCRP();
|
|
|
|
if ( cls.cddialog ) {
|
|
// bring up the cd error dialog if needed
|
|
cls.cddialog = qfalse;
|
|
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_NEED_CD );
|
|
} else if ( cls.state == CA_DISCONNECTED && !( cls.keyCatchers & KEYCATCH_UI )
|
|
&& !com_sv_running->integer ) {
|
|
// if disconnected, bring up the menu
|
|
S_StopAllSounds();
|
|
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
|
|
}
|
|
|
|
// if recording an avi, lock to a fixed fps
|
|
if ( CL_VideoRecording() && cl_aviFrameRate->integer && msec ) {
|
|
// save the current screen
|
|
CL_TakeVideoFrame();
|
|
// fixed time for next frame
|
|
msec = (int)ceil( (1000.0f / cl_aviFrameRate->value) * com_timescale->value );
|
|
if (msec == 0) {
|
|
msec = 1;
|
|
}
|
|
}
|
|
|
|
// save the msec before checking pause
|
|
cls.realFrametime = msec;
|
|
|
|
// decide the simulation time
|
|
cls.frametime = msec;
|
|
|
|
cls.realtime += cls.frametime;
|
|
|
|
if ( cl_timegraph->integer ) {
|
|
SCR_DebugGraph ( cls.realFrametime * 0.25, 0 );
|
|
}
|
|
|
|
// update the client's own GUI
|
|
CL_IMGUI_Frame();
|
|
|
|
// advance the current map download, if any
|
|
CL_MapDownload_Continue();
|
|
|
|
// see if we need to update any userinfo
|
|
CL_CheckUserinfo();
|
|
|
|
// if we haven't gotten a packet in a long time,
|
|
// drop the connection
|
|
CL_CheckTimeout();
|
|
|
|
// send intentions now
|
|
CL_SendCmd();
|
|
|
|
// resend a connection request if necessary
|
|
CL_CheckForResend();
|
|
|
|
// decide on the serverTime to render
|
|
CL_SetCGameTime();
|
|
|
|
// update the screen
|
|
SCR_UpdateScreen();
|
|
|
|
// update audio
|
|
S_Update();
|
|
|
|
// advance local effects for next frame
|
|
SCR_RunCinematic();
|
|
|
|
Con_RunConsole();
|
|
|
|
cls.framecount++;
|
|
}
|
|
|
|
|
|
qbool CL_ShouldSleep()
|
|
{
|
|
return re.ShouldSleep();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
|
|
int CL_ScaledMilliseconds()
|
|
{
|
|
return Sys_Milliseconds()*com_timescale->value;
|
|
}
|
|
|
|
|
|
qbool CL_Paused()
|
|
{
|
|
// Summary: We keep the client pause active until we get a new server time through a snapshot.
|
|
//
|
|
// Without this fix, after the client pause ends and before we get a new server snapshot,
|
|
// CL_AdjustTimeDelta will update cl.serverTime to a higher value
|
|
// and that value is sent in the ucmd_t data to the server (CL_FinishMove).
|
|
// Since the timestamp is "from the future", anything that follows needs to be
|
|
// at least as high, which won't happen for a while because cl.serverTime will get reset to
|
|
// something correct (i.e. lower) upon reception of the next snapshot from the server.
|
|
// In other words: After a client pause of X seconds, the server ignores the client's input
|
|
// for X seconds and the client is basically timing out. Oops.
|
|
return cl_paused->integer || cl_paused->modified;
|
|
}
|
|
|
|
|
|
static void CL_InitRenderer()
|
|
{
|
|
// this sets up the renderer and calls R_Init
|
|
re.BeginRegistration( &cls.glconfig );
|
|
|
|
// load character sets
|
|
cls.charSetShader = re.RegisterShader( "gfx/2d/bigchars" );
|
|
cls.whiteShader = re.RegisterShader( "white" );
|
|
g_console_field_width = CONSOLE_WIDTH;
|
|
g_consoleField.widthInChars = g_console_field_width;
|
|
}
|
|
|
|
|
|
// after the server has cleared the hunk, these will need to be restarted
|
|
// this is the only place that any of these functions are called from
|
|
|
|
void CL_StartHunkUsers( void ) {
|
|
if (!com_cl_running) {
|
|
return;
|
|
}
|
|
|
|
if ( !com_cl_running->integer ) {
|
|
return;
|
|
}
|
|
|
|
if ( !cls.rendererStarted ) {
|
|
cls.rendererStarted = qtrue;
|
|
CL_InitRenderer();
|
|
}
|
|
|
|
if ( !cls.soundStarted ) {
|
|
cls.soundStarted = qtrue;
|
|
S_Init();
|
|
}
|
|
|
|
if ( !cls.soundRegistered ) {
|
|
cls.soundRegistered = qtrue;
|
|
S_BeginRegistration();
|
|
}
|
|
|
|
if ( !cls.uiStarted ) {
|
|
cls.uiStarted = qtrue;
|
|
CL_InitUI();
|
|
}
|
|
}
|
|
|
|
|
|
static void QDECL CL_RefPrintf( printParm_t print_level, PRINTF_FORMAT_STRING const char* fmt, ... )
|
|
{
|
|
va_list va;
|
|
char msg[MAXPRINTMSG];
|
|
|
|
va_start( va, fmt );
|
|
Q_vsnprintf( msg, sizeof(msg), fmt, va );
|
|
va_end( va );
|
|
|
|
if ( print_level == PRINT_ALL ) {
|
|
Com_Printf( "%s", msg );
|
|
} else if ( print_level == PRINT_WARNING ) {
|
|
Com_Printf( S_COLOR_YELLOW "%s", msg );
|
|
} else if ( print_level == PRINT_ERROR ) {
|
|
Com_Printf( S_COLOR_RED "%s", msg );
|
|
} else if ( print_level == PRINT_DEVELOPER ) {
|
|
Com_DPrintf( S_COLOR_CYAN "%s", msg );
|
|
}
|
|
}
|
|
|
|
|
|
static void* CL_RefMalloc( int size )
|
|
{
|
|
return Z_TagMalloc( size, TAG_RENDERER );
|
|
}
|
|
|
|
|
|
static void CL_ShutdownRef()
|
|
{
|
|
if ( !re.Shutdown ) {
|
|
return;
|
|
}
|
|
re.Shutdown( cls.fullClientShutDown );
|
|
Com_Memset( &re, 0, sizeof( re ) );
|
|
}
|
|
|
|
|
|
static void RI_Cmd_RegisterTable( const cmdTableItem_t* cmds, int count )
|
|
{
|
|
Cmd_RegisterTable( cmds, count, MODULE_RENDERER );
|
|
}
|
|
|
|
|
|
static void RI_Cvar_RegisterTable( const cvarTableItem_t* cvars, int count )
|
|
{
|
|
Cvar_RegisterTable( cvars, count, MODULE_RENDERER );
|
|
}
|
|
|
|
|
|
static void RI_Cmd_UnregisterModule()
|
|
{
|
|
Cmd_UnregisterModule( MODULE_RENDERER );
|
|
}
|
|
|
|
|
|
static void CL_InitRef()
|
|
{
|
|
refimport_t ri;
|
|
|
|
ri.SetConsoleVisibility = Con_SetConsoleVisibility;
|
|
ri.Cmd_RegisterTable = RI_Cmd_RegisterTable;
|
|
ri.Cmd_UnregisterModule = RI_Cmd_UnregisterModule;
|
|
ri.Cmd_Argc = Cmd_Argc;
|
|
ri.Cmd_Argv = Cmd_Argv;
|
|
ri.Printf = CL_RefPrintf;
|
|
ri.Error = Com_Error;
|
|
ri.Milliseconds = CL_ScaledMilliseconds;
|
|
ri.Microseconds = Sys_Microseconds;
|
|
ri.Malloc = CL_RefMalloc;
|
|
ri.Free = Z_Free;
|
|
#ifdef HUNK_DEBUG
|
|
ri.Hunk_AllocDebug = Hunk_AllocDebug;
|
|
#else
|
|
ri.Hunk_Alloc = Hunk_Alloc;
|
|
#endif
|
|
ri.Hunk_AllocateTempMemory = Hunk_AllocateTempMemory;
|
|
ri.Hunk_FreeTempMemory = Hunk_FreeTempMemory;
|
|
ri.CM_DrawDebugSurface = CM_DrawDebugSurface;
|
|
ri.FS_ReadFile = FS_ReadFile;
|
|
ri.FS_ReadFilePak = FS_ReadFilePak;
|
|
ri.FS_FreeFile = FS_FreeFile;
|
|
ri.FS_WriteFile = FS_WriteFile;
|
|
ri.FS_FreeFileList = FS_FreeFileList;
|
|
ri.FS_ListFiles = FS_ListFiles;
|
|
ri.FS_GetPakPath = FS_GetPakPath;
|
|
ri.Cvar_Get = Cvar_Get;
|
|
ri.Cvar_SetHelp = Cvar_SetHelp;
|
|
ri.Cvar_Set = Cvar_Set;
|
|
ri.Cvar_RegisterTable = RI_Cvar_RegisterTable;
|
|
|
|
// cinematic stuff
|
|
|
|
ri.CIN_GrabCinematic = CIN_GrabCinematic;
|
|
ri.CIN_PlayCinematic = CIN_PlayCinematic;
|
|
ri.CIN_RunCinematic = CIN_RunCinematic;
|
|
|
|
ri.CL_WriteAVIVideoFrame = CL_WriteAVIVideoFrame;
|
|
|
|
re = *(GetRefAPI(&ri));
|
|
|
|
// unpause so the cgame definitely gets a snapshot and renders a frame
|
|
Cvar_Set( "cl_paused", "0" );
|
|
}
|
|
|
|
|
|
/*
|
|
Restart the video subsystem
|
|
|
|
we also have to reload the UI and CGame because the renderer
|
|
doesn't know what graphics to reload
|
|
*/
|
|
static void CL_Vid_Restart_f()
|
|
{
|
|
cls.fullClientShutDown = qfalse;
|
|
|
|
// Settings may have changed so stop recording now
|
|
CL_CloseAVI();
|
|
|
|
S_StopAllSounds(); // don't let them loop during the restart
|
|
|
|
CL_ShutdownUI();
|
|
CL_ShutdownCGame();
|
|
CL_ShutdownInput();
|
|
CL_ShutdownRef();
|
|
|
|
// client is no longer pure until new checksums are sent
|
|
CL_ResetPureClientAtServer();
|
|
|
|
FS_ClearPakReferences( FS_UI_REF | FS_CGAME_REF );
|
|
// reinitialize the filesystem if the game directory or checksum has changed
|
|
FS_ConditionalRestart( clc.checksumFeed );
|
|
|
|
cls.rendererStarted = qfalse;
|
|
cls.uiStarted = qfalse;
|
|
cls.cgameStarted = qfalse;
|
|
cls.soundRegistered = qfalse;
|
|
|
|
// unpause so the cgame definitely gets a snapshot and renders a frame
|
|
Cvar_Set( "cl_paused", "0" );
|
|
|
|
// if not running a server clear the whole hunk
|
|
if ( !com_sv_running->integer ) {
|
|
Hunk_Clear();
|
|
}
|
|
else {
|
|
// clear all the client data on the hunk
|
|
Hunk_ClearToMark();
|
|
}
|
|
|
|
// initialize the renderer interface
|
|
CL_InitRef();
|
|
|
|
// initialize input
|
|
CL_InitInput();
|
|
|
|
// startup all the client stuff
|
|
CL_StartHunkUsers();
|
|
|
|
// we don't really technically need to run everything again,
|
|
// but trying to optimize parts out is very likely to lead to nasty bugs
|
|
if ( clc.demoplaying && clc.newDemoPlayer ) {
|
|
Cmd_TokenizeString( va("demo \"%s\"", clc.demoName) );
|
|
CL_PlayDemo( qtrue );
|
|
}
|
|
// start the cgame if connected
|
|
else if ( cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
|
|
cls.cgameStarted = qtrue;
|
|
CL_InitCGame();
|
|
// send pure checksums
|
|
CL_SendPureChecksums();
|
|
}
|
|
}
|
|
|
|
|
|
// restart the sound subsystem
|
|
// the cgame must also be forced to restart because handles will be invalid
|
|
|
|
static void CL_Snd_Restart_f()
|
|
{
|
|
S_Shutdown();
|
|
S_Init();
|
|
|
|
CL_Vid_Restart_f();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
|
|
static void CL_Video_f()
|
|
{
|
|
char s[ MAX_OSPATH ];
|
|
|
|
if( !clc.demoplaying || clc.newDemoPlayer )
|
|
{
|
|
Com_Printf( "^3ERROR: ^7/%s is only enabled in the old demo player\n", Cmd_Argv( 0 ) );
|
|
return;
|
|
}
|
|
|
|
if( Cmd_Argc( ) == 2 )
|
|
{
|
|
Q_strncpyz( s, Cmd_Argv( 1 ), sizeof( s ) );
|
|
}
|
|
else
|
|
{
|
|
qtime_t t;
|
|
Com_RealTime( &t );
|
|
Com_sprintf( s, sizeof( s ), "%d_%02d_%02d-%02d_%02d_%02d",
|
|
1900+t.tm_year, 1+t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec );
|
|
}
|
|
|
|
CL_OpenAVIForWriting( s );
|
|
}
|
|
|
|
|
|
static void CL_StopVideo_f()
|
|
{
|
|
if( !clc.demoplaying || clc.newDemoPlayer )
|
|
{
|
|
Com_Printf( "^3ERROR: ^7/%s is only enabled in the old demo player\n", Cmd_Argv( 0 ) );
|
|
return;
|
|
}
|
|
|
|
if( !CL_VideoRecording() )
|
|
{
|
|
Com_Printf( "No video is being recorded\n" );
|
|
return;
|
|
}
|
|
|
|
CL_CloseAVI();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
|
|
static void CL_ShowIP_f()
|
|
{
|
|
Sys_ShowIP();
|
|
}
|
|
|
|
|
|
qbool CL_CDKeyValidate( const char *key, const char *checksum )
|
|
{
|
|
char ch;
|
|
byte sum;
|
|
char chs[3];
|
|
int i, len;
|
|
|
|
len = strlen(key);
|
|
if( len != CDKEY_LEN ) {
|
|
return qfalse;
|
|
}
|
|
|
|
if( checksum && strlen( checksum ) != CDCHKSUM_LEN ) {
|
|
return qfalse;
|
|
}
|
|
|
|
sum = 0;
|
|
// for loop gets rid of conditional assignment warning
|
|
for (i = 0; i < len; i++) {
|
|
ch = *key++;
|
|
if (ch>='a' && ch<='z') {
|
|
ch -= 32;
|
|
}
|
|
switch( ch ) {
|
|
case '2':
|
|
case '3':
|
|
case '7':
|
|
case 'A':
|
|
case 'B':
|
|
case 'C':
|
|
case 'D':
|
|
case 'G':
|
|
case 'H':
|
|
case 'J':
|
|
case 'L':
|
|
case 'P':
|
|
case 'R':
|
|
case 'S':
|
|
case 'T':
|
|
case 'W':
|
|
sum += ch;
|
|
continue;
|
|
default:
|
|
return qfalse;
|
|
}
|
|
}
|
|
|
|
sprintf(chs, "%02x", sum);
|
|
|
|
if (checksum && !Q_stricmp(chs, checksum)) {
|
|
return qtrue;
|
|
}
|
|
|
|
if (!checksum) {
|
|
return qtrue;
|
|
}
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
static void CL_PrintDownloadPakUsage()
|
|
{
|
|
Com_Printf( "Usage: %s checksum (signed decimal, '0x' or '0X' prefix for hex)\n", Cmd_Argv(0) );
|
|
}
|
|
|
|
|
|
static void CL_DownloadPak_f()
|
|
{
|
|
unsigned int checksum;
|
|
if ( Cmd_Argc() != 2 ) {
|
|
CL_PrintDownloadPakUsage();
|
|
return;
|
|
}
|
|
|
|
const char* const arg1 = Cmd_Argv(1);
|
|
const int length = strlen( arg1 );
|
|
if ( length > 2 && arg1[0] == '0' && (arg1[1] == 'x' || arg1[1] == 'X') ) {
|
|
if ( sscanf(arg1 + 2, "%x", &checksum) != 1 ) {
|
|
CL_PrintDownloadPakUsage();
|
|
return;
|
|
}
|
|
} else {
|
|
int crc32;
|
|
if ( sscanf(arg1, "%d", &crc32) != 1 ) {
|
|
CL_PrintDownloadPakUsage();
|
|
return;
|
|
}
|
|
checksum = (unsigned int)crc32;
|
|
}
|
|
|
|
if ( checksum == 0 ) {
|
|
Com_Printf( "%s: invalid checksum 0\n", Cmd_Argv(0) );
|
|
return;
|
|
}
|
|
|
|
if ( FS_PakExists(checksum) ) {
|
|
Com_Printf( "%s: pk3 with checksum 0x%08x (%d) already present\n", Cmd_Argv(0), checksum, (int)checksum );
|
|
return;
|
|
}
|
|
|
|
CL_PakDownload_Start( checksum, qtrue, NULL );
|
|
}
|
|
|
|
|
|
static void CL_DownloadMap( qbool forceDL )
|
|
{
|
|
if ( Cmd_Argc() != 2 ) {
|
|
Com_Printf( "Usage: %s mapname\n", Cmd_Argv(0) );
|
|
return;
|
|
}
|
|
|
|
const char* const mapName = Cmd_Argv(1);
|
|
if ( !forceDL ) {
|
|
const char* const mapPath = va( "maps/%s.bsp", mapName );
|
|
if ( MapDL_FileExists(mapPath) || FS_FileIsInPAK(mapPath, NULL, NULL) ) {
|
|
Com_Printf( "Map already exists! To force the download, use /%sf\n", Cmd_Argv(0) );
|
|
return;
|
|
}
|
|
}
|
|
|
|
CL_MapDownload_Start(mapName, qtrue);
|
|
}
|
|
|
|
|
|
static void CL_DownloadMap_f()
|
|
{
|
|
CL_DownloadMap( qfalse );
|
|
}
|
|
|
|
|
|
static void CL_ForceDownloadMap_f()
|
|
{
|
|
CL_DownloadMap( qtrue );
|
|
}
|
|
|
|
|
|
static void CL_CancelDownload_f()
|
|
{
|
|
CL_MapDownload_Cancel();
|
|
}
|
|
|
|
|
|
static void CL_PlayDemo_f()
|
|
{
|
|
CL_PlayDemo( qfalse );
|
|
}
|
|
|
|
|
|
static const cvarTableItem_t cl_cvars[] =
|
|
{
|
|
{ &cl_timeout, "cl_timeout", "200", 0, CVART_INTEGER, "30", "300", "connection time-out, in seconds" },
|
|
{ NULL, "cl_timeNudge", "0", CVAR_TEMP, CVART_INTEGER, NULL, NULL, help_cl_timeNudge },
|
|
{ &cl_shownet, "cl_shownet", "0", CVAR_TEMP, CVART_INTEGER, "-2", "4", help_cl_shownet },
|
|
{ &cl_showSend, "cl_showSend", "0", CVAR_TEMP, CVART_BOOL, NULL, NULL, help_cl_showSend },
|
|
{ &cl_showTimeDelta, "cl_showTimeDelta", "0", CVAR_TEMP, CVART_BOOL, NULL, NULL, "prints delta adjustment values and events" },
|
|
{ &rconPassword, "rconPassword", "", CVAR_TEMP, CVART_STRING, NULL, NULL, help_rconPassword },
|
|
{ &cl_timedemo, "timedemo", "0", 0, CVART_BOOL, NULL, NULL, "demo benchmarking mode" },
|
|
{
|
|
&cl_aviFrameRate, "cl_aviFrameRate", "50", CVAR_ARCHIVE, CVART_INTEGER, "24", "250", help_cl_aviFrameRate,
|
|
"AVI video framerate", CVARCAT_DEMO, "", ""
|
|
},
|
|
{
|
|
&cl_aviMotionJpeg, "cl_aviMotionJpeg", "1", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL, help_cl_aviMotionJpeg,
|
|
"AVI motion JPEG", CVARCAT_DEMO, "", ""
|
|
},
|
|
{
|
|
&cl_ffmpeg, "cl_ffmpeg", "0", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL,
|
|
"use FFmpeg for video export\n"
|
|
"Pipes video through FFmpeg instead of writing raw .avi files.",
|
|
"Use FFmpeg", CVARCAT_DEMO, "Uses FFmpeg instead of writing raw .avi files", ""
|
|
},
|
|
{
|
|
&cl_ffmpegCommand, "cl_ffmpegCommand", "-movflags faststart -bf 2 -c:v libx264 -preset medium -crf 23 -vf format=yuv420p -c:a aac -b:a 320k",
|
|
CVAR_ARCHIVE, CVART_STRING, NULL, NULL,
|
|
"FFmpeg encode settings\n"
|
|
"The full command-line options for the output file.",
|
|
"FFmpeg encode settings", CVARCAT_DEMO, "Command-line options for the output file", ""
|
|
},
|
|
{
|
|
&cl_ffmpegExePath, "cl_ffmpegExePath", "ffmpeg", CVAR_ARCHIVE, CVART_STRING, NULL, NULL,
|
|
"FFmpeg executable path\n"
|
|
"The path cannot contain spaces.",
|
|
"FFmpeg executable path", CVARCAT_DEMO, "The path cannot contain spaces", ""
|
|
},
|
|
{
|
|
&cl_ffmpegOutPath, "cl_ffmpegOutPath", "", CVAR_ARCHIVE, CVART_STRING, NULL, NULL,
|
|
"FFmpeg output directory\n"
|
|
"Leave empty to write to cpma/videos as with .avi files.",
|
|
"FFmpeg output directory", CVARCAT_DEMO, "Leave empty to write to cpma/videos as with .avi files", ""
|
|
},
|
|
{
|
|
&cl_ffmpegOutExt, "cl_ffmpegOutExt", "mp4", CVAR_ARCHIVE, CVART_STRING, NULL, NULL, "FFmpeg output file extension",
|
|
"FFmpeg output file extension", CVARCAT_DEMO, "", ""
|
|
},
|
|
{
|
|
&cl_ffmpegLog, "cl_ffmpegLog", "0", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL,
|
|
"FFmpeg log file creation\n"
|
|
"Creates 1 log file per capture.",
|
|
"FFmpeg log file creation", CVARCAT_DEMO, "Creates 1 log file per capture", ""
|
|
},
|
|
{ &rconAddress, "rconAddress", "", 0, CVART_STRING, NULL, NULL, help_rconAddress },
|
|
{
|
|
&cl_maxpackets, "cl_maxpackets", "125", CVAR_ARCHIVE, CVART_INTEGER, "15", "125", "max. packet upload rate",
|
|
"Max. packets", CVARCAT_NETWORK, "", ""
|
|
},
|
|
{
|
|
&cl_packetdup, "cl_packetdup", "1", CVAR_ARCHIVE, CVART_INTEGER, "0", "5", "number of extra transmissions per packet",
|
|
"Packet duplication", CVARCAT_NETWORK, "Sets the number of extra copies per packet", "Use if you experience packet loss"
|
|
},
|
|
{
|
|
&cl_allowDownload, "cl_allowDownload", "1", CVAR_ARCHIVE, CVART_INTEGER, "-1", "1", help_cl_allowDownload,
|
|
"PK3 download mode", CVARCAT_NETWORK, "", "",
|
|
CVAR_GUI_VALUE("-1", "Quake 3", "Can always find PK3 files\nServer must allow it\nVery slow")
|
|
CVAR_GUI_VALUE("0", "Disabled", "")
|
|
CVAR_GUI_VALUE("1", "CNQ3", "Map server may not have the file\nIndependent of server\nFast")
|
|
},
|
|
{ &cl_inGameVideo, "r_inGameVideo", "1", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL, "enables roq video playback" },
|
|
{ &cl_serverStatusResendTime, "cl_serverStatusResendTime", "750", 0, CVART_INTEGER, "500", "1000", "milli-seconds to wait before resending getstatus" },
|
|
{ NULL, "cl_maxPing", "999", CVAR_ARCHIVE, CVART_INTEGER, "80", "999", "max. ping for the server browser" },
|
|
{
|
|
NULL, "name", "UnnamedPlayer", CVAR_USERINFO | CVAR_ARCHIVE, CVART_STRING, NULL, NULL, "your name",
|
|
"Player name", CVARCAT_GENERAL, "", ""
|
|
},
|
|
{
|
|
NULL, "rate", "25000", CVAR_USERINFO | CVAR_ARCHIVE, CVART_INTEGER, "4000", "99999", "network transfer rate",
|
|
"Transfer rate", CVARCAT_NETWORK, "You'll generally want 25K to 30K", ""
|
|
},
|
|
{ NULL, "snaps", "30", CVAR_USERINFO | CVAR_ARCHIVE, CVART_INTEGER }, // documented by the mod
|
|
{ NULL, "password", "", CVAR_USERINFO, CVART_STRING, NULL, NULL, "used by /" S_COLOR_CMD "connect" },
|
|
{
|
|
&cl_matchAlerts, "cl_matchAlerts", "7", CVAR_ARCHIVE, CVART_BITMASK, "0", XSTRING(MAF_MAX), help_cl_matchAlerts,
|
|
"Match alerts", CVARCAT_GENERAL, "Lets you know when a match is starting", "",
|
|
CVAR_GUI_VALUE("0", "When unfocused", "Otherwise only when minimized")
|
|
CVAR_GUI_VALUE("1", "Flash the task bar", "")
|
|
CVAR_GUI_VALUE("2", "Beep once", "")
|
|
CVAR_GUI_VALUE("3", "Unmute", "")
|
|
},
|
|
{ &net_proxy, "net_proxy", "", CVAR_TEMP, CVART_STRING, NULL, NULL, help_net_proxy },
|
|
{
|
|
&cl_demoPlayer, "cl_demoPlayer", "1", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL, help_cl_demoPlayer,
|
|
"New demo player", CVARCAT_DEMO, "Enables the new demo player with rewind support", ""
|
|
},
|
|
{
|
|
&cl_escapeAbortsDemo, "cl_escapeAbortsDemo", "1", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL, "pressing escape aborts demo playback",
|
|
"Escape aborts demo", CVARCAT_DEMO, "Pressing escape aborts demo playback", ""
|
|
},
|
|
};
|
|
|
|
|
|
static const cmdTableItem_t cl_cmds[] =
|
|
{
|
|
{ "cmd", CL_ForwardToServer_f, NULL, "forwards all arguments as a command to the server" },
|
|
{ "configstrings", CL_Configstrings_f, NULL, "prints all non-empty config strings" },
|
|
{ "clientinfo", CL_Clientinfo_f, NULL, "prints some client settings" },
|
|
{ "snd_restart", CL_Snd_Restart_f, NULL, "restarts the sound system" },
|
|
{ "vid_restart", CL_Vid_Restart_f, NULL, "restarts the video system" },
|
|
{ "disconnect", CL_Disconnect_f, NULL, "disconnects from the current server" },
|
|
{ "record", CL_Record_f, CL_CompleteDemoRecord_f, "starts recording a demo" },
|
|
{ "demo", CL_PlayDemo_f, CL_CompleteDemoPlay_f, "starts demo playback" },
|
|
{ "cinematic", CL_PlayCinematic_f, NULL, "starts playback of a .roq video file" },
|
|
{ "stoprecord", CL_StopRecord_f, NULL, "stops demo recording" },
|
|
{ "connect", CL_Connect_f, NULL, "connects to a server" },
|
|
{ "reconnect", CL_Reconnect_f, NULL, "reconnects to the current or last server" },
|
|
{ "localservers", CL_LocalServers_f, NULL, "finds and prints local LAN servers" },
|
|
{ "globalservers", CL_GlobalServers_f, NULL, "requests server lists from master servers" },
|
|
{ "rcon", CL_Rcon_f, CL_CompleteRcon_f, "executes the arguments as a command on the server" },
|
|
{ "ping", CL_Ping_f, NULL, "pings a server" },
|
|
{ "serverstatus", CL_ServerStatus_f, NULL, "prints server status and player list" },
|
|
{ "showip", CL_ShowIP_f, NULL, "shows your open IP address(es)" },
|
|
{ "fs_referencedList", CL_ReferencedPK3List_f, NULL, "prints the names of referenced pak files" },
|
|
{ "video", CL_Video_f, NULL, "starts writing a .avi file" },
|
|
{ "stopvideo", CL_StopVideo_f, NULL, "stops writing the .avi file" },
|
|
{ "dlpak", CL_DownloadPak_f, NULL, "starts a pk3 download by checksum if not existing" },
|
|
{ "dlmap", CL_DownloadMap_f, NULL, "starts a pk3 download by map name if not existing" },
|
|
{ "dlmapf", CL_ForceDownloadMap_f, NULL, "start a pk3 download by map name" },
|
|
{ "dlstop", CL_CancelDownload_f, NULL, "stops the current pk3 download" },
|
|
};
|
|
|
|
|
|
struct cvarTableItemCPMA_t {
|
|
const char* name;
|
|
cvarType_t type;
|
|
const char* guiName;
|
|
int categories;
|
|
const char* guiDesc;
|
|
const char* guiHelp;
|
|
const char* guiValues;
|
|
};
|
|
|
|
|
|
static const cvarTableItemCPMA_t cpma_cvars[] =
|
|
{
|
|
{
|
|
"cg_damageDraw", CVART_BOOL,
|
|
"Screen blood", CVARCAT_GRAPHICS, "Draws blood when taking damage", ""
|
|
},
|
|
{
|
|
"cg_deadBodyDarken", CVART_BOOL,
|
|
"Grey corpses", CVARCAT_GRAPHICS, "Renders dead players in dark grey", ""
|
|
},
|
|
{
|
|
"cg_redTeamColors", CVART_COLOR_CHBLS,
|
|
"Red player colors", CVARCAT_GRAPHICS, "Red team player colors", ""
|
|
},
|
|
{
|
|
"cg_blueTeamColors", CVART_COLOR_CHBLS,
|
|
"Blue player colors", CVARCAT_GRAPHICS, "Blue team player colors", ""
|
|
},
|
|
{
|
|
"cg_forceTeamColors", CVART_BITMASK,
|
|
"Force team player colors", CVARCAT_GRAPHICS, "", "",
|
|
CVAR_GUI_VALUE("0", "Own team in first-person", "")
|
|
CVAR_GUI_VALUE("1", "Enemy team in first-person", "")
|
|
CVAR_GUI_VALUE("2", "Free-float camera", "")
|
|
CVAR_GUI_VALUE("3", "Only for CTF/NTF/CTFS", "")
|
|
},
|
|
{
|
|
"cg_teamModel", CVART_STRING,
|
|
"Team model", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_forceTeamModel", CVART_BOOL,
|
|
"Force team model", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_enemyColors", CVART_COLOR_CHBLS,
|
|
"Enemy player colors", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_enemyModel", CVART_STRING,
|
|
"Enemy model", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_fallKick", CVART_BOOL,
|
|
"Fall kick", CVARCAT_GAMEPLAY, "Makes the camera bounce after a fall", ""
|
|
},
|
|
{
|
|
"cg_forceColors", CVART_BOOL,
|
|
"Force colors on teammates", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_gunOffset", CVART_STRING,
|
|
"View weapon position", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_itemFX", CVART_BITMASK,
|
|
"Item effects", CVARCAT_GRAPHICS, "", "",
|
|
CVAR_GUI_VALUE("0", "Bob up and down", "")
|
|
CVAR_GUI_VALUE("1", "Rotate", "Asymmetric items will always rotate")
|
|
CVAR_GUI_VALUE("2", "Scale up on respawn", "")
|
|
},
|
|
{
|
|
"cg_lagHax", CVART_INTEGER,
|
|
"Adaptive prediction", CVARCAT_NETWORK, "Also does a bit of lag compensation", "",
|
|
CVAR_GUI_VALUE("0", "Disabled", "")
|
|
CVAR_GUI_VALUE("-1", "As much as allowed", "")
|
|
},
|
|
{
|
|
"cg_lightningImpact", CVART_INTEGER,
|
|
"LG impact style", CVARCAT_GRAPHICS, "", "",
|
|
CVAR_GUI_VALUE("0", "Nothing", "")
|
|
CVAR_GUI_VALUE("1", "Impact", "")
|
|
CVAR_GUI_VALUE("2", "Impact and sparks", "")
|
|
},
|
|
{
|
|
"cg_muzzleFlash", CVART_BOOL,
|
|
"Muzzle flash", CVARCAT_GRAPHICS, "Draws a muzzle flash when firing the view weapon", ""
|
|
},
|
|
{
|
|
"cg_noAmmoChange", CVART_INTEGER,
|
|
"No-ammo switch", CVARCAT_GAMEPLAY, "Allows from/to out-of-ammo weapon changes", "",
|
|
CVAR_GUI_VALUE("0", "Switch, disallow 0 ammo", "Switches to the next weapon. Can't select a weapon with no ammo")
|
|
CVAR_GUI_VALUE("1", "Switch, allow 0 ammo", "Switches to the next weapon. Can select a weapon with no ammo")
|
|
CVAR_GUI_VALUE("2", "No switch, allow 0 ammo", "Keeps the current weapon. Can select a weapon with no ammo")
|
|
},
|
|
{
|
|
"cg_noHitBeep", CVART_BOOL,
|
|
"Hit beeps", CVARCAT_SOUND | CVARCAT_GAMEPLAY, "", "",
|
|
CVAR_GUI_VALUE("1", "Silence", "")
|
|
CVAR_GUI_VALUE("0", "Hit beeps", "")
|
|
},
|
|
{
|
|
"cg_nudge", CVART_INTEGER,
|
|
"Time nudge", CVARCAT_NETWORK, "", ""
|
|
},
|
|
{
|
|
"cg_optimiseBW", CVART_BITMASK,
|
|
"Bandwidth optimizations", CVARCAT_NETWORK, "", "",
|
|
CVAR_GUI_VALUE("0", "Server-to-client", "Usually forced by servers")
|
|
CVAR_GUI_VALUE("1", "Client-to-server", "Only use if your upload rate is dial-up level")
|
|
},
|
|
{
|
|
"cg_railCoreWidth", CVART_INTEGER,
|
|
"Railgun core width", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_railRingStep", CVART_INTEGER,
|
|
"Railgun ring step", CVARCAT_GRAPHICS, "Distance between the rail rings", ""
|
|
},
|
|
{
|
|
"cg_railRingWidth", CVART_INTEGER,
|
|
"Railgun ring width", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_railStyle", CVART_BITMASK,
|
|
"Railgun trail style", CVARCAT_GRAPHICS, "Visual elements of a railgun trail", "",
|
|
CVAR_GUI_VALUE("0", "Core", "")
|
|
CVAR_GUI_VALUE("1", "Spiral", "")
|
|
CVAR_GUI_VALUE("2", "Rings", "")
|
|
},
|
|
{
|
|
"cg_smoke_SG", CVART_BOOL,
|
|
"Shotgun smoke", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_smokeRadius_RL", CVART_FLOAT,
|
|
"Rocket launcher smoke radius", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_smokeRadius_GL", CVART_FLOAT,
|
|
"Grenade launcher smoke radius", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_xerpClients", CVART_INTEGER,
|
|
"Extrapolate clients", CVARCAT_NETWORK, "", "",
|
|
CVAR_GUI_VALUE("-1", "Hacked extrapolation", "Intended for high ping")
|
|
CVAR_GUI_VALUE("0", "No extrapolation", "Fine for low ping")
|
|
CVAR_GUI_VALUE("1", "Original Q3 behavior", "Just like the original cg_smoothClients code")
|
|
},
|
|
{
|
|
"cg_trueLightning", CVART_FLOAT,
|
|
"Lightning gun beam prediction", CVARCAT_GRAPHICS | CVARCAT_NETWORK | CVARCAT_GAMEPLAY, "",
|
|
"LG beam prediction control\n" \
|
|
" -1 = Pure client-side (no sway, no beam drawn)\n"
|
|
" 0 = Pure server-side (sways the most)\n"
|
|
" 1 = Pure client-side (no sway)\n"
|
|
"Fractional values: mix between server and client rendering\n"
|
|
"Negative values: the beam isn't drawn\n"
|
|
"Negative fractional values still affect impact mark placement."
|
|
},
|
|
{
|
|
"cg_viewAdjustments", CVART_BOOL,
|
|
"Enable view bobbing", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_fragSound", CVART_STRING,
|
|
"Kill sound", CVARCAT_SOUND, "", "",
|
|
CVAR_GUI_VALUE("0", "No sound", "")
|
|
CVAR_GUI_VALUE("1", "Tonal impact: D", "")
|
|
CVAR_GUI_VALUE("2", "Tonal impact: E", "")
|
|
CVAR_GUI_VALUE("3", "Tonal impact: F#", "")
|
|
CVAR_GUI_VALUE("4", "Tonal impact: G", "")
|
|
CVAR_GUI_VALUE("5", "Cork pop", "")
|
|
CVAR_GUI_VALUE("6", "Cash register", "")
|
|
CVAR_GUI_VALUE("7", "Hook impact", "")
|
|
},
|
|
{
|
|
"cg_newModels", CVART_BOOL,
|
|
"Better 3D models", CVARCAT_GRAPHICS, "Uses better meshes for items", ""
|
|
},
|
|
{
|
|
"cg_animateChatBalloon", CVART_BOOL,
|
|
"Animated chat sprite", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_demoMapOverrides", CVART_BOOL,
|
|
"Override demo maps", CVARCAT_GRAPHICS, "Replaces maps for demo playback",
|
|
"The override list is loaded from 'cfg-maps/demomaps.txt'.\n"
|
|
"Each line has the format 'DemoName DisplayName'.\n"
|
|
"Example: 'cpm3a cpm3b_b1' will display cpm3b_b1 instead of cpm3a."
|
|
},
|
|
{
|
|
"ch_crosshairAlpha", CVART_FLOAT,
|
|
"Crosshair opacity", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_crosshairColor", CVART_COLOR_CPMA,
|
|
"Crosshair color", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_crosshairPulse", CVART_INTEGER,
|
|
"Crosshair pulses", CVARCAT_HUD, "Crosshair pulses on events", "",
|
|
CVAR_GUI_VALUE("0", "Never", "")
|
|
CVAR_GUI_VALUE("1", "Item pick-ups", "")
|
|
CVAR_GUI_VALUE("2", "Enemy damage", "")
|
|
CVAR_GUI_VALUE("3", "Enemy frags", "")
|
|
},
|
|
{
|
|
"ch_crosshairText", CVART_STRING,
|
|
"Crosshair text", CVARCAT_HUD, "Crosshair uses this text instead of an icon", ""
|
|
},
|
|
{
|
|
"ch_crosshairHitColor", CVART_COLOR_CPMA_E,
|
|
"Crosshair hit color", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_crosshairFragColor", CVART_COLOR_CPMA_E,
|
|
"Crosshair kill color", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_drawWarmup", CVART_BOOL,
|
|
"Warm-up info", CVARCAT_HUD, "Displays gameplay settings during warm-up", ""
|
|
},
|
|
{
|
|
"ch_file", CVART_STRING,
|
|
"HUD config file", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_playerNames", CVART_BOOL,
|
|
"Draw player names", CVARCAT_DEMO, "Draws names above heads during demo playback", ""
|
|
},
|
|
{
|
|
"ch_recordMessage", CVART_BOOL,
|
|
"Draw demo recording", CVARCAT_HUD, "Draws a message when recording demos", ""
|
|
},
|
|
{
|
|
"ch_selfOnTeamOverlay", CVART_BOOL,
|
|
"Team overlay self row", CVARCAT_HUD, "Draw a row for yourself in the team overlays", ""
|
|
},
|
|
{
|
|
"ch_shortNames", CVART_BOOL,
|
|
"Team overlay nicknames", CVARCAT_HUD, "Team overlays uses nicknames (max. 5 characters) instead of names", ""
|
|
},
|
|
{
|
|
"ch_locations", CVART_BOOL,
|
|
"Team overlay locations", CVARCAT_HUD, "Draws locations in the team overlays", ""
|
|
},
|
|
{
|
|
"ch_shortScoreboard", CVART_BOOL,
|
|
"Short scoreboard", CVARCAT_HUD, "Disables stats display in 1v1 scoreboard", ""
|
|
},
|
|
{
|
|
"ch_3waveFont", CVART_BOOL,
|
|
"Threewave font", CVARCAT_HUD, "Uses the Threewave font in the scoreboard", ""
|
|
},
|
|
{
|
|
"ch_wstatsTime", CVART_INTEGER,
|
|
"Weapon stats time", CVARCAT_HUD, "Max. +wstats display duration in intermission", ""
|
|
},
|
|
{
|
|
"ch_gauntlet", CVART_BOOL,
|
|
"Gauntlet in weapon list", CVARCAT_HUD, "Draws the gauntlet in the WeaponList SuperHUD element", ""
|
|
},
|
|
{
|
|
"ch_drawKeys", CVART_BITMASK,
|
|
"Draw movement keys", CVARCAT_HUD, "Enables the KeyDown_* and KeyUp_* SuperHUD elements", "",
|
|
CVAR_GUI_VALUE("0", "When playing", "")
|
|
CVAR_GUI_VALUE("1", "When spectating", "")
|
|
CVAR_GUI_VALUE("2", "During demo playback", "Won't work with pre-1.50 demos")
|
|
},
|
|
{
|
|
"ch_hiddenElements", CVART_STRING,
|
|
"Hidden SuperHUD elements", CVARCAT_HUD, "List of hidden SuperHUD elements", "Use /hud_hide and /hud_show to manipulate this list"
|
|
},
|
|
{
|
|
"ch_timersList", CVART_STRING,
|
|
"Item timers draw list", CVARCAT_HUD, "Space-separated list of item types to draw", "Use /itemtimerlist to see the type list"
|
|
},
|
|
{
|
|
"ch_timersOrderOR", CVART_INTEGER,
|
|
"Own/red item timers order", CVARCAT_HUD, "", "",
|
|
CVAR_GUI_VALUE("0", "Flag -> Mid", "")
|
|
CVAR_GUI_VALUE("1", "Mid -> Flag", "")
|
|
CVAR_GUI_VALUE("2", "Custom list", "")
|
|
CVAR_GUI_VALUE("3", "Custom list, inverted", "")
|
|
},
|
|
{
|
|
"ch_timersOrderEB", CVART_INTEGER,
|
|
"Enemy/blue item timers order", CVARCAT_HUD, "", "",
|
|
CVAR_GUI_VALUE("0", "Flag -> Mid", "")
|
|
CVAR_GUI_VALUE("1", "Mid -> Flag", "")
|
|
CVAR_GUI_VALUE("2", "Custom list", "")
|
|
CVAR_GUI_VALUE("3", "Custom list, inverted", "")
|
|
},
|
|
{
|
|
"ch_timersOrderTeams", CVART_INTEGER,
|
|
"Item timers team order", CVARCAT_HUD, "", "",
|
|
CVAR_GUI_VALUE("0", "Own -> Enemy", "")
|
|
CVAR_GUI_VALUE("1", "Enemy -> Own", "")
|
|
CVAR_GUI_VALUE("2", "Red -> Blue", "")
|
|
CVAR_GUI_VALUE("3", "Blue -> Red", "")
|
|
},
|
|
{
|
|
"ch_timersSync", CVART_BOOL,
|
|
"Synchronize item timers", CVARCAT_HUD, "Synchronizes all timer updates in the HUD", ""
|
|
},
|
|
{
|
|
"cg_demoSkipPauses", CVART_BOOL,
|
|
"Skip server pauses", CVARCAT_DEMO, "Skips timeouts and referee pauses",
|
|
"When not paused, it will skip past server pauses\n"
|
|
"Only available with CNQ3's new demo player"
|
|
},
|
|
{
|
|
"mvw_DM", CVART_STRING,
|
|
"Multi-view 1v1 window", CVARCAT_HUD, "PiP window coordinates for the opponent in 1v1", ""
|
|
},
|
|
{
|
|
"mvw_TDM1", CVART_STRING,
|
|
"Multi-view TDM window #1", CVARCAT_HUD, "PiP window coordinates for teammate #1", ""
|
|
},
|
|
{
|
|
"mvw_TDM2", CVART_STRING,
|
|
"Multi-view TDM window #2", CVARCAT_HUD, "PiP window coordinates for teammate #2", ""
|
|
},
|
|
{
|
|
"mvw_TDM3", CVART_STRING,
|
|
"Multi-view TDM window #3", CVARCAT_HUD, "PiP window coordinates for teammate #3", ""
|
|
},
|
|
{
|
|
"mvw_TDM4", CVART_STRING,
|
|
"Multi-view TDM window #4", CVARCAT_HUD, "PiP window coordinates for teammate #4", ""
|
|
},
|
|
{
|
|
"s_ambient", CVART_BOOL,
|
|
"Ambient sounds", CVARCAT_SOUND, "Enables the maps' ambient sounds", ""
|
|
},
|
|
{
|
|
"cg_drawBrightSpawns", CVART_BOOL,
|
|
"Bright spawn points", CVARCAT_GRAPHICS, "Draws spawn points more visibly during warm-up", ""
|
|
},
|
|
{
|
|
"cg_drawBrightWeapons", CVART_BITMASK,
|
|
"Fullbright weapons", CVARCAT_GRAPHICS, "Enables fullbright weapons", "",
|
|
CVAR_GUI_VALUE("0", "First-person, your own gun", "")
|
|
CVAR_GUI_VALUE("1", "First-person, carried by teammates", "")
|
|
CVAR_GUI_VALUE("2", "First-person, carried by enemies", "")
|
|
CVAR_GUI_VALUE("3", "Weapons lying on the map", "")
|
|
CVAR_GUI_VALUE("4", "Freecam, carried by players", "")
|
|
},
|
|
{
|
|
"s_announcer", CVART_STRING,
|
|
"Announcer", CVARCAT_SOUND, "Announcer sound pack", "",
|
|
CVAR_GUI_VALUE("feedback", "Q3's male announcer", "")
|
|
CVAR_GUI_VALUE("hellchick", "CPMA's female announcer", "")
|
|
},
|
|
{
|
|
"ch_consoleLines", CVART_INTEGER,
|
|
"Max console lines", CVARCAT_HUD, "Maximum number of lines in the 'Console' SuperHUD element", ""
|
|
},
|
|
{
|
|
"ch_eventLines", CVART_INTEGER,
|
|
"Max event lines", CVARCAT_HUD, "Maximum number of lines in the 'GameEvents' SuperHUD element", ""
|
|
},
|
|
{
|
|
"ch_eventForceColors", CVART_BOOL,
|
|
"Force event colors", CVARCAT_HUD, "Enables custom team colors in the 'GameEvents' SuperHUD element", ""
|
|
},
|
|
{
|
|
"ch_eventOwnColor", CVART_COLOR_CPMA,
|
|
"Own team event color", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_eventEnemyColor", CVART_COLOR_CPMA,
|
|
"Enemy team event color", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"ch_chatLines", CVART_INTEGER,
|
|
"Max chat lines", CVARCAT_HUD, "Maximum number of lines in the 'Chat' SuperHUD element", ""
|
|
},
|
|
{
|
|
"ch_animateScroll", CVART_BOOL,
|
|
"Scrolling animations", CVARCAT_HUD, "For console, chat, game events and rewards", ""
|
|
},
|
|
{
|
|
"ch_animateRewardIcons", CVART_INTEGER,
|
|
"Animate reward icons", CVARCAT_HUD, "", "",
|
|
CVAR_GUI_VALUE("0", "No animation", "")
|
|
CVAR_GUI_VALUE("1", "Play animation once", "")
|
|
CVAR_GUI_VALUE("2", "Play looped animation", "")
|
|
},
|
|
{
|
|
"ui_swapMouseButtons", CVART_BOOL,
|
|
"Swap mouse buttons", CVARCAT_GUI, "Swaps the left and right mouse buttons", ""
|
|
},
|
|
{
|
|
"ui_sensitivity", CVART_FLOAT,
|
|
"UI mouse sensitivity", CVARCAT_GUI, "Mouse sensitivity in the UI", ""
|
|
},
|
|
{
|
|
"cg_mvSensitivity", CVART_FLOAT,
|
|
"Coach view mouse sensitivity", CVARCAT_GUI, "Mouse sensitivity in the live coach view UI", ""
|
|
},
|
|
{
|
|
"cg_ammoWarning", CVART_BOOL,
|
|
"Ammo warning", CVARCAT_SOUND, "Plays a click sound when out of ammo", ""
|
|
},
|
|
{
|
|
"cg_autoswitch", CVART_BOOL,
|
|
"Weapon auto-switch", CVARCAT_GAMEPLAY, "Auto-switches to the weapon you just picked up", ""
|
|
},
|
|
{
|
|
"com_blood", CVART_INTEGER,
|
|
"Draw blood", CVARCAT_GRAPHICS, "Draws blood when players are hit", "",
|
|
CVAR_GUI_VALUE("0", "Disabled", "")
|
|
CVAR_GUI_VALUE("1", "Old style", "Large, long, slow updates")
|
|
CVAR_GUI_VALUE("2", "New style", "Small, short, fast updates")
|
|
},
|
|
{
|
|
"cg_drawGun", CVART_INTEGER,
|
|
"View weapon", CVARCAT_GRAPHICS, "", "",
|
|
CVAR_GUI_VALUE("0", "No gun", "")
|
|
CVAR_GUI_VALUE("1", "Gun visible, sways", "")
|
|
CVAR_GUI_VALUE("2", "Gun visible, doesn't sway", "")
|
|
},
|
|
{
|
|
"cg_zoomfov", CVART_FLOAT,
|
|
"Zoom FoV", CVARCAT_GRAPHICS | CVARCAT_GAMEPLAY, "Field of view when zoomed in", ""
|
|
},
|
|
{
|
|
"cg_zoomAnimationTime", CVART_INTEGER,
|
|
"Zoom animation time", CVARCAT_GRAPHICS | CVARCAT_GAMEPLAY, "Zoom in/out animation duration, in milliseconds", ""
|
|
},
|
|
{
|
|
"cg_zoomSensitivity", CVART_FLOAT,
|
|
"Zoom mouse sensitivity", CVARCAT_GAMEPLAY, "Relative to the main sensitivity", ""
|
|
},
|
|
{
|
|
"cg_fov", CVART_FLOAT,
|
|
"FoV", CVARCAT_GRAPHICS | CVARCAT_GAMEPLAY, "Field of view", "Enable depth clamping to raise the limit to 150"
|
|
},
|
|
{
|
|
"cg_viewsize", CVART_INTEGER,
|
|
"Gameplay window size", CVARCAT_HUD, "Percentage scale of the gameplay window", ""
|
|
},
|
|
{
|
|
"cg_shadows", CVART_BOOL,
|
|
"Blob player shadows", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"cg_gibs", CVART_BOOL,
|
|
"Giblets", CVARCAT_GRAPHICS, "Enables giblets and the blood spatter effect", ""
|
|
},
|
|
{
|
|
"cg_draw2D", CVART_BOOL,
|
|
"Enable HUD", CVARCAT_HUD, "", ""
|
|
},
|
|
{
|
|
"cg_draw3dIcons", CVART_BOOL,
|
|
"3D icons", CVARCAT_HUD, "Draws 3D heads/flags in the HUD", ""
|
|
},
|
|
{
|
|
"cg_drawCrosshair", CVART_INTEGER,
|
|
"Crosshair icon", CVARCAT_HUD, "", "",
|
|
CVAR_GUI_VALUE("0", "No crosshair", "")
|
|
CVAR_GUI_VALUE("1", "Cross", "")
|
|
CVAR_GUI_VALUE("2", "Exploded cross", "")
|
|
CVAR_GUI_VALUE("3", "Disk + dot", "")
|
|
CVAR_GUI_VALUE("4", "Circle + dot", "")
|
|
CVAR_GUI_VALUE("5", "Big dot", "")
|
|
CVAR_GUI_VALUE("6", "Circle + cross", "")
|
|
CVAR_GUI_VALUE("7", "Big exploded cross", "")
|
|
CVAR_GUI_VALUE("8", "Big exploded cross + dot", "")
|
|
CVAR_GUI_VALUE("9", "Side curves + dot", "")
|
|
CVAR_GUI_VALUE("10", "Circle + dot", "")
|
|
CVAR_GUI_VALUE("11", "Cross with black outline", "")
|
|
CVAR_GUI_VALUE("12", "Exploded cross with black outline", "")
|
|
CVAR_GUI_VALUE("13", "Disk + dot with black outline", "")
|
|
CVAR_GUI_VALUE("14", "Circle + dot with black outline", "")
|
|
CVAR_GUI_VALUE("15", "Dot with black outline", "")
|
|
CVAR_GUI_VALUE("16", "Circle + cross with black outline", "")
|
|
CVAR_GUI_VALUE("17", "Mirrored L with black outline", "")
|
|
CVAR_GUI_VALUE("18", "Cross + dot with black outlines", "")
|
|
CVAR_GUI_VALUE("19", "Side curves + dot with black outline", "")
|
|
CVAR_GUI_VALUE("20", "Circle + exploded cross + dot", "")
|
|
},
|
|
{
|
|
"cg_drawCrosshairNames", CVART_INTEGER,
|
|
"Draw crosshair names", CVARCAT_HUD, "Draws the name and status of the player under the crosshair",
|
|
"SuperHUD elements: 'TargetName' and 'TargetStatus'",
|
|
CVAR_GUI_VALUE("0", "Disabled", "")
|
|
CVAR_GUI_VALUE("1", "All players", "")
|
|
CVAR_GUI_VALUE("2", "Teammates only", "")
|
|
},
|
|
{
|
|
"cg_crosshairSize", CVART_STRING,
|
|
"Crosshair scale", CVARCAT_HUD, "Examples: '26', '26x32'", ""
|
|
},
|
|
{
|
|
"cg_crosshairHealth", CVART_BOOL,
|
|
"Crosshair health", CVARCAT_HUD, "Sets crosshair color based on your stack", ""
|
|
},
|
|
{
|
|
"cg_crosshairX", CVART_INTEGER,
|
|
"Crosshair X offset", CVARCAT_HUD, "X-axis offset from screen center", ""
|
|
},
|
|
{
|
|
"cg_crosshairY", CVART_INTEGER,
|
|
"Crosshair Y offset", CVARCAT_HUD, "Y-axis offset from screen center", ""
|
|
},
|
|
{
|
|
"cg_simpleItems", CVART_BOOL,
|
|
"Simple items", CVARCAT_GRAPHICS | CVARCAT_PERFORMANCE, "Shows items as sprites", ""
|
|
},
|
|
{
|
|
"cg_brassTime", CVART_INTEGER,
|
|
"Brass lifetime", CVARCAT_GRAPHICS, "MG/SG shell visibility duration, in milliseconds", ""
|
|
},
|
|
{
|
|
"cg_marks", CVART_INTEGER,
|
|
"Explosion marks lifetime", CVARCAT_GRAPHICS, "Explosion marks visibility duration, in milliseconds", ""
|
|
},
|
|
{
|
|
"cg_railTrailTime", CVART_INTEGER,
|
|
"Rail trails lifetime", CVARCAT_GRAPHICS, "Rail trails visibility duration, in milliseconds", ""
|
|
},
|
|
{
|
|
"cg_errordecay", CVART_INTEGER,
|
|
"Prediction error decay", CVARCAT_NETWORK, "Duration for client-side mispredictions smoothing, in milliseconds", ""
|
|
},
|
|
{
|
|
"cg_predict", CVART_INTEGER,
|
|
"Player movement prediction", CVARCAT_NETWORK, "", "",
|
|
CVAR_GUI_VALUE("0", "Disabled", "")
|
|
CVAR_GUI_VALUE("1", "Enabled", "")
|
|
CVAR_GUI_VALUE("2", "Optimized", "Has errors and performance gains aren't significant")
|
|
},
|
|
{
|
|
"cg_noProjectileTrail", CVART_BOOL,
|
|
"Projectile trails", CVARCAT_GRAPHICS, "", "",
|
|
CVAR_GUI_VALUE("1", "None in water", "")
|
|
CVAR_GUI_VALUE("0", "Everywhere", "")
|
|
},
|
|
{
|
|
"cg_noTaunt", CVART_BOOL,
|
|
"Taunt sounds", CVARCAT_SOUND, "", "",
|
|
CVAR_GUI_VALUE("1", "Silence", "")
|
|
CVAR_GUI_VALUE("0", "Taunt sounds", "")
|
|
},
|
|
{
|
|
"cg_forceModel", CVART_BOOL,
|
|
"Force model on teammates", CVARCAT_GRAPHICS, "Draws your teammates with the same model as yours", ""
|
|
},
|
|
{
|
|
"cg_predictItems", CVART_BOOL,
|
|
"Item pick-up prediction", CVARCAT_NETWORK, "Disable if you get false pick-ups", ""
|
|
},
|
|
{
|
|
"cg_deferPlayers", CVART_BOOL,
|
|
"Delay model loads", CVARCAT_GRAPHICS | CVARCAT_PERFORMANCE, "Delays player model loads to avoid hitches", ""
|
|
},
|
|
{
|
|
"cg_drawFriend", CVART_BOOL,
|
|
"Friend markers", CVARCAT_HUD, "Draws triangles above teammates' heads", ""
|
|
},
|
|
{
|
|
"cg_teamChatsOnly", CVART_BOOL,
|
|
"Global chat sink", CVARCAT_HUD, "To which SuperHUD element does global chat go?", "Team chat always goes to the 'Chat' SuperHUD element",
|
|
CVAR_GUI_VALUE("0", "Chat", "")
|
|
CVAR_GUI_VALUE("1", "Console", "")
|
|
},
|
|
{
|
|
"cg_altLightning", CVART_STRING,
|
|
"LG beam style", CVARCAT_GRAPHICS, "In order: self, enemies, teammates",
|
|
"0 = Original (pre-TA) id LG beam\n"
|
|
"1 = CPMA lightning\n"
|
|
"2 = Thin lightning\n"
|
|
"3 = Lightning using 1.44 render"
|
|
},
|
|
{
|
|
"cg_altPlasma", CVART_BOOL,
|
|
"CPMA plasma projectile", CVARCAT_GRAPHICS, "Enables the CPMA plasma gun projectile", ""
|
|
},
|
|
{
|
|
"cg_autoAction", CVART_BITMASK,
|
|
"Automated actions", CVARCAT_GENERAL, "", "",
|
|
CVAR_GUI_VALUE("0", "Save stats to a .txt file", "")
|
|
CVAR_GUI_VALUE("1", "Take an end-game screenshot", "")
|
|
CVAR_GUI_VALUE("2", "Record a demo: match start", "Only if present at match start")
|
|
CVAR_GUI_VALUE("3", "Multi-view the game", "")
|
|
CVAR_GUI_VALUE("4", "Only if you're playing", "")
|
|
CVAR_GUI_VALUE("5", "Follow power-up", "")
|
|
CVAR_GUI_VALUE("6", "Follow killer", "")
|
|
CVAR_GUI_VALUE("7", "Record a demo: late join", "When not present at match start")
|
|
},
|
|
{
|
|
"cg_customLoc", CVART_BOOL,
|
|
"Custom map locations", CVARCAT_HUD, "Uses client-local map location names", "The locations are in .cfg files in the 'locs' folder"
|
|
},
|
|
{
|
|
"cg_nochatbeep", CVART_BOOL,
|
|
"Global chat beeps", CVARCAT_SOUND, "", "",
|
|
CVAR_GUI_VALUE("0", "Global chat beeps", "")
|
|
CVAR_GUI_VALUE("1", "Silence", "")
|
|
},
|
|
{
|
|
"cg_nomip", CVART_BITMASK,
|
|
"Picmip overrides", CVARCAT_GRAPHICS, "Enable to keep specific visuals sharp", "",
|
|
CVAR_GUI_VALUE("0", "Lightning beams", "")
|
|
CVAR_GUI_VALUE("1", "Plasma balls", "")
|
|
CVAR_GUI_VALUE("2", "Rocket and grenade explosions", "")
|
|
CVAR_GUI_VALUE("3", "Grenade projectiles", "")
|
|
CVAR_GUI_VALUE("4", "Bullet impact marks", "")
|
|
CVAR_GUI_VALUE("5", "Railgun impact mark", "")
|
|
CVAR_GUI_VALUE("6", "BFG explosion", "")
|
|
CVAR_GUI_VALUE("7", "Blood", "")
|
|
CVAR_GUI_VALUE("8", "Smoke", "")
|
|
CVAR_GUI_VALUE("9", "Rocket projectiles", "")
|
|
},
|
|
{
|
|
"cg_noteamchatbeep", CVART_BOOL,
|
|
"Team chat beeps", CVARCAT_SOUND, "", "",
|
|
CVAR_GUI_VALUE("1", "Silence", "")
|
|
CVAR_GUI_VALUE("0", "Team chat beeps", "")
|
|
},
|
|
{
|
|
"cg_oldCTFSounds", CVART_INTEGER,
|
|
"CTF sounds", CVARCAT_SOUND, "", "",
|
|
CVAR_GUI_VALUE("0", "Team Arena", "With voice-overs")
|
|
CVAR_GUI_VALUE("1", "Quake 3 1.17", "Same for both teams")
|
|
CVAR_GUI_VALUE("2", "Team-specific", "No voice-overs")
|
|
},
|
|
{
|
|
"cg_showPlayerLean", CVART_BOOL,
|
|
"Player model leaning", CVARCAT_GAMEPLAY, "Enables player model leaning", "Off is more accurate wrt collision models"
|
|
},
|
|
{
|
|
"cg_useScreenShotJPEG", CVART_BOOL,
|
|
"Automated screenshot format", CVARCAT_GENERAL, "", "",
|
|
CVAR_GUI_VALUE("0", "TARGA (.tga)", "")
|
|
CVAR_GUI_VALUE("1", "JPEG (.jpg)", "")
|
|
},
|
|
{
|
|
"color", CVART_COLOR_CHBLS,
|
|
"Player colors", CVARCAT_GRAPHICS, "", "",
|
|
},
|
|
{
|
|
"model", CVART_STRING,
|
|
"Player model", CVARCAT_GRAPHICS, "", ""
|
|
},
|
|
{
|
|
"nick", CVART_STRING,
|
|
"Nickname", CVARCAT_GENERAL, "Short name (max. 5 chars) for team overlays", ""
|
|
}
|
|
};
|
|
|
|
|
|
void CL_Init()
|
|
{
|
|
//QSUBSYSTEM_INIT_START( "Client" );
|
|
|
|
cls.fullClientShutDown = qfalse;
|
|
|
|
CL_ConInit();
|
|
|
|
CL_ClearState();
|
|
|
|
cls.state = CA_DISCONNECTED; // no longer CA_UNINITIALIZED
|
|
|
|
cls.realtime = 0;
|
|
|
|
Cvar_RegisterArray( cl_cvars, MODULE_CLIENT );
|
|
Cmd_RegisterArray( cl_cmds, MODULE_CLIENT );
|
|
|
|
CL_InitRef();
|
|
CL_InitInput();
|
|
|
|
SCR_Init();
|
|
|
|
Cbuf_Execute();
|
|
|
|
Cvar_Set( "cl_running", "1" );
|
|
|
|
CL_MapDownload_Init();
|
|
|
|
CL_IMGUI_Init();
|
|
|
|
//QSUBSYSTEM_INIT_DONE( "Client" );
|
|
}
|
|
|
|
|
|
void CL_Shutdown()
|
|
{
|
|
static qbool recursive = qfalse;
|
|
|
|
// check whether the client is running at all.
|
|
if(!(com_cl_running && com_cl_running->integer))
|
|
return;
|
|
|
|
Com_Printf( "----- CL_Shutdown -----\n" );
|
|
|
|
if ( recursive ) {
|
|
printf ("recursive shutdown\n");
|
|
return;
|
|
}
|
|
recursive = qtrue;
|
|
|
|
cls.fullClientShutDown = qtrue;
|
|
|
|
CL_Disconnect( qtrue );
|
|
|
|
S_Shutdown();
|
|
|
|
CL_ShutdownInput();
|
|
CL_ShutdownRef();
|
|
|
|
CL_ShutdownUI();
|
|
|
|
CL_MapDownload_Cancel();
|
|
|
|
Cmd_UnregisterModule( MODULE_CLIENT );
|
|
|
|
CL_ConShutdown();
|
|
|
|
CL_IMGUI_Shutdown();
|
|
|
|
Cvar_Set( "cl_running", "0" );
|
|
|
|
recursive = qfalse;
|
|
|
|
Com_Memset( &cls, 0, sizeof( cls ) );
|
|
|
|
Com_Printf( "-----------------------\n" );
|
|
}
|
|
|
|
|
|
void CL_SetMenuData( qboolean typeOnly )
|
|
{
|
|
for ( int i = 0; i < ARRAY_LEN( cpma_cvars ); ++i ) {
|
|
const cvarTableItemCPMA_t* const cvar = &cpma_cvars[i];
|
|
Cvar_SetDataType( cvar->name, cvar->type );
|
|
if ( !typeOnly ) {
|
|
Cvar_SetMenuData( cvar->name, cvar->categories, cvar->guiName, cvar->guiDesc, cvar->guiHelp, cvar->guiValues );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
qbool CL_DemoPlaying()
|
|
{
|
|
return clc.demoplaying;
|
|
}
|