cnq3/code/client/cl_main.cpp

/*
===========================================================================
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_allowDownload;
cvar_t	*cl_inGameVideo;

cvar_t	*cl_matchAlerts;

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 ) {
	int		index;

	// 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++;
	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 const int demo_protocols[] = { 68, 67, 66, 0 };

static void CL_WalkDemoExt( const char* arg, char* name, fileHandle_t* fh )
{
	*fh = 0;

	for (int i = 0; demo_protocols[i]; ++i)
	{
		Com_sprintf( name, MAX_OSPATH, "demos/%s.dm_%d", arg, demo_protocols[i] );
		FS_FOpenFileRead( name, fh, qtrue );
		if (*fh)
		{
			Com_Printf("Demo file: %s\n", name);
			return;
		}
	}

	Com_Printf( "No match: demos/%s.dm_*\n", arg );
}


void CL_PlayDemo_f()
{

	if (Cmd_Argc() != 2) {
		Com_Printf ("demo <demoname>\n");
		return;
	}

	// make sure a local server is killed
	Cvar_Set( "sv_killserver", "1" );

	CL_Disconnect( qtrue );
    char	name[MAX_OSPATH];

	// open the demo file
	const char* arg = Cmd_Argv(1);

	// check for an extension .dm_?? (?? is protocol)
	const char* ext = arg + strlen(arg) - 6;
	if ((strlen(arg) > 6) && (ext[0] == '.') && ((ext[1] == 'd') || (ext[1] == 'D')) && ((ext[2] == 'm') || (ext[2] == 'M')) && (ext[3] == '_'))
	{
		int protocol = atoi(ext + 4), i = 0;
		while (demo_protocols[i]) {
			if (demo_protocols[i] == protocol)
				break;
			++i;
		}
		if (demo_protocols[i])
		{
			Com_sprintf( name, sizeof(name), "demos/%s", arg );
			FS_FOpenFileRead( name, &clc.demofile, qtrue );
		} else {
            char	retry[MAX_OSPATH];

			Com_Printf("Protocol %d not supported for demos\n", protocol);
			Q_strncpyz(retry, arg, sizeof(retry));
			retry[strlen(retry)-6] = 0;
			CL_WalkDemoExt( retry, name, &clc.demofile );
		}
	} else {
		CL_WalkDemoExt( arg, name, &clc.demofile );
	}

	if (!clc.demofile) {
		Com_Error( ERR_DROP, "couldn't open %s", name);
		return;
	}
	Q_strncpyz( clc.demoName, Cmd_Argv(1), sizeof( clc.demoName ) );

	Con_Close();

	cls.state = CA_CONNECTED;
	clc.demoplaying = qtrue;
	Q_strncpyz( cls.servername, Cmd_Argv(1), sizeof( cls.servername ) );

	// 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)
{
	// clear sounds
	S_DisableSounds();
	// shutdown CGame
	CL_ShutdownCGame();
	// shutdown UI
	CL_ShutdownUI();

	// shutdown the renderer
	if ( re.Shutdown ) {
		re.Shutdown( qfalse );		// don't destroy window or context
	}

	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 {
		// clear nextmap so the cinematic shutdown doesn't execute it
		Cvar_Set( "nextmap", "" );
		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;
	}

	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;

	// Stop recording any video
	if( CL_VideoRecording( ) ) {
		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_f()
{
	if ( !strlen( cls.servername ) || !strcmp( cls.servername, "localhost" ) ) {
		Com_Printf( "Can't reconnect to localhost.\n" );
		return;
	}
	Cbuf_AddText( va("connect %s\n", cls.servername ) );
}


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* server = Cmd_Argv(1);

	if ( com_sv_running->integer && !strcmp( server, "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, server, sizeof(cls.servername) );

	if (!NET_StringToAdr( cls.servername, &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", cls.servername,
		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", server );
}


#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();
}


// returns qtrue if a download started
static qbool CL_StartDownloads()
{
	int mode = cl_allowDownload->integer;
	if (mode < -1 || mode > 1) {
		mode = 1;
	}

	// downloads disabled
	if (mode == 0) {
		// autodownload is disabled on the client
		// but 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"
					   "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) {
				// if autodownloading is not enabled on the server
				cls.state = CA_CONNECTED;
				CL_NextDownload();
				return qtrue;
			}
		}
		return qfalse;
	}

	//
	// CNQ3 downloads
	//

	// note: the use of FS_FileIsInPAK works here because it rejects paks that aren't in the pure list
	const qbool pureServer = Cvar_VariableIntegerValue("sv_pure"); // the cvar is in CS_SYSTEMINFO
	const qbool exactMatch = !clc.demoplaying && pureServer;
	const char* const serverInfo = cl.gameState.stringData + cl.gameState.stringOffsets[CS_SERVERINFO];
	const char* const mapName = Info_ValueForKey(serverInfo, "mapname");
	const char* const mapPath = va("maps/%s.bsp", mapName);
	if ((!exactMatch && FS_FileExists(mapPath)) || FS_FileIsInPAK(mapPath, NULL, NULL))
		return qfalse;

	// generate a checksum list of all the pure paks we're missing
	unsigned int pakChecksums[256];
	int pakCount;
	const char* const pakChecksumString = Info_ValueForKey(serverInfo, "sv_currentPak");
	unsigned int pakChecksum;
	if (sscanf(pakChecksumString, "%d", &pakChecksum) == 1 && 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, so no need to send a map name
			CL_PakDownload_Start(pakChecksums[0], qfalse) :
			// we send the map's name and a list of pk3 checksums (qmd4)
			CL_MapDownload_Start_PakChecksums(mapName, pakChecksums, pakCount, exactMatch);

		if (dlStarted) {
			cls.state = CA_CONNECTED;
			return qtrue;
		}
		return qfalse;
	}

	// we send the map's name only because we have no additional data and
	// an exact match isn't needed
	if (!exactMatch && CL_MapDownload_Start(mapName, qfalse)) {
		cls.state = CA_CONNECTED;
		return qtrue;
	}
	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_f();
		}
		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;
	}

	if ( ( !cl_paused->integer || !sv_paused->integer )
		&& cls.state >= CA_CONNECTED && cls.state != CA_CINEMATIC
		&& cls.realtime - clc.lastPacketTime > cl_timeout->value*1000) {
		if (++cl.timeoutcount > 5) {	// timeoutcount saves debugger
			Com_Printf ("\nServer connection timed out.\n");
			CL_Disconnect( qtrue );
			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->integer ) {
		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 ) ) );
	}
}


void CL_Frame( int msec )
{
	if ( !com_cl_running->integer ) {
		return;
	}

	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 );
	}

	// 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++;
}


///////////////////////////////////////////////////////////////


int CL_ScaledMilliseconds()
{
	return Sys_Milliseconds()*com_timescale->value;
}


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 = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
	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, 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( qtrue );
	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.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_FreeFile = FS_FreeFile;
	ri.FS_WriteFile = FS_WriteFile;
	ri.FS_FreeFileList = FS_FreeFileList;
	ri.FS_ListFiles = FS_ListFiles;
	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_UploadCinematic = CIN_UploadCinematic;
	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()
{
	// Settings may have changed so stop recording now
	if( CL_VideoRecording( ) ) {
		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();

	// start the cgame if connected
	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( Cmd_Argc( ) == 2 )
	{
		Com_sprintf( s, MAX_OSPATH, "videos/%s.avi", Cmd_Argv( 1 ) );
	}
	else
	{
		qtime_t t;
		Com_RealTime( &t );
		Com_sprintf( s, sizeof(s), "videos/%d_%02d_%02d-%02d_%02d_%02d.avi",
				1900+t.tm_year, 1+t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec );
	}

	Com_Printf( "recording to %s\n", s );
	CL_OpenAVIForWriting( s );
}


static void CL_StopVideo_f()
{
	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_CallVote_f()
{
	CL_ForwardCommandToServer( Cmd_Cmd() );
}


static void CL_CompleteCallVote_f( int startArg, int compArg )
{
	if ( compArg == startArg + 2 && !Q_stricmp( Cmd_Argv( startArg + 1 ), "map" ) )
		Field_AutoCompleteCustom( startArg, compArg, &Field_AutoCompleteMapName );
}


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 );
}


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 ( FS_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 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, "server password, used by /rcon" },
	{ &cl_timedemo, "timedemo", "0", 0, CVART_BOOL, NULL, NULL, "demo benchmarking mode" },
	{ &cl_aviFrameRate, "cl_aviFrameRate", "25", CVAR_ARCHIVE, CVART_INTEGER, "1", "250", "frame-rate for /video" },
	{ &cl_aviMotionJpeg, "cl_aviMotionJpeg", "1", CVAR_ARCHIVE, CVART_BOOL, NULL, NULL, "/video stores frames as JPEGs" },
	{ &rconAddress, "rconAddress", "", 0, CVART_STRING, NULL, NULL, "IP address of the server to /rcon to" },
	{ &cl_maxpackets, "cl_maxpackets", "125", CVAR_ARCHIVE, CVART_INTEGER, "15", "125", "max. packet upload rate" },
	{ &cl_packetdup, "cl_packetdup", "1", CVAR_ARCHIVE, CVART_INTEGER, "0", "5", "number of extra transmissions per packet" },
	{ &cl_allowDownload, "cl_allowDownload", "1", CVAR_ARCHIVE, CVART_INTEGER, "-1", "1", help_cl_allowDownload },
	{ &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" },
	{ NULL, "rate", "25000", CVAR_USERINFO | CVAR_ARCHIVE, CVART_INTEGER, "4000", "99999", "network transfer rate" },
	{ NULL, "snaps", "30", CVAR_USERINFO | CVAR_ARCHIVE, CVART_INTEGER }, // documented by the mod
	{ NULL, "password", "", CVAR_USERINFO, CVART_STRING, NULL, NULL, "used by /connect" },
	{ &cl_matchAlerts, "cl_matchAlerts", "7", CVAR_ARCHIVE, CVART_BITMASK, "0", XSTRING(MAF_MAX), help_cl_matchAlerts }
};


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" },

	// we use these until we get proper handling on the mod side
	{ "cv", CL_CallVote_f, CL_CompleteCallVote_f, "calls a vote" },
	{ "callvote", CL_CallVote_f, CL_CompleteCallVote_f, "calls a vote" }
};


void CL_Init()
{
	//QSUBSYSTEM_INIT_START( "Client" );

	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();

	//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;

	CL_Disconnect( qtrue );

	S_Shutdown();

	CL_ShutdownInput();
	CL_ShutdownRef();

	CL_ShutdownUI();

	CL_MapDownload_Cancel();

	Cmd_UnregisterModule( MODULE_CLIENT );

	CL_ConShutdown();

	Cvar_Set( "cl_running", "0" );

	recursive = qfalse;

	Com_Memset( &cls, 0, sizeof( cls ) );

	Com_Printf( "-----------------------\n" );
}