client.h File Reference

#include "../game/q_shared.h"
#include "../qcommon/qcommon.h"
#include "../renderer/tr_public.h"
#include "../ui/ui_public.h"
#include "keys.h"
#include "snd_public.h"
#include "../cgame/cg_public.h"
#include "../game/bg_public.h"

Include dependency graph for client.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	clientActive_t
struct	clientConnection_t
struct	clientStatic_t
struct	clSnapshot_t
struct	kbutton_t
struct	outPacket_t
struct	ping_t
struct	serverAddress_t
struct	serverInfo_t
Defines
#define	MAX_PARSE_ENTITIES   2048
#define	RETRANSMIT_TIMEOUT   3000
Functions
void	CIN_CloseAllVideos (void)
void	CIN_DrawCinematic (int handle)
int	CIN_PlayCinematic (const char *arg0, int xpos, int ypos, int width, int height, int bits)
e_status	CIN_RunCinematic (int handle)
void	CIN_SetExtents (int handle, int x, int y, int w, int h)
void	CIN_SetLooping (int handle, qboolean loop)
e_status	CIN_StopCinematic (int handle)
void	CIN_UploadCinematic (int handle)
void	CL_AddReliableCommand (const char *cmd)
qboolean	CL_CDKeyValidate (const char *key, const char *checksum)
void	CL_CGameRendering (stereoFrame_t stereo)
void	CL_ClearPing (int n)
void	CL_ClearState (void)
void	CL_Disconnect_f (void)
void	CL_FavoriteServers_f (void)
void	CL_FirstSnapshot (void)
void	CL_FlushMemory (void)
qboolean	CL_GameCommand (void)
void	CL_GetChallengePacket (void)
void	CL_GetPing (int n, char *buf, int buflen, int *pingtime)
void	CL_GetPingInfo (int n, char *buf, int buflen)
int	CL_GetPingQueueCount (void)
void	CL_GlobalServers_f (void)
void	CL_Init (void)
void	CL_InitCGame (void)
void	CL_InitDownloads (void)
void	CL_InitInput (void)
void	CL_InitRef (void)
void	CL_InitUI (void)
float	CL_KeyState (kbutton_t *key)
void	CL_LocalServers_f (void)
qboolean	CL_Netchan_Process (netchan_t *chan, msg_t *msg)
void	CL_Netchan_Transmit (netchan_t *chan, msg_t *msg)
void	CL_Netchan_TransmitNextFragment (netchan_t *chan)
void	CL_NextDemo (void)
void	CL_NextDownload (void)
void	CL_ParseServerMessage (msg_t *msg)
void	CL_Ping_f (void)
void	CL_PlayCinematic_f (void)
void	CL_ReadDemoMessage (void)
void	CL_ReadPackets (void)
void	CL_SendCmd (void)
void	CL_ServerInfoPacket (netadr_t from, msg_t *msg)
int	CL_ServerStatus (char *serverAddress, char *serverStatusString, int maxLen)
void	CL_SetCGameTime (void)
void	CL_ShaderStateChanged (void)
void	CL_ShutdownAll (void)
void	CL_ShutdownCGame (void)
void	CL_ShutdownRef (void)
void	CL_ShutdownUI (void)
void	CL_Snd_Restart_f (void)
void	CL_StartDemoLoop (void)
void	CL_StartHunkUsers (void)
void	CL_SystemInfoChanged (void)
qboolean	CL_UpdateVisiblePings_f (int source)
void	CL_VerifyCode (void)
void	CL_Vid_Restart_f (void)
void	CL_WritePacket (void)
void	Con_Bottom (void)
void	Con_CheckResize (void)
void	Con_Clear_f (void)
void	Con_ClearNotify (void)
void	Con_Close (void)
void	Con_DrawCharacter (int cx, int line, int num)
void	Con_DrawConsole (void)
void	Con_DrawNotify (void)
void	Con_Init (void)
void	Con_PageDown (void)
void	Con_PageUp (void)
void	Con_RunConsole (void)
void	Con_ToggleConsole_f (void)
void	Con_Top (void)
void	IN_CenterView (void)
int	Key_GetCatcher (void)
char *	Key_KeynumToString (int keynum)
void	Key_SetCatcher (int catcher)
void	LAN_LoadCachedServers ()
void	LAN_SaveServersToCache ()
void	SCR_AdjustFrom640 (float *x, float *y, float *w, float *h)
void	SCR_DebugGraph (float value, int color)
void	SCR_DrawBigString (int x, int y, const char *s, float alpha)
void	SCR_DrawBigStringColor (int x, int y, const char *s, vec4_t color)
void	SCR_DrawCinematic (void)
void	SCR_DrawNamedPic (float x, float y, float width, float height, const char *picname)
void	SCR_DrawPic (float x, float y, float width, float height, qhandle_t hShader)
void	SCR_DrawSmallChar (int x, int y, int ch)
void	SCR_DrawSmallStringExt (int x, int y, const char *string, float *setColor, qboolean forceColor)
void	SCR_FillRect (float x, float y, float width, float height, const float *color)
int	SCR_GetBigStringWidth (const char *str)
void	SCR_Init (void)
void	SCR_RunCinematic (void)
void	SCR_StopCinematic (void)
void	SCR_UpdateScreen (void)
Variables
vm_t *	cgvm
clientActive_t	cl
cvar_t *	cl_activeAction
cvar_t *	cl_allowDownload
cvar_t *	cl_anglespeedkey
int	cl_connectedToPureServer
cvar_t *	cl_conXOffset
cvar_t *	cl_debugMove
cvar_t *	cl_freelook
cvar_t *	cl_freezeDemo
cvar_t *	cl_inGameVideo
cvar_t *	cl_maxpackets
cvar_t *	cl_mouseAccel
cvar_t *	cl_nodelta
cvar_t *	cl_noprint
cvar_t *	cl_packetdup
cvar_t *	cl_pitchspeed
cvar_t *	cl_run
cvar_t *	cl_sensitivity
cvar_t *	cl_showMouseRate
cvar_t *	cl_shownet
cvar_t *	cl_showSend
cvar_t *	cl_showTimeDelta
cvar_t *	cl_timedemo
cvar_t *	cl_timegraph
cvar_t *	cl_timeNudge
cvar_t *	cl_yawspeed
clientConnection_t	clc
clientStatic_t	cls
int	g_console_field_width
kbutton_t	in_klook
kbutton_t	in_mlook
kbutton_t	in_speed
kbutton_t	in_strafe
cvar_t *	m_filter
cvar_t *	m_forward
cvar_t *	m_pitch
cvar_t *	m_side
cvar_t *	m_yaw
refexport_t	re
vm_t *	uivm

---

Define Documentation

#define MAX_PARSE_ENTITIES   2048

Definition at line 78 of file client.h. Referenced by CL_DeltaEntity(), CL_GetParseEntityState(), CL_GetSnapshot(), CL_ParsePacketEntities(), and CL_ParseSnapshot().

#define RETRANSMIT_TIMEOUT   3000

Definition at line 33 of file client.h.

---

Function Documentation

void CIN_CloseAllVideos (  void   )

Definition at line 143 of file cl_cin.c. { int i; for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) { if (cinTable[i].fileName[0] != 0 ) { CIN_StopCinematic(i); } } }

void CIN_DrawCinematic (  int  handle  )

Definition at line 1589 of file cl_cin.c. References cin_cache::buf, byte, cin_cache::CIN_HEIGHT, cin_cache::CIN_WIDTH, cinTable, cin_cache::dirty, refexport_t::DrawStretchRaw, cin_cache::drawX, cin_cache::drawY, h(), cin_cache::height, Hunk_AllocateTempMemory(), Hunk_FreeTempMemory(), MAX_VIDEO_HANDLES, qtrue, re, SCR_AdjustFrom640(), cin_cache::status, w, cin_cache::width, x, cin_cache::xpos, y, and cin_cache::ypos. Referenced by CL_CgameSystemCalls(), CL_UISystemCalls(), and SCR_DrawCinematic(). { float x, y, w, h; byte *buf; if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return; if (!cinTable[handle].buf) { return; } x = cinTable[handle].xpos; y = cinTable[handle].ypos; w = cinTable[handle].width; h = cinTable[handle].height; buf = cinTable[handle].buf; SCR_AdjustFrom640( &x, &y, &w, &h ); if (cinTable[handle].dirty && (cinTable[handle].CIN_WIDTH != cinTable[handle].drawX || cinTable[handle].CIN_HEIGHT != cinTable[handle].drawY)) { int ix, iy, *buf2, *buf3, xm, ym, ll; xm = cinTable[handle].CIN_WIDTH/256; ym = cinTable[handle].CIN_HEIGHT/256; ll = 8; if (cinTable[handle].CIN_WIDTH==512) { ll = 9; } buf3 = (int*)buf; buf2 = Hunk_AllocateTempMemory( 256*256*4 ); if (xm==2 && ym==2) { byte *bc2, *bc3; int ic, iiy; bc2 = (byte *)buf2; bc3 = (byte *)buf3; for (iy = 0; iy<256; iy++) { iiy = iy<<12; for (ix = 0; ix<2048; ix+=8) { for(ic = ix;ic<(ix+4);ic++) { *bc2=(bc3[iiy+ic]+bc3[iiy+4+ic]+bc3[iiy+2048+ic]+bc3[iiy+2048+4+ic])>>2; bc2++; } } } } else if (xm==2 && ym==1) { byte *bc2, *bc3; int ic, iiy; bc2 = (byte *)buf2; bc3 = (byte *)buf3; for (iy = 0; iy<256; iy++) { iiy = iy<<11; for (ix = 0; ix<2048; ix+=8) { for(ic = ix;ic<(ix+4);ic++) { *bc2=(bc3[iiy+ic]+bc3[iiy+4+ic])>>1; bc2++; } } } } else { for (iy = 0; iy<256; iy++) { for (ix = 0; ix<256; ix++) { buf2[(iy<<8)+ix] = buf3[((iy*ym)<<ll) + (ix*xm)]; } } } re.DrawStretchRaw( x, y, w, h, 256, 256, (byte *)buf2, handle, qtrue); cinTable[handle].dirty = qfalse; Hunk_FreeTempMemory(buf2); return; } re.DrawStretchRaw( x, y, w, h, cinTable[handle].drawX, cinTable[handle].drawY, buf, handle, cinTable[handle].dirty); cinTable[handle].dirty = qfalse; }

Here is the call graph for this function:

int CIN_PlayCinematic (  const char *  arg0, int  xpos, int  ypos, int  width, int  height, int  bits )

Definition at line 1481 of file cl_cin.c. References cin_cache::alterGameState, cin, CIN_HandleForVideo(), cin_cache::CIN_HEIGHT, CIN_loop, CIN_SetExtents(), CIN_SetLooping(), cin_cache::CIN_WIDTH, cinTable, cl_inGameVideo, cls, Com_DPrintf(), Com_Memset(), Com_sprintf(), Con_Close(), cinematics_t::currentHandle, currentHandle, cinematics_t::file, cin_cache::fileName, FS_FOpenFileRead(), FS_Read(), h(), cin_cache::holdAtEnd, i, cin_cache::iFile, initRoQ(), cvar_s::integer, name, NULL, cin_cache::playonwalls, qtrue, RoQ_init(), RoQShutdown(), cin_cache::ROQSize, s_rawend, cin_cache::shader, cin_cache::silent, clientStatic_t::state, cin_cache::status, strcmp(), strcpy(), strstr(), Sys_BeginStreamedFile(), UI_SET_ACTIVE_MENU, UIMENU_NONE, uivm, VM_Call(), w, x, and y. Referenced by CL_CgameSystemCalls(), CL_PlayCinematic_f(), and CL_UISystemCalls(). { unsigned short RoQID; char name[MAX_OSPATH]; int i; if (strstr(arg, "/") == NULL && strstr(arg, "\\") == NULL) { Com_sprintf (name, sizeof(name), "video/%s", arg); } else { Com_sprintf (name, sizeof(name), "%s", arg); } if (!(systemBits & CIN_system)) { for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) { if (!strcmp(cinTable[i].fileName, name) ) { return i; } } } Com_DPrintf("SCR_PlayCinematic( %s )\n", arg); Com_Memset(&cin, 0, sizeof(cinematics_t) ); currentHandle = CIN_HandleForVideo(); cin.currentHandle = currentHandle; strcpy(cinTable[currentHandle].fileName, name); cinTable[currentHandle].ROQSize = 0; cinTable[currentHandle].ROQSize = FS_FOpenFileRead (cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, qtrue); if (cinTable[currentHandle].ROQSize<=0) { Com_DPrintf("play(%s), ROQSize<=0\n", arg); cinTable[currentHandle].fileName[0] = 0; return -1; } CIN_SetExtents(currentHandle, x, y, w, h); CIN_SetLooping(currentHandle, (systemBits & CIN_loop)!=0); cinTable[currentHandle].CIN_HEIGHT = DEFAULT_CIN_HEIGHT; cinTable[currentHandle].CIN_WIDTH = DEFAULT_CIN_WIDTH; cinTable[currentHandle].holdAtEnd = (systemBits & CIN_hold) != 0; cinTable[currentHandle].alterGameState = (systemBits & CIN_system) != 0; cinTable[currentHandle].playonwalls = 1; cinTable[currentHandle].silent = (systemBits & CIN_silent) != 0; cinTable[currentHandle].shader = (systemBits & CIN_shader) != 0; if (cinTable[currentHandle].alterGameState) { // close the menu if ( uivm ) { VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_NONE ); } } else { cinTable[currentHandle].playonwalls = cl_inGameVideo->integer; } initRoQ(); FS_Read (cin.file, 16, cinTable[currentHandle].iFile); RoQID = (unsigned short)(cin.file[0]) + (unsigned short)(cin.file[1])*256; if (RoQID == 0x1084) { RoQ_init(); // FS_Read (cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile); // let the background thread start reading ahead Sys_BeginStreamedFile( cinTable[currentHandle].iFile, 0x10000 ); cinTable[currentHandle].status = FMV_PLAY; Com_DPrintf("trFMV::play(), playing %s\n", arg); if (cinTable[currentHandle].alterGameState) { cls.state = CA_CINEMATIC; } Con_Close(); s_rawend = s_soundtime; return currentHandle; } Com_DPrintf("trFMV::play(), invalid RoQ ID\n"); RoQShutdown(); return -1; }

Here is the call graph for this function:

e_status CIN_RunCinematic (  int  handle  )

Definition at line 1405 of file cl_cin.c. References abs(), cin_cache::alterGameState, cin, cinTable, CL_ScaledMilliseconds(), cls, com_timescale, currentHandle, cinematics_t::currentHandle, e_status, cin_cache::lastTime, cin_cache::looping, MAX_VIDEO_HANDLES, cin_cache::numQuads, cin_cache::playonwalls, RoQInterrupt(), RoQReset(), RoQShutdown(), cin_cache::shader, cin_cache::startTime, clientStatic_t::state, cin_cache::status, cin_cache::tfps, and cvar_s::value. Referenced by CL_CgameSystemCalls(), CL_UISystemCalls(), and SCR_RunCinematic(). { // bk001204 - init int start = 0; int thisTime = 0; if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF; if (cin.currentHandle != handle) { currentHandle = handle; cin.currentHandle = currentHandle; cinTable[currentHandle].status = FMV_EOF; RoQReset(); } if (cinTable[handle].playonwalls < -1) { return cinTable[handle].status; } currentHandle = handle; if (cinTable[currentHandle].alterGameState) { if ( cls.state != CA_CINEMATIC ) { return cinTable[currentHandle].status; } } if (cinTable[currentHandle].status == FMV_IDLE) { return cinTable[currentHandle].status; } // we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer thisTime = CL_ScaledMilliseconds()*com_timescale->value; if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime))>100) { cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime; } // we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer cinTable[currentHandle].tfps = ((((CL_ScaledMilliseconds()*com_timescale->value) - cinTable[currentHandle].startTime)*3)/100); start = cinTable[currentHandle].startTime; while( (cinTable[currentHandle].tfps != cinTable[currentHandle].numQuads) && (cinTable[currentHandle].status == FMV_PLAY) ) { RoQInterrupt(); if (start != cinTable[currentHandle].startTime) { // we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer cinTable[currentHandle].tfps = ((((CL_ScaledMilliseconds()*com_timescale->value) - cinTable[currentHandle].startTime)*3)/100); start = cinTable[currentHandle].startTime; } } cinTable[currentHandle].lastTime = thisTime; if (cinTable[currentHandle].status == FMV_LOOPED) { cinTable[currentHandle].status = FMV_PLAY; } if (cinTable[currentHandle].status == FMV_EOF) { if (cinTable[currentHandle].looping) { RoQReset(); } else { RoQShutdown(); } } return cinTable[currentHandle].status; }

Here is the call graph for this function:

void CIN_SetExtents (  int  handle, int  x, int  y, int  w, int  h )

Definition at line 1569 of file cl_cin.c. References cinTable, cin_cache::dirty, cin_cache::height, MAX_VIDEO_HANDLES, cin_cache::status, cin_cache::width, cin_cache::xpos, and cin_cache::ypos. Referenced by CIN_PlayCinematic(), CL_CgameSystemCalls(), and CL_UISystemCalls(). { if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return; cinTable[handle].xpos = x; cinTable[handle].ypos = y; cinTable[handle].width = w; cinTable[handle].height = h; cinTable[handle].dirty = qtrue; }

void CIN_SetLooping (  int  handle, qboolean  loop )

Definition at line 1578 of file cl_cin.c. References cinTable, cin_cache::looping, MAX_VIDEO_HANDLES, and cin_cache::status. Referenced by CIN_PlayCinematic(). { if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return; cinTable[handle].looping = loop; }

e_status CIN_StopCinematic (  int  handle  )

Definition at line 1374 of file cl_cin.c. References cin_cache::alterGameState, cin_cache::buf, cinTable, cls, Com_DPrintf(), currentHandle, e_status, MAX_VIDEO_HANDLES, RoQShutdown(), clientStatic_t::state, and cin_cache::status. Referenced by CIN_CloseAllVideos(), CL_CgameSystemCalls(), CL_UISystemCalls(), and SCR_StopCinematic(). { if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF; currentHandle = handle; Com_DPrintf("trFMV::stop(), closing %s\n", cinTable[currentHandle].fileName); if (!cinTable[currentHandle].buf) { return FMV_EOF; } if (cinTable[currentHandle].alterGameState) { if ( cls.state != CA_CINEMATIC ) { return cinTable[currentHandle].status; } } cinTable[currentHandle].status = FMV_EOF; RoQShutdown(); return FMV_EOF; }

Here is the call graph for this function:

void CIN_UploadCinematic (  int  handle  )

Definition at line 1718 of file cl_cin.c. References cin_cache::buf, cinTable, cl_inGameVideo, cin_cache::dirty, cvar_s::integer, cin_cache::playonwalls, re, and refexport_t::UploadCinematic. { if (handle >= 0 && handle < MAX_VIDEO_HANDLES) { if (!cinTable[handle].buf) { return; } if (cinTable[handle].playonwalls <= 0 && cinTable[handle].dirty) { if (cinTable[handle].playonwalls == 0) { cinTable[handle].playonwalls = -1; } else { if (cinTable[handle].playonwalls == -1) { cinTable[handle].playonwalls = -2; } else { cinTable[handle].dirty = qfalse; } } } re.UploadCinematic( 256, 256, 256, 256, cinTable[handle].buf, handle, cinTable[handle].dirty); if (cl_inGameVideo->integer == 0 && cinTable[handle].playonwalls == 1) { cinTable[handle].playonwalls--; } } }

void CL_AddReliableCommand (  const char *  cmd  )

Definition at line 133 of file cl_main.c. References clc, Com_Error(), ERR_DROP, MAX_RELIABLE_COMMANDS, Q_strncpyz(), clientConnection_t::reliableAcknowledge, clientConnection_t::reliableCommands, and clientConnection_t::reliableSequence. Referenced by CL_BeginDownload(), CL_CgameSystemCalls(), CL_CheckUserinfo(), CL_Disconnect(), CL_DownloadsComplete(), CL_ForwardCommandToServer(), CL_ForwardToServer_f(), CL_ParseDownload(), CL_ResetPureClientAtServer(), CL_SendPureChecksums(), and Message_Key(). { 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 ] ) ); }

Here is the call graph for this function:

qboolean CL_CDKeyValidate (  const char *  key, const char *  checksum )

Definition at line 3265 of file cl_main.c. { 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; }

void CL_CGameRendering (  stereoFrame_t  stereo  )

Definition at line 794 of file cl_cgame.c. References CG_DRAW_ACTIVE_FRAME, cgvm, cl, clc, clientConnection_t::demoplaying, clientActive_t::serverTime, VM_Call(), and VM_Debug(). Referenced by SCR_DrawScreenField(). { VM_Call( cgvm, CG_DRAW_ACTIVE_FRAME, cl.serverTime, stereo, clc.demoplaying ); VM_Debug( 0 ); }

Here is the call graph for this function:

void CL_ClearPing (  int  n  )

Definition at line 2986 of file cl_main.c. References ping_t::adr, cl_pinglist, and netadr_t::port. Referenced by CL_UpdateVisiblePings_f(), and LAN_ClearPing(). { if (n < 0 || n >= MAX_PINGREQUESTS) return; cl_pinglist[n].adr.port = 0; }

void CL_ClearState (  void   )

Definition at line 705 of file cl_main.c. References cl, and Com_Memset(). Referenced by CL_Disconnect(), CL_Init(), and CL_ParseGamestate(). { // S_StopAllSounds(); Com_Memset( &cl, 0, sizeof( cl ) ); }

Here is the call graph for this function:

void CL_Disconnect_f (  void   )

Definition at line 998 of file cl_main.c. References CA_DISCONNECTED, cls, Com_Error(), Cvar_Set(), ERR_DISCONNECT, SCR_StopCinematic(), and clientStatic_t::state. Referenced by CL_Init(), and CL_KeyEvent(). { SCR_StopCinematic(); Cvar_Set("ui_singlePlayerActive", "0"); if ( cls.state != CA_DISCONNECTED && cls.state != CA_CINEMATIC ) { Com_Error (ERR_DISCONNECT, "Disconnected from server"); } }

Here is the call graph for this function:

void CL_FavoriteServers_f (  void   )

void CL_FirstSnapshot (  void   )

Definition at line 885 of file cl_cgame.c. References Cbuf_AddText(), cl, cl_activeAction, clc, cls, Cvar_Set(), clientActive_t::oldServerTime, clientStatic_t::realtime, clSnapshot_t::serverTime, clientActive_t::serverTimeDelta, clientActive_t::snap, clSnapshot_t::snapFlags, clientStatic_t::state, cvar_s::string, Sys_BeginProfiling(), and clientConnection_t::timeDemoBaseTime. Referenced by CL_SetCGameTime(). { // ignore snapshots that don't have entities if ( cl.snap.snapFlags & SNAPFLAG_NOT_ACTIVE ) { return; } cls.state = CA_ACTIVE; // set the timedelta so we are exactly on this first frame cl.serverTimeDelta = cl.snap.serverTime - cls.realtime; cl.oldServerTime = cl.snap.serverTime; clc.timeDemoBaseTime = cl.snap.serverTime; // if this is the first frame of active play, // execute the contents of activeAction now // this is to allow scripting a timedemo to start right // after loading if ( cl_activeAction->string[0] ) { Cbuf_AddText( cl_activeAction->string ); Cvar_Set( "activeAction", "" ); } Sys_BeginProfiling(); }

Here is the call graph for this function:

void CL_FlushMemory (  void   )

Definition at line 637 of file cl_main.c. { // 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(); }

qboolean CL_GameCommand (  void   )

Definition at line 779 of file cl_cgame.c. { if ( !cgvm ) { return qfalse; } return VM_Call( cgvm, CG_CONSOLE_COMMAND ); }

void CL_GetChallengePacket (  void   )

void CL_GetPing (  int  n, char *  buf, int  buflen, int *  pingtime )

Definition at line 2910 of file cl_main.c. References ping_t::adr, cl_pinglist, CL_SetServerInfoByAddress(), cls, Cvar_VariableIntegerValue(), n, NET_AdrToString(), netadr_t::port, Q_strncpyz(), clientStatic_t::realtime, ping_t::start, ping_t::time, and time(). Referenced by CL_UpdateVisiblePings_f(), and LAN_GetPing(). { const char *str; int time; int maxPing; if (!cl_pinglist[n].adr.port) { // empty slot buf[0] = '\0'; *pingtime = 0; return; } str = NET_AdrToString( cl_pinglist[n].adr ); Q_strncpyz( buf, str, buflen ); time = cl_pinglist[n].time; if (!time) { // check for timeout time = cls.realtime - cl_pinglist[n].start; maxPing = Cvar_VariableIntegerValue( "cl_maxPing" ); if( maxPing < 100 ) { maxPing = 100; } if (time < maxPing) { // not timed out yet time = 0; } } CL_SetServerInfoByAddress(cl_pinglist[n].adr, cl_pinglist[n].info, cl_pinglist[n].time); *pingtime = time; }

Here is the call graph for this function:

void CL_GetPingInfo (  int  n, char *  buf, int  buflen )

Definition at line 2968 of file cl_main.c. References ping_t::adr, cl_pinglist, n, netadr_t::port, and Q_strncpyz(). Referenced by LAN_GetPingInfo(). { if (!cl_pinglist[n].adr.port) { // empty slot if (buflen) buf[0] = '\0'; return; } Q_strncpyz( buf, cl_pinglist[n].info, buflen ); }

Here is the call graph for this function:

int CL_GetPingQueueCount (  void   )

Definition at line 2999 of file cl_main.c. References ping_t::adr, count, i, and netadr_t::port. Referenced by CL_UpdateVisiblePings_f(), and LAN_GetPingQueueCount(). { int i; int count; ping_t* pingptr; count = 0; pingptr = cl_pinglist; for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ ) { if (pingptr->adr.port) { count++; } } return (count); }

void CL_GlobalServers_f (  void   )

Definition at line 2856 of file cl_main.c. References atoi, BigShort(), cls, Cmd_Argc(), Cmd_Argv(), Com_Printf(), count, Cvar_VariableValue(), i, MASTER_SERVER_NAME, clientStatic_t::masterNum, NET_OutOfBandPrint(), NET_StringToAdr(), NS_SERVER, clientStatic_t::numglobalservers, clientStatic_t::nummplayerservers, clientStatic_t::pingUpdateSource, netadr_t::port, PORT_MASTER, sprintf(), strlen(), and netadr_t::type. Referenced by CL_Init(). { netadr_t to; int i; int count; char *buffptr; char command[1024]; if ( Cmd_Argc() < 3) { Com_Printf( "usage: globalservers <master# 0-1> <protocol> [keywords]\n"); return; } cls.masterNum = atoi( Cmd_Argv(1) ); Com_Printf( "Requesting servers from the master...\n"); // reset the list, waiting for response // -1 is used to distinguish a "no response" if( cls.masterNum == 1 ) { NET_StringToAdr( MASTER_SERVER_NAME, &to ); cls.nummplayerservers = -1; cls.pingUpdateSource = AS_MPLAYER; } else { NET_StringToAdr( MASTER_SERVER_NAME, &to ); cls.numglobalservers = -1; cls.pingUpdateSource = AS_GLOBAL; } to.type = NA_IP; to.port = BigShort(PORT_MASTER); sprintf( command, "getservers %s", Cmd_Argv(2) ); // tack on keywords buffptr = command + strlen( command ); count = Cmd_Argc(); for (i=3; i<count; i++) buffptr += sprintf( buffptr, " %s", Cmd_Argv(i) ); // if we are a demo, automatically add a "demo" keyword if ( Cvar_VariableValue( "fs_restrict" ) ) { buffptr += sprintf( buffptr, " demo" ); } NET_OutOfBandPrint( NS_SERVER, to, command ); }

Here is the call graph for this function:

void CL_Init (  void   )

Definition at line 2265 of file cl_main.c. { Com_Printf( "----- Client Initialization -----\n" ); Con_Init (); CL_ClearState (); cls.state = CA_DISCONNECTED; // no longer CA_UNINITIALIZED cls.realtime = 0; CL_InitInput (); // // register our variables // cl_noprint = Cvar_Get( "cl_noprint", "0", 0 ); cl_motd = Cvar_Get ("cl_motd", "1", 0); cl_timeout = Cvar_Get ("cl_timeout", "200", 0); cl_timeNudge = Cvar_Get ("cl_timeNudge", "0", CVAR_TEMP ); cl_shownet = Cvar_Get ("cl_shownet", "0", CVAR_TEMP ); cl_showSend = Cvar_Get ("cl_showSend", "0", CVAR_TEMP ); cl_showTimeDelta = Cvar_Get ("cl_showTimeDelta", "0", CVAR_TEMP ); cl_freezeDemo = Cvar_Get ("cl_freezeDemo", "0", CVAR_TEMP ); rcon_client_password = Cvar_Get ("rconPassword", "", CVAR_TEMP ); cl_activeAction = Cvar_Get( "activeAction", "", CVAR_TEMP ); cl_timedemo = Cvar_Get ("timedemo", "0", 0); cl_avidemo = Cvar_Get ("cl_avidemo", "0", 0); cl_forceavidemo = Cvar_Get ("cl_forceavidemo", "0", 0); rconAddress = Cvar_Get ("rconAddress", "", 0); cl_yawspeed = Cvar_Get ("cl_yawspeed", "140", CVAR_ARCHIVE); cl_pitchspeed = Cvar_Get ("cl_pitchspeed", "140", CVAR_ARCHIVE); cl_anglespeedkey = Cvar_Get ("cl_anglespeedkey", "1.5", 0); cl_maxpackets = Cvar_Get ("cl_maxpackets", "30", CVAR_ARCHIVE ); cl_packetdup = Cvar_Get ("cl_packetdup", "1", CVAR_ARCHIVE ); cl_run = Cvar_Get ("cl_run", "1", CVAR_ARCHIVE); cl_sensitivity = Cvar_Get ("sensitivity", "5", CVAR_ARCHIVE); cl_mouseAccel = Cvar_Get ("cl_mouseAccel", "0", CVAR_ARCHIVE); cl_freelook = Cvar_Get( "cl_freelook", "1", CVAR_ARCHIVE ); cl_showMouseRate = Cvar_Get ("cl_showmouserate", "0", 0); cl_allowDownload = Cvar_Get ("cl_allowDownload", "0", CVAR_ARCHIVE); cl_conXOffset = Cvar_Get ("cl_conXOffset", "0", 0); #ifdef MACOS_X // In game video is REALLY slow in Mac OS X right now due to driver slowness cl_inGameVideo = Cvar_Get ("r_inGameVideo", "0", CVAR_ARCHIVE); #else cl_inGameVideo = Cvar_Get ("r_inGameVideo", "1", CVAR_ARCHIVE); #endif cl_serverStatusResendTime = Cvar_Get ("cl_serverStatusResendTime", "750", 0); // init autoswitch so the ui will have it correctly even // if the cgame hasn't been started Cvar_Get ("cg_autoswitch", "1", CVAR_ARCHIVE); m_pitch = Cvar_Get ("m_pitch", "0.022", CVAR_ARCHIVE); m_yaw = Cvar_Get ("m_yaw", "0.022", CVAR_ARCHIVE); m_forward = Cvar_Get ("m_forward", "0.25", CVAR_ARCHIVE); m_side = Cvar_Get ("m_side", "0.25", CVAR_ARCHIVE); #ifdef MACOS_X // Input is jittery on OS X w/o this m_filter = Cvar_Get ("m_filter", "1", CVAR_ARCHIVE); #else m_filter = Cvar_Get ("m_filter", "0", CVAR_ARCHIVE); #endif cl_motdString = Cvar_Get( "cl_motdString", "", CVAR_ROM ); Cvar_Get( "cl_maxPing", "800", CVAR_ARCHIVE ); // userinfo Cvar_Get ("name", "UnnamedPlayer", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("rate", "3000", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("snaps", "20", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("model", "sarge", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("headmodel", "sarge", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("team_model", "james", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("team_headmodel", "*james", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("g_redTeam", "Stroggs", CVAR_SERVERINFO | CVAR_ARCHIVE); Cvar_Get ("g_blueTeam", "Pagans", CVAR_SERVERINFO | CVAR_ARCHIVE); Cvar_Get ("color1", "4", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("color2", "5", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("handicap", "100", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("teamtask", "0", CVAR_USERINFO ); Cvar_Get ("sex", "male", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("cl_anonymous", "0", CVAR_USERINFO | CVAR_ARCHIVE ); Cvar_Get ("password", "", CVAR_USERINFO); Cvar_Get ("cg_predictItems", "1", CVAR_USERINFO | CVAR_ARCHIVE ); // cgame might not be initialized before menu is used Cvar_Get ("cg_viewsize", "100", CVAR_ARCHIVE ); // // register our commands // Cmd_AddCommand ("cmd", CL_ForwardToServer_f); Cmd_AddCommand ("configstrings", CL_Configstrings_f); Cmd_AddCommand ("clientinfo", CL_Clientinfo_f); Cmd_AddCommand ("snd_restart", CL_Snd_Restart_f); Cmd_AddCommand ("vid_restart", CL_Vid_Restart_f); Cmd_AddCommand ("disconnect", CL_Disconnect_f); Cmd_AddCommand ("record", CL_Record_f); Cmd_AddCommand ("demo", CL_PlayDemo_f); Cmd_AddCommand ("cinematic", CL_PlayCinematic_f); Cmd_AddCommand ("stoprecord", CL_StopRecord_f); Cmd_AddCommand ("connect", CL_Connect_f); Cmd_AddCommand ("reconnect", CL_Reconnect_f); Cmd_AddCommand ("localservers", CL_LocalServers_f); Cmd_AddCommand ("globalservers", CL_GlobalServers_f); Cmd_AddCommand ("rcon", CL_Rcon_f); Cmd_AddCommand ("setenv", CL_Setenv_f ); Cmd_AddCommand ("ping", CL_Ping_f ); Cmd_AddCommand ("serverstatus", CL_ServerStatus_f ); Cmd_AddCommand ("showip", CL_ShowIP_f ); Cmd_AddCommand ("fs_openedList", CL_OpenedPK3List_f ); Cmd_AddCommand ("fs_referencedList", CL_ReferencedPK3List_f ); Cmd_AddCommand ("model", CL_SetModel_f ); CL_InitRef(); SCR_Init (); Cbuf_Execute (); Cvar_Set( "cl_running", "1" ); Com_Printf( "----- Client Initialization Complete -----\n" ); }

void CL_InitCGame (  void   )

Definition at line 715 of file cl_cgame.c. References CG_INIT, cgvm, cl, CL_CgameSystemCalls(), cl_connectedToPureServer, clc, clientConnection_t::clientNum, cls, Com_Error(), Com_Printf(), Com_sprintf(), Com_TouchMemory(), Con_ClearNotify(), Con_Close(), Cvar_VariableValue(), refexport_t::EndRegistration, ERR_DROP, clientActive_t::gameState, Info_ValueForKey(), clientConnection_t::lastExecutedServerCommand, clientActive_t::mapname, re, clientConnection_t::serverMessageSequence, clientStatic_t::state, gameState_t::stringData, gameState_t::stringOffsets, Sys_LowPhysicalMemory(), Sys_Milliseconds(), VM_Call(), VM_Create(), and vmInterpret_t. Referenced by CL_DownloadsComplete(), and CL_Vid_Restart_f(). { const char *info; const char *mapname; int t1, t2; vmInterpret_t interpret; t1 = Sys_Milliseconds(); // put away the console Con_Close(); // find the current mapname info = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SERVERINFO ]; mapname = Info_ValueForKey( info, "mapname" ); Com_sprintf( cl.mapname, sizeof( cl.mapname ), "maps/%s.bsp", mapname ); // load the dll or bytecode if ( cl_connectedToPureServer != 0 ) { // if sv_pure is set we only allow qvms to be loaded interpret = VMI_COMPILED; } else { interpret = Cvar_VariableValue( "vm_cgame" ); } cgvm = VM_Create( "cgame", CL_CgameSystemCalls, interpret ); if ( !cgvm ) { Com_Error( ERR_DROP, "VM_Create on cgame failed" ); } cls.state = CA_LOADING; // init for this gamestate // use the lastExecutedServerCommand instead of the serverCommandSequence // otherwise server commands sent just before a gamestate are dropped VM_Call( cgvm, CG_INIT, clc.serverMessageSequence, clc.lastExecutedServerCommand, clc.clientNum ); // we will send a usercmd this frame, which // will cause the server to send us the first snapshot cls.state = CA_PRIMED; t2 = Sys_Milliseconds(); Com_Printf( "CL_InitCGame: %5.2f seconds\n", (t2-t1)/1000.0 ); // have the renderer touch all its images, so they are present // on the card even if the driver does deferred loading re.EndRegistration(); // make sure everything is paged in if (!Sys_LowPhysicalMemory()) { Com_TouchMemory(); } // clear anything that got printed Con_ClearNotify (); }

Here is the call graph for this function:

void CL_InitDownloads (  void   )

Definition at line 1454 of file cl_main.c. References cl_allowDownload, CL_DownloadsComplete(), CL_NextDownload(), clc, cls, Com_Printf(), clientConnection_t::downloadList, FS_ComparePaks(), cvar_s::integer, qfalse, qtrue, and clientStatic_t::state. Referenced by CL_ParseGamestate(). { char missingfiles[1024]; if ( !cl_allowDownload->integer ) { // autodownload is disabled on the client // but it's possible that some referenced files on the server are missing 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 wether we will successfully join or not Com_Printf( "\nWARNING: You are missing some files referenced by the server:\n%s" "You might not be able to join the game\n" "Go to the setting menu to turn on autodownload, or get the file elsewhere\n\n", missingfiles ); } } else 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; } } CL_DownloadsComplete(); }

Here is the call graph for this function:

void CL_InitInput (  void   )

Definition at line 837 of file cl_input.c. References cl_debugMove, cl_nodelta, Cmd_AddCommand(), Cvar_Get(), IN_BackDown(), IN_BackUp(), IN_Button0Down(), IN_Button0Up(), IN_Button10Down(), IN_Button10Up(), IN_Button11Down(), IN_Button11Up(), IN_Button12Down(), IN_Button12Up(), IN_Button13Down(), IN_Button13Up(), IN_Button14Down(), IN_Button14Up(), IN_Button1Down(), IN_Button1Up(), IN_Button2Down(), IN_Button2Up(), IN_Button3Down(), IN_Button3Up(), IN_Button4Down(), IN_Button4Up(), IN_Button5Down(), IN_Button5Up(), IN_Button6Down(), IN_Button6Up(), IN_Button7Down(), IN_Button7Up(), IN_Button8Down(), IN_Button8Up(), IN_Button9Down(), IN_Button9Up(), IN_CenterView(), IN_DownDown(), IN_DownUp(), IN_ForwardDown(), IN_ForwardUp(), IN_LeftDown(), IN_LeftUp(), IN_LookdownDown(), IN_LookdownUp(), IN_LookupDown(), IN_LookupUp(), IN_MLookDown(), IN_MLookUp(), IN_MoveleftDown(), IN_MoveleftUp(), IN_MoverightDown(), IN_MoverightUp(), IN_RightDown(), IN_RightUp(), IN_SpeedDown(), IN_SpeedUp(), IN_StrafeDown(), IN_StrafeUp(), IN_UpDown(), and IN_UpUp(). Referenced by CL_Init(). { Cmd_AddCommand ("centerview",IN_CenterView); Cmd_AddCommand ("+moveup",IN_UpDown); Cmd_AddCommand ("-moveup",IN_UpUp); Cmd_AddCommand ("+movedown",IN_DownDown); Cmd_AddCommand ("-movedown",IN_DownUp); Cmd_AddCommand ("+left",IN_LeftDown); Cmd_AddCommand ("-left",IN_LeftUp); Cmd_AddCommand ("+right",IN_RightDown); Cmd_AddCommand ("-right",IN_RightUp); Cmd_AddCommand ("+forward",IN_ForwardDown); Cmd_AddCommand ("-forward",IN_ForwardUp); Cmd_AddCommand ("+back",IN_BackDown); Cmd_AddCommand ("-back",IN_BackUp); Cmd_AddCommand ("+lookup", IN_LookupDown); Cmd_AddCommand ("-lookup", IN_LookupUp); Cmd_AddCommand ("+lookdown", IN_LookdownDown); Cmd_AddCommand ("-lookdown", IN_LookdownUp); Cmd_AddCommand ("+strafe", IN_StrafeDown); Cmd_AddCommand ("-strafe", IN_StrafeUp); Cmd_AddCommand ("+moveleft", IN_MoveleftDown); Cmd_AddCommand ("-moveleft", IN_MoveleftUp); Cmd_AddCommand ("+moveright", IN_MoverightDown); Cmd_AddCommand ("-moveright", IN_MoverightUp); Cmd_AddCommand ("+speed", IN_SpeedDown); Cmd_AddCommand ("-speed", IN_SpeedUp); Cmd_AddCommand ("+attack", IN_Button0Down); Cmd_AddCommand ("-attack", IN_Button0Up); Cmd_AddCommand ("+button0", IN_Button0Down); Cmd_AddCommand ("-button0", IN_Button0Up); Cmd_AddCommand ("+button1", IN_Button1Down); Cmd_AddCommand ("-button1", IN_Button1Up); Cmd_AddCommand ("+button2", IN_Button2Down); Cmd_AddCommand ("-button2", IN_Button2Up); Cmd_AddCommand ("+button3", IN_Button3Down); Cmd_AddCommand ("-button3", IN_Button3Up); Cmd_AddCommand ("+button4", IN_Button4Down); Cmd_AddCommand ("-button4", IN_Button4Up); Cmd_AddCommand ("+button5", IN_Button5Down); Cmd_AddCommand ("-button5", IN_Button5Up); Cmd_AddCommand ("+button6", IN_Button6Down); Cmd_AddCommand ("-button6", IN_Button6Up); Cmd_AddCommand ("+button7", IN_Button7Down); Cmd_AddCommand ("-button7", IN_Button7Up); Cmd_AddCommand ("+button8", IN_Button8Down); Cmd_AddCommand ("-button8", IN_Button8Up); Cmd_AddCommand ("+button9", IN_Button9Down); Cmd_AddCommand ("-button9", IN_Button9Up); Cmd_AddCommand ("+button10", IN_Button10Down); Cmd_AddCommand ("-button10", IN_Button10Up); Cmd_AddCommand ("+button11", IN_Button11Down); Cmd_AddCommand ("-button11", IN_Button11Up); Cmd_AddCommand ("+button12", IN_Button12Down); Cmd_AddCommand ("-button12", IN_Button12Up); Cmd_AddCommand ("+button13", IN_Button13Down); Cmd_AddCommand ("-button13", IN_Button13Up); Cmd_AddCommand ("+button14", IN_Button14Down); Cmd_AddCommand ("-button14", IN_Button14Up); Cmd_AddCommand ("+mlook", IN_MLookDown); Cmd_AddCommand ("-mlook", IN_MLookUp); cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0); cl_debugMove = Cvar_Get ("cl_debugMove", "0", 0); }

Here is the call graph for this function:

void CL_InitRef (  void   )

Definition at line 2184 of file cl_main.c. References refimport_t::CIN_PlayCinematic, refimport_t::CIN_RunCinematic, refimport_t::CIN_UploadCinematic, refimport_t::CM_DrawDebugSurface, refimport_t::Cmd_AddCommand, refimport_t::Cmd_Argc, refimport_t::Cmd_Argv, refimport_t::Cmd_ExecuteText, refimport_t::Cmd_RemoveCommand, Com_Error(), Com_Printf(), refimport_t::Cvar_Get, Cvar_Set(), refimport_t::Cvar_Set, ERR_FATAL, refimport_t::Free, refimport_t::FS_FileExists, refimport_t::FS_FileIsInPAK, refimport_t::FS_FreeFile, refimport_t::FS_FreeFileList, refimport_t::FS_ListFiles, refimport_t::FS_ReadFile, refimport_t::FS_WriteFile, GetRefAPI(), refimport_t::Hunk_Alloc, refimport_t::Hunk_AllocateTempMemory, refimport_t::Hunk_FreeTempMemory, refimport_t::Malloc, refimport_t::Milliseconds, re, REF_API_VERSION, and ri. Referenced by CL_Init(), and CL_Vid_Restart_f(). { refimport_t ri; refexport_t *ret; Com_Printf( "----- Initializing Renderer ----\n" ); ri.Cmd_AddCommand = Cmd_AddCommand; ri.Cmd_RemoveCommand = Cmd_RemoveCommand; ri.Cmd_Argc = Cmd_Argc; ri.Cmd_Argv = Cmd_Argv; ri.Cmd_ExecuteText = Cbuf_ExecuteText; 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.FS_FileIsInPAK = FS_FileIsInPAK; ri.FS_FileExists = FS_FileExists; ri.Cvar_Get = Cvar_Get; ri.Cvar_Set = Cvar_Set; // cinematic stuff ri.CIN_UploadCinematic = CIN_UploadCinematic; ri.CIN_PlayCinematic = CIN_PlayCinematic; ri.CIN_RunCinematic = CIN_RunCinematic; ret = GetRefAPI( REF_API_VERSION, &ri ); #if defined __USEA3D && defined __A3D_GEOM hA3Dg_ExportRenderGeom (ret); #endif Com_Printf( "-------------------------------\n"); if ( !ret ) { Com_Error (ERR_FATAL, "Couldn't initialize refresh" ); } re = *ret; // unpause so the cgame definately gets a snapshot and renders a frame Cvar_Set( "cl_paused", "0" ); }

Here is the call graph for this function:

void CL_InitUI (  void   )

Definition at line 1145 of file cl_ui.c. References CA_ACTIVE, CA_AUTHORIZING, cl_connectedToPureServer, CL_UISystemCalls(), cls, Com_Error(), Cvar_VariableValue(), ERR_DROP, ERR_FATAL, clientStatic_t::state, UI_API_VERSION, UI_GETAPIVERSION, UI_INIT, clientStatic_t::uiStarted, uivm, v, VM_Call(), VM_Create(), and vmInterpret_t. Referenced by CL_StartHunkUsers(). { int v; vmInterpret_t interpret; // load the dll or bytecode if ( cl_connectedToPureServer != 0 ) { // if sv_pure is set we only allow qvms to be loaded interpret = VMI_COMPILED; } else { interpret = Cvar_VariableValue( "vm_ui" ); } uivm = VM_Create( "ui", CL_UISystemCalls, interpret ); if ( !uivm ) { Com_Error( ERR_FATAL, "VM_Create on UI failed" ); } // sanity check v = VM_Call( uivm, UI_GETAPIVERSION ); if (v == UI_OLD_API_VERSION) { // Com_Printf(S_COLOR_YELLOW "WARNING: loading old Quake III Arena User Interface version %d\n", v ); // init for this gamestate VM_Call( uivm, UI_INIT, (cls.state >= CA_AUTHORIZING && cls.state < CA_ACTIVE)); } else if (v != UI_API_VERSION) { Com_Error( ERR_DROP, "User Interface is version %d, expected %d", v, UI_API_VERSION ); cls.uiStarted = qfalse; } else { // init for this gamestate VM_Call( uivm, UI_INIT, (cls.state >= CA_AUTHORIZING && cls.state < CA_ACTIVE) ); } }

Here is the call graph for this function:

float CL_KeyState (  kbutton_t *  key  )

Definition at line 157 of file cl_input.c. References kbutton_t::active, com_frameTime, Com_Printf(), kbutton_t::downtime, and kbutton_t::msec. Referenced by CL_AdjustAngles(), and CL_KeyMove(). { float val; int msec; msec = key->msec; key->msec = 0; if ( key->active ) { // still down if ( !key->downtime ) { msec = com_frameTime; } else { msec += com_frameTime - key->downtime; } key->downtime = com_frameTime; } #if 0 if (msec) { Com_Printf ("%i ", msec); } #endif val = (float)msec / frame_msec; if ( val < 0 ) { val = 0; } if ( val > 1 ) { val = 1; } return val; }

Here is the call graph for this function:

void CL_LocalServers_f (  void   )

Definition at line 2811 of file cl_main.c. References b, BigShort(), cls, Com_Memset(), Com_Printf(), i, j, clientStatic_t::localServers, NET_SendPacket(), NS_CLIENT, clientStatic_t::numlocalservers, clientStatic_t::pingUpdateSource, PORT_SERVER, qboolean, strlen(), and serverInfo_t::visible. Referenced by CL_Init(). { char *message; int i, j; netadr_t to; Com_Printf( "Scanning for servers on the local network...\n"); // reset the list, waiting for response cls.numlocalservers = 0; cls.pingUpdateSource = AS_LOCAL; for (i = 0; i < MAX_OTHER_SERVERS; i++) { qboolean b = cls.localServers[i].visible; Com_Memset(&cls.localServers[i], 0, sizeof(cls.localServers[i])); cls.localServers[i].visible = b; } Com_Memset( &to, 0, sizeof( to ) ); // The 'xxx' in the message is a challenge that will be echoed back // by the server. We don't care about that here, but master servers // can use that to prevent spoofed server responses from invalid ip message = "\377\377\377\377getinfo xxx"; // send each message twice in case one is dropped for ( i = 0 ; i < 2 ; i++ ) { // send a broadcast packet on each server port // we support multiple server ports so a single machine // can nicely run multiple servers for ( j = 0 ; j < NUM_SERVER_PORTS ; j++ ) { to.port = BigShort( (short)(PORT_SERVER + j) ); to.type = NA_BROADCAST; NET_SendPacket( NS_CLIENT, strlen( message ), message, to ); to.type = NA_BROADCAST_IPX; NET_SendPacket( NS_CLIENT, strlen( message ), message, to ); } } }

Here is the call graph for this function:

qboolean CL_Netchan_Process (  netchan_t *  chan, msg_t *  msg )

Definition at line 158 of file cl_net_chan.c. References CL_Netchan_Decode(), msg_t::cursize, Netchan_Process(), newsize, and qboolean. Referenced by CL_PacketEvent(). { int ret; ret = Netchan_Process( chan, msg ); if (!ret) return qfalse; CL_Netchan_Decode( msg ); newsize += msg->cursize; return qtrue; }

Here is the call graph for this function:

void CL_Netchan_Transmit (  netchan_t *  chan, msg_t *  msg )

Definition at line 143 of file cl_net_chan.c. References CL_Netchan_Encode(), clc_EOF, msg_t::cursize, msg_t::data, MSG_WriteByte(), and Netchan_Transmit(). Referenced by CL_WritePacket(). { MSG_WriteByte( msg, clc_EOF ); CL_Netchan_Encode( msg ); Netchan_Transmit( chan, msg->cursize, msg->data ); }

Here is the call graph for this function:

void CL_Netchan_TransmitNextFragment (  netchan_t *  chan  )

Definition at line 134 of file cl_net_chan.c. References Netchan_TransmitNextFragment(). Referenced by CL_WritePacket(). { Netchan_TransmitNextFragment( chan ); }

Here is the call graph for this function:

void CL_NextDemo (  void   )

Definition at line 584 of file cl_main.c. References Cbuf_AddText(), Cbuf_Execute(), Com_DPrintf(), Cvar_Set(), Cvar_VariableString(), MAX_STRING_CHARS, Q_strncpyz(), and v. Referenced by CL_DemoCompleted(). { 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(); }

Here is the call graph for this function:

void CL_NextDownload (  void   )

Definition at line 1406 of file cl_main.c. References CL_BeginDownload(), CL_DownloadsComplete(), clc, clientConnection_t::downloadList, clientConnection_t::downloadRestart, memmove(), s, strchr(), and strlen(). Referenced by CL_InitDownloads(), and CL_ParseDownload(). { 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 CL_BeginDownload( localName, remoteName ); clc.downloadRestart = qtrue; // move over the rest memmove( clc.downloadList, s, strlen(s) + 1); return; } CL_DownloadsComplete(); }

Here is the call graph for this function:

void CL_ParseServerMessage (  msg_t *  msg  )

Definition at line 590 of file cl_parse.c. References CL_ParseCommandString(), CL_ParseDownload(), CL_ParseGamestate(), CL_ParseSnapshot(), cl_shownet, clc, Com_Error(), Com_Printf(), msg_t::cursize, ERR_DROP, cvar_s::integer, MSG_Bitstream(), MSG_ReadByte(), MSG_ReadLong(), msg_t::readcount, clientConnection_t::reliableAcknowledge, clientConnection_t::reliableSequence, SHOWNET(), svc_download, svc_gamestate, svc_nop, svc_serverCommand, svc_snapshot, and svc_strings. Referenced by CL_PacketEvent(), and CL_ReadDemoMessage(). { int cmd; if ( cl_shownet->integer == 1 ) { Com_Printf ("%i ",msg->cursize); } else if ( cl_shownet->integer >= 2 ) { Com_Printf ("------------------\n"); } MSG_Bitstream(msg); // get the reliable sequence acknowledge number clc.reliableAcknowledge = MSG_ReadLong( msg ); // if ( clc.reliableAcknowledge < clc.reliableSequence - MAX_RELIABLE_COMMANDS ) { clc.reliableAcknowledge = clc.reliableSequence; } // // parse the message // while ( 1 ) { if ( msg->readcount > msg->cursize ) { Com_Error (ERR_DROP,"CL_ParseServerMessage: read past end of server message"); break; } cmd = MSG_ReadByte( msg ); if ( cmd == svc_EOF) { SHOWNET( msg, "END OF MESSAGE" ); break; } if ( cl_shownet->integer >= 2 ) { if ( !svc_strings[cmd] ) { Com_Printf( "%3i:BAD CMD %i\n", msg->readcount-1, cmd ); } else { SHOWNET( msg, svc_strings[cmd] ); } } // other commands switch ( cmd ) { default: Com_Error (ERR_DROP,"CL_ParseServerMessage: Illegible server message\n"); break; case svc_nop: break; case svc_serverCommand: CL_ParseCommandString( msg ); break; case svc_gamestate: CL_ParseGamestate( msg ); break; case svc_snapshot: CL_ParseSnapshot( msg ); break; case svc_download: CL_ParseDownload( msg ); break; } } }

Here is the call graph for this function:

void CL_Ping_f (  void   )

Definition at line 3079 of file cl_main.c. References ping_t::adr, CL_GetFreePing(), CL_SetServerInfoByAddress(), cls, Cmd_Argc(), Cmd_Argv(), Com_Memset(), Com_Printf(), memcpy(), NET_OutOfBandPrint(), NET_StringToAdr(), NS_CLIENT, NULL, clientStatic_t::realtime, ping_t::start, and ping_t::time. Referenced by CL_Init(). { netadr_t to; ping_t* pingptr; char* server; if ( Cmd_Argc() != 2 ) { Com_Printf( "usage: ping [server]\n"); return; } Com_Memset( &to, 0, sizeof(netadr_t) ); server = Cmd_Argv(1); if ( !NET_StringToAdr( server, &to ) ) { return; } pingptr = CL_GetFreePing(); memcpy( &pingptr->adr, &to, sizeof (netadr_t) ); pingptr->start = cls.realtime; pingptr->time = 0; CL_SetServerInfoByAddress(pingptr->adr, NULL, 0); NET_OutOfBandPrint( NS_CLIENT, to, "getinfo xxx" ); }

Here is the call graph for this function:

void CL_PlayCinematic_f (  void   )

Definition at line 1665 of file cl_cin.c. References bits, cin_cache::buf, CIN_PlayCinematic(), cinTable, CL_handle, cls, Cmd_Argv(), Com_DPrintf(), NULL, Q_stricmp(), qboolean, s, S_StopAllSounds(), SCR_RunCinematic(), SCR_StopCinematic(), SCREEN_HEIGHT, SCREEN_WIDTH, clientStatic_t::state, and cin_cache::status. Referenced by CL_Init(). { char *arg, *s; qboolean holdatend; int bits = CIN_system; Com_DPrintf("CL_PlayCinematic_f\n"); if (cls.state == CA_CINEMATIC) { SCR_StopCinematic(); } arg = Cmd_Argv( 1 ); s = Cmd_Argv(2); holdatend = qfalse; if ((s && s[0] == '1') || Q_stricmp(arg,"demoend.roq")==0 || Q_stricmp(arg,"end.roq")==0) { bits |= CIN_hold; } if (s && s[0] == '2') { bits |= CIN_loop; } S_StopAllSounds (); CL_handle = CIN_PlayCinematic( arg, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, bits ); if (CL_handle >= 0) { do { SCR_RunCinematic(); } while (cinTable[currentHandle].buf == NULL && cinTable[currentHandle].status == FMV_PLAY); // wait for first frame (load codebook and sound) } }

Here is the call graph for this function:

void CL_ReadDemoMessage (  void   )

Definition at line 416 of file cl_main.c. References byte, CL_DemoCompleted(), CL_ParseServerMessage(), clc, cls, Com_Error(), Com_Printf(), msg_t::cursize, msg_t::data, clientConnection_t::demofile, ERR_DROP, FS_Read(), clientConnection_t::lastPacketTime, LittleLong(), msg_t::maxsize, MSG_Init(), r, msg_t::readcount, clientStatic_t::realtime, s, and clientConnection_t::serverMessageSequence. Referenced by CL_PlayDemo_f(), and CL_SetCGameTime(). { int r; msg_t buf; byte bufData[ MAX_MSGLEN ]; int s; if ( !clc.demofile ) { CL_DemoCompleted (); return; } // get the sequence number r = FS_Read( &s, 4, clc.demofile); if ( r != 4 ) { CL_DemoCompleted (); return; } clc.serverMessageSequence = LittleLong( s ); // 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 ); }

Here is the call graph for this function:

void CL_ReadPackets (  void   )

void CL_SendCmd (  void   )

Definition at line 807 of file cl_input.c. References CL_CreateNewCommands(), cl_paused, CL_ReadyToSendPacket(), cl_showSend, CL_WritePacket(), cls, Com_Printf(), com_sv_running, cvar_s::integer, clientStatic_t::state, and sv_paused. Referenced by CL_Frame(). { // don't send any message if not connected if ( cls.state < CA_CONNECTED ) { return; } // don't send commands if paused if ( com_sv_running->integer && sv_paused->integer && cl_paused->integer ) { return; } // we create commands even if a demo is playing, CL_CreateNewCommands(); // don't send a packet if the last packet was sent too recently if ( !CL_ReadyToSendPacket() ) { if ( cl_showSend->integer ) { Com_Printf( ". " ); } return; } CL_WritePacket(); }

Here is the call graph for this function:

void CL_ServerInfoPacket (  netadr_t  from, msg_t *  msg )

Definition at line 2513 of file cl_main.c. References serverInfo_t::adr, ping_t::adr, atoi, cl_pinglist, CL_SetServerInfoByAddress(), serverInfo_t::clients, cls, Com_DPrintf(), Com_Printf(), serverInfo_t::game, serverInfo_t::gameType, serverInfo_t::hostName, i, Info_SetValueForKey(), Info_ValueForKey(), clientStatic_t::localServers, serverInfo_t::mapName, MAX_INFO_STRING, serverInfo_t::maxClients, serverInfo_t::maxPing, serverInfo_t::minPing, MSG_ReadString(), NA_BROADCAST, NA_BROADCAST_IPX, NA_IP, NA_IPX, NET_AdrToString(), NET_CompareAdr(), serverInfo_t::netType, clientStatic_t::numlocalservers, serverInfo_t::ping, clientStatic_t::pingUpdateSource, netadr_t::port, serverInfo_t::punkbuster, Q_strncpyz(), clientStatic_t::realtime, ping_t::start, strlen(), strncat(), time(), ping_t::time, type, netadr_t::type, and va(). Referenced by CL_ConnectionlessPacket(). { int i, type; char info[MAX_INFO_STRING]; char* str; char *infoString; int prot; infoString = MSG_ReadString( msg ); // if this isn't the correct protocol version, ignore it prot = atoi( Info_ValueForKey( infoString, "protocol" ) ); if ( prot != PROTOCOL_VERSION ) { Com_DPrintf( "Different protocol info packet: %s\n", infoString ); return; } // iterate servers waiting for ping response for (i=0; i<MAX_PINGREQUESTS; i++) { if ( cl_pinglist[i].adr.port && !cl_pinglist[i].time && NET_CompareAdr( from, cl_pinglist[i].adr ) ) { // calc ping time cl_pinglist[i].time = cls.realtime - cl_pinglist[i].start + 1; Com_DPrintf( "ping time %dms from %s\n", cl_pinglist[i].time, NET_AdrToString( from ) ); // save of info Q_strncpyz( cl_pinglist[i].info, infoString, sizeof( cl_pinglist[i].info ) ); // tack on the net type // NOTE: make sure these types are in sync with the netnames strings in the UI switch (from.type) { case NA_BROADCAST: case NA_IP: str = "udp"; type = 1; break; case NA_IPX: case NA_BROADCAST_IPX: str = "ipx"; type = 2; break; default: str = "???"; type = 0; break; } Info_SetValueForKey( cl_pinglist[i].info, "nettype", va("%d", type) ); CL_SetServerInfoByAddress(from, infoString, cl_pinglist[i].time); return; } } // if not just sent a local broadcast or pinging local servers if (cls.pingUpdateSource != AS_LOCAL) { return; } for ( i = 0 ; i < MAX_OTHER_SERVERS ; i++ ) { // empty slot if ( cls.localServers[i].adr.port == 0 ) { break; } // avoid duplicate if ( NET_CompareAdr( from, cls.localServers[i].adr ) ) { return; } } if ( i == MAX_OTHER_SERVERS ) { Com_DPrintf( "MAX_OTHER_SERVERS hit, dropping infoResponse\n" ); return; } // add this to the list cls.numlocalservers = i+1; cls.localServers[i].adr = from; cls.localServers[i].clients = 0; cls.localServers[i].hostName[0] = '\0'; cls.localServers[i].mapName[0] = '\0'; cls.localServers[i].maxClients = 0; cls.localServers[i].maxPing = 0; cls.localServers[i].minPing = 0; cls.localServers[i].ping = -1; cls.localServers[i].game[0] = '\0'; cls.localServers[i].gameType = 0; cls.localServers[i].netType = from.type; cls.localServers[i].punkbuster = 0; Q_strncpyz( info, MSG_ReadString( msg ), MAX_INFO_STRING ); if (strlen(info)) { if (info[strlen(info)-1] != '\n') { strncat(info, "\n", sizeof(info)); } Com_Printf( "%s: %s", NET_AdrToString( from ), info ); } }

Here is the call graph for this function:

int CL_ServerStatus (  char *  serverAddress, char *  serverStatusString, int  maxLen )

Definition at line 2655 of file cl_main.c. References serverStatus_s::address, CL_GetServerStatus(), cl_serverStatusList, cl_serverStatusResendTime, Com_Milliseconds(), i, cvar_s::integer, NET_CompareAdr(), NET_OutOfBandPrint(), NET_StringToAdr(), NS_CLIENT, serverStatus_s::pending, netadr_t::port, serverStatus_s::print, Q_strncpyz(), serverStatus_s::retrieved, serverStatus_t, serverStatus_s::startTime, serverStatus_s::string, and serverStatus_s::time. Referenced by LAN_GetServerStatus(). { int i; netadr_t to; serverStatus_t *serverStatus; // if no server address then reset all server status requests if ( !serverAddress ) { for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) { cl_serverStatusList[i].address.port = 0; cl_serverStatusList[i].retrieved = qtrue; } return qfalse; } // get the address if ( !NET_StringToAdr( serverAddress, &to ) ) { return qfalse; } serverStatus = CL_GetServerStatus( to ); // if no server status string then reset the server status request for this address if ( !serverStatusString ) { serverStatus->retrieved = qtrue; return qfalse; } // if this server status request has the same address if ( NET_CompareAdr( to, serverStatus->address) ) { // if we recieved an response for this server status request if (!serverStatus->pending) { Q_strncpyz(serverStatusString, serverStatus->string, maxLen); serverStatus->retrieved = qtrue; serverStatus->startTime = 0; return qtrue; } // resend the request regularly else if ( serverStatus->startTime < Com_Milliseconds() - cl_serverStatusResendTime->integer ) { serverStatus->print = qfalse; serverStatus->pending = qtrue; serverStatus->retrieved = qfalse; serverStatus->time = 0; serverStatus->startTime = Com_Milliseconds(); NET_OutOfBandPrint( NS_CLIENT, to, "getstatus" ); return qfalse; } } // if retrieved else if ( serverStatus->retrieved ) { serverStatus->address = to; serverStatus->print = qfalse; serverStatus->pending = qtrue; serverStatus->retrieved = qfalse; serverStatus->startTime = Com_Milliseconds(); serverStatus->time = 0; NET_OutOfBandPrint( NS_CLIENT, to, "getstatus" ); return qfalse; } return qfalse; }

Here is the call graph for this function:

void CL_SetCGameTime (  void   )

Definition at line 915 of file cl_cgame.c. References cl, CL_AdjustTimeDelta(), CL_FirstSnapshot(), cl_freezeDemo, cl_paused, CL_ReadDemoMessage(), cl_timedemo, cl_timeNudge, clc, cls, Com_Error(), com_sv_running, clientConnection_t::demoplaying, ERR_DROP, clientActive_t::extrapolatedSnapshot, clientConnection_t::firstDemoFrameSkipped, cvar_s::integer, clientActive_t::newSnapshots, clientActive_t::oldFrameServerTime, clientActive_t::oldServerTime, clientStatic_t::realtime, clientActive_t::serverTime, clSnapshot_t::serverTime, clientActive_t::serverTimeDelta, clientActive_t::snap, clientStatic_t::state, sv_paused, Sys_Milliseconds(), clientConnection_t::timeDemoBaseTime, clientConnection_t::timeDemoFrames, clientConnection_t::timeDemoStart, and clSnapshot_t::valid. Referenced by CL_Frame(). { // getting a valid frame message ends the connection process if ( cls.state != CA_ACTIVE ) { if ( cls.state != CA_PRIMED ) { return; } if ( clc.demoplaying ) { // we shouldn't get the first snapshot on the same frame // as the gamestate, because it causes a bad time skip if ( !clc.firstDemoFrameSkipped ) { clc.firstDemoFrameSkipped = qtrue; return; } CL_ReadDemoMessage(); } if ( cl.newSnapshots ) { cl.newSnapshots = qfalse; CL_FirstSnapshot(); } if ( cls.state != CA_ACTIVE ) { return; } } // if we have gotten to this point, cl.snap is guaranteed to be valid if ( !cl.snap.valid ) { Com_Error( ERR_DROP, "CL_SetCGameTime: !cl.snap.valid" ); } // allow pause in single player if ( sv_paused->integer && cl_paused->integer && com_sv_running->integer ) { // paused return; } if ( cl.snap.serverTime < cl.oldFrameServerTime ) { Com_Error( ERR_DROP, "cl.snap.serverTime < cl.oldFrameServerTime" ); } cl.oldFrameServerTime = cl.snap.serverTime; // get our current view of time if ( clc.demoplaying && cl_freezeDemo->integer ) { // cl_freezeDemo is used to lock a demo in place for single frame advances } else { // cl_timeNudge is a user adjustable cvar that allows more // or less latency to be added in the interest of better // smoothness or better responsiveness. int tn; tn = cl_timeNudge->integer; if (tn<-30) { tn = -30; } else if (tn>30) { tn = 30; } cl.serverTime = cls.realtime + cl.serverTimeDelta - tn; // guarantee that time will never flow backwards, even if // serverTimeDelta made an adjustment or cl_timeNudge was changed if ( cl.serverTime < cl.oldServerTime ) { cl.serverTime = cl.oldServerTime; } cl.oldServerTime = cl.serverTime; // note if we are almost past the latest frame (without timeNudge), // so we will try and adjust back a bit when the next snapshot arrives if ( cls.realtime + cl.serverTimeDelta >= cl.snap.serverTime - 5 ) { cl.extrapolatedSnapshot = qtrue; } } // if we have gotten new snapshots, drift serverTimeDelta // don't do this every frame, or a period of packet loss would // make a huge adjustment if ( cl.newSnapshots ) { CL_AdjustTimeDelta(); } if ( !clc.demoplaying ) { return; } // if we are playing a demo back, we can just keep reading // messages from the demo file until the cgame definately // has valid snapshots to interpolate between // a timedemo will always use a deterministic set of time samples // no matter what speed machine it is run on, // while a normal demo may have different time samples // each time it is played back if ( cl_timedemo->integer ) { if (!clc.timeDemoStart) { clc.timeDemoStart = Sys_Milliseconds(); } clc.timeDemoFrames++; cl.serverTime = clc.timeDemoBaseTime + clc.timeDemoFrames * 50; } while ( cl.serverTime >= cl.snap.serverTime ) { // feed another messag, which should change // the contents of cl.snap CL_ReadDemoMessage(); if ( cls.state != CA_ACTIVE ) { return; // end of demo } } }

Here is the call graph for this function:

void CL_ShaderStateChanged (  void   )

void CL_ShutdownAll (  void   )

Definition at line 608 of file cl_main.c. { // 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; }

void CL_ShutdownCGame (  void   )

Definition at line 389 of file cl_cgame.c. { cls.keyCatchers &= ~KEYCATCH_CGAME; cls.cgameStarted = qfalse; if ( !cgvm ) { return; } VM_Call( cgvm, CG_SHUTDOWN ); VM_Free( cgvm ); cgvm = NULL; }

void CL_ShutdownRef (  void   )

Definition at line 2103 of file cl_main.c. References Com_Memset(), qtrue, re, and refexport_t::Shutdown. Referenced by CL_Shutdown(), and CL_Vid_Restart_f(). { if ( !re.Shutdown ) { return; } re.Shutdown( qtrue ); Com_Memset( &re, 0, sizeof( re ) ); }

Here is the call graph for this function:

void CL_ShutdownUI (  void   )

Definition at line 1127 of file cl_ui.c. { cls.keyCatchers &= ~KEYCATCH_UI; cls.uiStarted = qfalse; if ( !uivm ) { return; } VM_Call( uivm, UI_SHUTDOWN ); VM_Free( uivm ); uivm = NULL; }

void CL_Snd_Restart_f (  void   )

Definition at line 1247 of file cl_main.c. References CL_Vid_Restart_f(), S_Init(), and S_Shutdown(). Referenced by CL_Init(). { S_Shutdown(); S_Init(); CL_Vid_Restart_f(); }

Here is the call graph for this function:

void CL_StartDemoLoop (  void   )

Definition at line 570 of file cl_main.c. References Cbuf_AddText(), cls, and clientStatic_t::keyCatchers. Referenced by Con_ToggleConsole_f(). { // start the demo loop again Cbuf_AddText ("d1\n"); cls.keyCatchers = 0; }

Here is the call graph for this function:

void CL_StartHunkUsers (  void   )

Definition at line 2136 of file cl_main.c. { 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(); } }

void CL_SystemInfoChanged (  void   )

Definition at line 327 of file cl_parse.c. References atoi, cl, cl_connectedToPureServer, clc, Cvar_Set(), Cvar_SetCheatState(), Cvar_VariableString(), Cvar_VariableValue(), clientConnection_t::demoplaying, FS_PureServerSetLoadedPaks(), FS_PureServerSetReferencedPaks(), clientActive_t::gameState, Info_NextPair(), Info_ValueForKey(), Q_stricmp(), qboolean, s, clientActive_t::serverId, gameState_t::stringData, gameState_t::stringOffsets, t, and value. Referenced by CL_ConfigstringModified(), and CL_ParseGamestate(). { char *systemInfo; const char *s, *t; char key[BIG_INFO_KEY]; char value[BIG_INFO_VALUE]; qboolean gameSet; systemInfo = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SYSTEMINFO ]; // NOTE TTimo: // when the serverId changes, any further messages we send to the server will use this new serverId // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=475 // in some cases, outdated cp commands might get sent with this news serverId cl.serverId = atoi( Info_ValueForKey( systemInfo, "sv_serverid" ) ); // don't set any vars when playing a demo if ( clc.demoplaying ) { return; } s = Info_ValueForKey( systemInfo, "sv_cheats" ); if ( atoi(s) == 0 ) { Cvar_SetCheatState(); } // check pure server string s = Info_ValueForKey( systemInfo, "sv_paks" ); t = Info_ValueForKey( systemInfo, "sv_pakNames" ); FS_PureServerSetLoadedPaks( s, t ); s = Info_ValueForKey( systemInfo, "sv_referencedPaks" ); t = Info_ValueForKey( systemInfo, "sv_referencedPakNames" ); FS_PureServerSetReferencedPaks( s, t ); gameSet = qfalse; // scan through all the variables in the systeminfo and locally set cvars to match s = systemInfo; while ( s ) { Info_NextPair( &s, key, value ); if ( !key[0] ) { break; } // ehw! if ( !Q_stricmp( key, "fs_game" ) ) { gameSet = qtrue; } Cvar_Set( key, value ); } // if game folder should not be set and it is set at the client side if ( !gameSet && *Cvar_VariableString("fs_game") ) { Cvar_Set( "fs_game", "" ); } cl_connectedToPureServer = Cvar_VariableValue( "sv_pure" ); }

Here is the call graph for this function:

qboolean CL_UpdateVisiblePings_f (  int  source  )

Definition at line 3113 of file cl_main.c. References ping_t::adr, AS_FAVORITES, AS_GLOBAL, AS_LOCAL, AS_MPLAYER, CL_ClearPing(), CL_GetPing(), CL_GetPingQueueCount(), CL_InitServerInfo(), cl_pinglist, cls, clientStatic_t::favoriteServers, clientStatic_t::globalServerAddresses, clientStatic_t::globalServers, i, j, clientStatic_t::localServers, max, MAX_GLOBAL_SERVERS, MAX_STRING_CHARS, memcpy(), clientStatic_t::mplayerServers, NET_CompareAdr(), NET_OutOfBandPrint(), NS_CLIENT, clientStatic_t::numfavoriteservers, clientStatic_t::numGlobalServerAddresses, clientStatic_t::numglobalservers, clientStatic_t::numlocalservers, clientStatic_t::nummplayerservers, serverInfo_t::ping, clientStatic_t::pingUpdateSource, netadr_t::port, qboolean, clientStatic_t::realtime, source, ping_t::start, ping_t::time, and serverInfo_t::visible. Referenced by LAN_UpdateVisiblePings(). { int slots, i; char buff[MAX_STRING_CHARS]; int pingTime; int max; qboolean status = qfalse; if (source < 0 || source > AS_FAVORITES) { return qfalse; } cls.pingUpdateSource = source; slots = CL_GetPingQueueCount(); if (slots < MAX_PINGREQUESTS) { serverInfo_t *server = NULL; max = (source == AS_GLOBAL) ? MAX_GLOBAL_SERVERS : MAX_OTHER_SERVERS; switch (source) { case AS_LOCAL : server = &cls.localServers[0]; max = cls.numlocalservers; break; case AS_MPLAYER : server = &cls.mplayerServers[0]; max = cls.nummplayerservers; break; case AS_GLOBAL : server = &cls.globalServers[0]; max = cls.numglobalservers; break; case AS_FAVORITES : server = &cls.favoriteServers[0]; max = cls.numfavoriteservers; break; } for (i = 0; i < max; i++) { if (server[i].visible) { if (server[i].ping == -1) { int j; if (slots >= MAX_PINGREQUESTS) { break; } for (j = 0; j < MAX_PINGREQUESTS; j++) { if (!cl_pinglist[j].adr.port) { continue; } if (NET_CompareAdr( cl_pinglist[j].adr, server[i].adr)) { // already on the list break; } } if (j >= MAX_PINGREQUESTS) { status = qtrue; for (j = 0; j < MAX_PINGREQUESTS; j++) { if (!cl_pinglist[j].adr.port) { break; } } memcpy(&cl_pinglist[j].adr, &server[i].adr, sizeof(netadr_t)); cl_pinglist[j].start = cls.realtime; cl_pinglist[j].time = 0; NET_OutOfBandPrint( NS_CLIENT, cl_pinglist[j].adr, "getinfo xxx" ); slots++; } } // if the server has a ping higher than cl_maxPing or // the ping packet got lost else if (server[i].ping == 0) { // if we are updating global servers if (source == AS_GLOBAL) { // if ( cls.numGlobalServerAddresses > 0 ) { // overwrite this server with one from the additional global servers cls.numGlobalServerAddresses--; CL_InitServerInfo(&server[i], &cls.globalServerAddresses[cls.numGlobalServerAddresses]); // NOTE: the server[i].visible flag stays untouched } } } } } } if (slots) { status = qtrue; } for (i = 0; i < MAX_PINGREQUESTS; i++) { if (!cl_pinglist[i].adr.port) { continue; } CL_GetPing( i, buff, MAX_STRING_CHARS, &pingTime ); if (pingTime != 0) { CL_ClearPing(i); status = qtrue; } } return status; }

Here is the call graph for this function:

void CL_VerifyCode (  void   )

void CL_Vid_Restart_f (  void   )

Definition at line 1188 of file cl_main.c. References CA_CONNECTED, clientStatic_t::cgameStarted, clientConnection_t::checksumFeed, CL_InitCGame(), CL_InitRef(), CL_ResetPureClientAtServer(), CL_SendPureChecksums(), CL_ShutdownCGame(), CL_ShutdownRef(), CL_ShutdownUI(), CL_StartHunkUsers(), clc, cls, com_sv_running, Cvar_Set(), FS_CGAME_REF, FS_ClearPakReferences(), FS_ConditionalRestart(), FS_UI_REF, Hunk_Clear(), Hunk_ClearToMark(), cvar_s::integer, clientStatic_t::rendererStarted, S_StopAllSounds(), clientStatic_t::soundRegistered, clientStatic_t::state, and clientStatic_t::uiStarted. Referenced by CL_Init(), and CL_Snd_Restart_f(). { // don't let them loop during the restart S_StopAllSounds(); // shutdown the UI CL_ShutdownUI(); // shutdown the CGame CL_ShutdownCGame(); // shutdown the renderer and clear the renderer interface CL_ShutdownRef(); // client is no longer pure untill new checksums are sent CL_ResetPureClientAtServer(); // clear pak references 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 definately 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 ) { // clear the whole hunk Hunk_Clear(); } else { // clear all the client data on the hunk Hunk_ClearToMark(); } // initialize the renderer interface CL_InitRef(); // 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(); } }

Here is the call graph for this function:

void CL_WritePacket (  void   )

Definition at line 688 of file cl_input.c. References byte, clientConnection_t::checksumFeed, cl, CL_Netchan_Transmit(), CL_Netchan_TransmitNextFragment(), cl_nodelta, cl_packetdup, cl_showSend, clc, clc_clientCommand, clc_move, clc_moveNoDelta, cls, clientActive_t::cmdNumber, clientActive_t::cmds, Com_DPrintf(), Com_HashKey(), Com_Memset(), Com_Printf(), count, msg_t::cursize, Cvar_Set(), data, clientConnection_t::demoplaying, clientConnection_t::demowaiting, i, cvar_s::integer, j, clientConnection_t::lastPacketSentTime, MAX_RELIABLE_COMMANDS, clSnapshot_t::messageNum, MSG_Bitstream(), MSG_Init(), MSG_WriteByte(), MSG_WriteDeltaUsercmdKey(), MSG_WriteLong(), MSG_WriteString(), clientConnection_t::netchan, netchan_t::outgoingSequence, clientActive_t::outPackets, outPacket_t::p_cmdNumber, outPacket_t::p_realtime, outPacket_t::p_serverTime, clientStatic_t::realtime, clientConnection_t::reliableAcknowledge, clientConnection_t::reliableCommands, clientConnection_t::reliableSequence, clientConnection_t::serverCommands, clientConnection_t::serverCommandSequence, clientActive_t::serverId, clientConnection_t::serverMessageSequence, usercmd_s::serverTime, clientActive_t::snap, clientStatic_t::state, netchan_t::unsentFragments, usercmd_t, and clSnapshot_t::valid. Referenced by CL_Disconnect(), CL_DownloadsComplete(), CL_ParseDownload(), and CL_SendCmd(). { msg_t buf; byte data[MAX_MSGLEN]; int i, j; usercmd_t *cmd, *oldcmd; usercmd_t nullcmd; int packetNum; int oldPacketNum; int count, key; // don't send anything if playing back a demo if ( clc.demoplaying || cls.state == CA_CINEMATIC ) { return; } Com_Memset( &nullcmd, 0, sizeof(nullcmd) ); oldcmd = &nullcmd; MSG_Init( &buf, data, sizeof(data) ); MSG_Bitstream( &buf ); // write the current serverId so the server // can tell if this is from the current gameState MSG_WriteLong( &buf, cl.serverId ); // write the last message we received, which can // be used for delta compression, and is also used // to tell if we dropped a gamestate MSG_WriteLong( &buf, clc.serverMessageSequence ); // write the last reliable message we received MSG_WriteLong( &buf, clc.serverCommandSequence ); // write any unacknowledged clientCommands for ( i = clc.reliableAcknowledge + 1 ; i <= clc.reliableSequence ; i++ ) { MSG_WriteByte( &buf, clc_clientCommand ); MSG_WriteLong( &buf, i ); MSG_WriteString( &buf, clc.reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] ); } // we want to send all the usercmds that were generated in the last // few packet, so even if a couple packets are dropped in a row, // all the cmds will make it to the server if ( cl_packetdup->integer < 0 ) { Cvar_Set( "cl_packetdup", "0" ); } else if ( cl_packetdup->integer > 5 ) { Cvar_Set( "cl_packetdup", "5" ); } oldPacketNum = (clc.netchan.outgoingSequence - 1 - cl_packetdup->integer) & PACKET_MASK; count = cl.cmdNumber - cl.outPackets[ oldPacketNum ].p_cmdNumber; if ( count > MAX_PACKET_USERCMDS ) { count = MAX_PACKET_USERCMDS; Com_Printf("MAX_PACKET_USERCMDS\n"); } if ( count >= 1 ) { if ( cl_showSend->integer ) { Com_Printf( "(%i)", count ); } // begin a client move command if ( cl_nodelta->integer || !cl.snap.valid || clc.demowaiting || clc.serverMessageSequence != cl.snap.messageNum ) { MSG_WriteByte (&buf, clc_moveNoDelta); } else { MSG_WriteByte (&buf, clc_move); } // write the command count MSG_WriteByte( &buf, count ); // use the checksum feed in the key key = clc.checksumFeed; // also use the message acknowledge key ^= clc.serverMessageSequence; // also use the last acknowledged server command in the key key ^= Com_HashKey(clc.serverCommands[ clc.serverCommandSequence & (MAX_RELIABLE_COMMANDS-1) ], 32); // write all the commands, including the predicted command for ( i = 0 ; i < count ; i++ ) { j = (cl.cmdNumber - count + i + 1) & CMD_MASK; cmd = &cl.cmds[j]; MSG_WriteDeltaUsercmdKey (&buf, key, oldcmd, cmd); oldcmd = cmd; } } // // deliver the message // packetNum = clc.netchan.outgoingSequence & PACKET_MASK; cl.outPackets[ packetNum ].p_realtime = cls.realtime; cl.outPackets[ packetNum ].p_serverTime = oldcmd->serverTime; cl.outPackets[ packetNum ].p_cmdNumber = cl.cmdNumber; clc.lastPacketSentTime = cls.realtime; if ( cl_showSend->integer ) { Com_Printf( "%i ", buf.cursize ); } CL_Netchan_Transmit (&clc.netchan, &buf); // clients never really should have messages large enough // to fragment, but in case they do, fire them all off // at once // TTimo: this causes a packet burst, which is bad karma for winsock // added a WARNING message, we'll see if there are legit situations where this happens while ( clc.netchan.unsentFragments ) { Com_DPrintf( "WARNING: #462 unsent fragments (not supposed to happen!)\n" ); CL_Netchan_TransmitNextFragment( &clc.netchan ); } }

Here is the call graph for this function:

void Con_Bottom (  void   )

Definition at line 772 of file cl_console.c. References con, console_t::current, and console_t::display. Referenced by Con_Clear_f(), and Console_Key(). { con.display = con.current; }

void Con_CheckResize (  void   )

Definition at line 248 of file cl_console.c. References COLOR_WHITE, ColorIndex, Com_Memcpy(), con, Con_ClearNotify(), CON_TEXTSIZE, console_t::current, console_t::display, i, j, console_t::linewidth, SCREEN_WIDTH, console_t::text, console_t::totallines, and width. Referenced by CL_ConsolePrint(), and Con_DrawConsole(). { int i, j, width, oldwidth, oldtotallines, numlines, numchars; MAC_STATIC short tbuf[CON_TEXTSIZE]; width = (SCREEN_WIDTH / SMALLCHAR_WIDTH) - 2; if (width == con.linewidth) return; if (width < 1) // video hasn't been initialized yet { width = DEFAULT_CONSOLE_WIDTH; con.linewidth = width; con.totallines = CON_TEXTSIZE / con.linewidth; for(i=0; i<CON_TEXTSIZE; i++) con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' '; } else { oldwidth = con.linewidth; con.linewidth = width; oldtotallines = con.totallines; con.totallines = CON_TEXTSIZE / con.linewidth; numlines = oldtotallines; if (con.totallines < numlines) numlines = con.totallines; numchars = oldwidth; if (con.linewidth < numchars) numchars = con.linewidth; Com_Memcpy (tbuf, con.text, CON_TEXTSIZE * sizeof(short)); for(i=0; i<CON_TEXTSIZE; i++) con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' '; for (i=0 ; i<numlines ; i++) { for (j=0 ; j<numchars ; j++) { con.text[(con.totallines - 1 - i) * con.linewidth + j] = tbuf[((con.current - i + oldtotallines) % oldtotallines) * oldwidth + j]; } } Con_ClearNotify (); } con.current = con.totallines - 1; con.display = con.current; }

Here is the call graph for this function:

void Con_Clear_f (  void   )

Definition at line 153 of file cl_console.c. References COLOR_WHITE, ColorIndex, con, Con_Bottom(), i, and console_t::text. Referenced by Con_Init(). { int i; for ( i = 0 ; i < CON_TEXTSIZE ; i++ ) { con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' '; } Con_Bottom(); // go to end }

Here is the call graph for this function:

void Con_ClearNotify (  void   )

Definition at line 231 of file cl_console.c. References con, i, and console_t::times. Referenced by CL_GetServerCommand(), CL_InitCGame(), Con_CheckResize(), Con_Close(), and Con_ToggleConsole_f(). { int i; for ( i = 0 ; i < NUM_CON_TIMES ; i++ ) { con.times[i] = 0; } }

void Con_Close (  void   )

Definition at line 777 of file cl_console.c. References cls, com_cl_running, con, Con_ClearNotify(), console_t::displayFrac, Field_Clear(), console_t::finalFrac, g_consoleField, cvar_s::integer, and clientStatic_t::keyCatchers. Referenced by CIN_PlayCinematic(), CL_Connect_f(), CL_GetServerCommand(), CL_InitCGame(), CL_MapLoading(), CL_ParseGamestate(), and CL_PlayDemo_f(). { if ( !com_cl_running->integer ) { return; } Field_Clear( &g_consoleField ); Con_ClearNotify (); cls.keyCatchers &= ~KEYCATCH_CONSOLE; con.finalFrac = 0; // none visible con.displayFrac = 0; }

Here is the call graph for this function:

void Con_DrawCharacter (  int  cx, int  line, int  num )

void Con_DrawConsole (  void   )

Definition at line 695 of file cl_console.c. References cls, con, Con_CheckResize(), Con_DrawNotify(), Con_DrawSolidConsole(), console_t::displayFrac, KEYCATCH_UI, clientStatic_t::keyCatchers, and clientStatic_t::state. Referenced by SCR_DrawScreenField(). { // check for console width changes from a vid mode change Con_CheckResize (); // if disconnected, render console full screen if ( cls.state == CA_DISCONNECTED ) { if ( !( cls.keyCatchers & (KEYCATCH_UI | KEYCATCH_CGAME)) ) { Con_DrawSolidConsole( 1.0 ); return; } } if ( con.displayFrac ) { Con_DrawSolidConsole( con.displayFrac ); } else { // draw notify lines if ( cls.state == CA_ACTIVE ) { Con_DrawNotify (); } } }

Here is the call graph for this function:

void Con_DrawNotify (  void   )

Definition at line 502 of file cl_console.c. References BIGCHAR_WIDTH, chatField, cl, cl_conXOffset, cls, con, con_notifytime, console_t::current, f, Field_BigDraw(), g_color_table, i, cvar_s::integer, KEYCATCH_UI, clientStatic_t::keyCatchers, console_t::linewidth, NULL, NUM_CON_TIMES, PM_INTERMISSION, playerState_s::pm_type, clSnapshot_t::ps, qtrue, re, clientStatic_t::realtime, SCR_DrawBigString(), SCR_DrawSmallChar(), SCREEN_WIDTH, refexport_t::SetColor, SMALLCHAR_WIDTH, clientActive_t::snap, console_t::text, time(), console_t::times, console_t::totallines, v, cvar_s::value, x, and console_t::xadjust. Referenced by Con_DrawConsole(). { int x, v; short *text; int i; int time; int skip; int currentColor; currentColor = 7; re.SetColor( g_color_table[currentColor] ); v = 0; for (i= con.current-NUM_CON_TIMES+1 ; i<=con.current ; i++) { if (i < 0) continue; time = con.times[i % NUM_CON_TIMES]; if (time == 0) continue; time = cls.realtime - time; if (time > con_notifytime->value*1000) continue; text = con.text + (i % con.totallines)*con.linewidth; if (cl.snap.ps.pm_type != PM_INTERMISSION && cls.keyCatchers & (KEYCATCH_UI | KEYCATCH_CGAME) ) { continue; } for (x = 0 ; x < con.linewidth ; x++) { if ( ( text[x] & 0xff ) == ' ' ) { continue; } if ( ( (text[x]>>8)&7 ) != currentColor ) { currentColor = (text[x]>>8)&7; re.SetColor( g_color_table[currentColor] ); } SCR_DrawSmallChar( cl_conXOffset->integer + con.xadjust + (x+1)*SMALLCHAR_WIDTH, v, text[x] & 0xff ); } v += SMALLCHAR_HEIGHT; } re.SetColor( NULL ); if (cls.keyCatchers & (KEYCATCH_UI | KEYCATCH_CGAME) ) { return; } // draw the chat line if ( cls.keyCatchers & KEYCATCH_MESSAGE ) { if (chat_team) { SCR_DrawBigString (8, v, "say_team:", 1.0f ); skip = 11; } else { SCR_DrawBigString (8, v, "say:", 1.0f ); skip = 5; } Field_BigDraw( &chatField, skip * BIGCHAR_WIDTH, v, SCREEN_WIDTH - ( skip + 1 ) * BIGCHAR_WIDTH, qtrue ); v += BIGCHAR_HEIGHT; } }

Here is the call graph for this function:

void Con_Init (  void   )

Definition at line 312 of file cl_console.c. References Cmd_AddCommand(), Con_Clear_f(), con_conspeed, Con_Dump_f(), Con_MessageMode2_f(), Con_MessageMode3_f(), Con_MessageMode4_f(), Con_MessageMode_f(), con_notifytime, Con_ToggleConsole_f(), Cvar_Get(), Field_Clear(), g_consoleField, historyEditLines, i, and field_t::widthInChars. Referenced by CL_Init(). { int i; con_notifytime = Cvar_Get ("con_notifytime", "3", 0); con_conspeed = Cvar_Get ("scr_conspeed", "3", 0); Field_Clear( &g_consoleField ); g_consoleField.widthInChars = g_console_field_width; for ( i = 0 ; i < COMMAND_HISTORY ; i++ ) { Field_Clear( &historyEditLines[i] ); historyEditLines[i].widthInChars = g_console_field_width; } Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f); Cmd_AddCommand ("messagemode", Con_MessageMode_f); Cmd_AddCommand ("messagemode2", Con_MessageMode2_f); Cmd_AddCommand ("messagemode3", Con_MessageMode3_f); Cmd_AddCommand ("messagemode4", Con_MessageMode4_f); Cmd_AddCommand ("clear", Con_Clear_f); Cmd_AddCommand ("condump", Con_Dump_f); }

Here is the call graph for this function:

void Con_PageDown (  void   )

Definition at line 758 of file cl_console.c. References con, console_t::current, and console_t::display. Referenced by Console_Key(). { con.display += 2; if (con.display > con.current) { con.display = con.current; } }

void Con_PageUp (  void   )

Definition at line 751 of file cl_console.c. References con, console_t::current, console_t::display, and console_t::totallines. Referenced by Console_Key(). { con.display -= 2; if ( con.current - con.display >= con.totallines ) { con.display = con.current - con.totallines + 1; } }

void Con_RunConsole (  void   )

Definition at line 726 of file cl_console.c. References cls, con, con_conspeed, console_t::displayFrac, console_t::finalFrac, clientStatic_t::keyCatchers, clientStatic_t::realFrametime, and cvar_s::value. Referenced by CL_Frame(). { // decide on the destination height of the console if ( cls.keyCatchers & KEYCATCH_CONSOLE ) con.finalFrac = 0.5; // half screen else con.finalFrac = 0; // none visible // scroll towards the destination height if (con.finalFrac < con.displayFrac) { con.displayFrac -= con_conspeed->value*cls.realFrametime*0.001; if (con.finalFrac > con.displayFrac) con.displayFrac = con.finalFrac; } else if (con.finalFrac > con.displayFrac) { con.displayFrac += con_conspeed->value*cls.realFrametime*0.001; if (con.finalFrac < con.displayFrac) con.displayFrac = con.finalFrac; } }

void Con_ToggleConsole_f (  void   )

Definition at line 73 of file cl_console.c. References CA_DISCONNECTED, CL_StartDemoLoop(), cls, Con_ClearNotify(), Field_Clear(), g_consoleField, clientStatic_t::keyCatchers, clientStatic_t::state, and field_t::widthInChars. Referenced by CL_KeyEvent(), and Con_Init(). { // closing a full screen console restarts the demo loop if ( cls.state == CA_DISCONNECTED && cls.keyCatchers == KEYCATCH_CONSOLE ) { CL_StartDemoLoop(); return; } Field_Clear( &g_consoleField ); g_consoleField.widthInChars = g_console_field_width; Con_ClearNotify (); cls.keyCatchers ^= KEYCATCH_CONSOLE; }

Here is the call graph for this function:

void Con_Top (  void   )

Definition at line 765 of file cl_console.c. References con, console_t::current, console_t::display, and console_t::totallines. Referenced by Console_Key(). { con.display = con.totallines; if ( con.current - con.display >= con.totallines ) { con.display = con.current - con.totallines + 1; } }

void IN_CenterView (  void   )

Definition at line 257 of file cl_input.c. References cl, playerState_s::delta_angles, PITCH, clSnapshot_t::ps, SHORT2ANGLE, clientActive_t::snap, and clientActive_t::viewangles. Referenced by CL_InitInput(), and IN_MLookUp(). { cl.viewangles[PITCH] = -SHORT2ANGLE(cl.snap.ps.delta_angles[PITCH]); }

int Key_GetCatcher (  void   )

Definition at line 670 of file cl_ui.c. References cls, and clientStatic_t::keyCatchers. Referenced by CL_CgameSystemCalls(), and CL_UISystemCalls(). { return cls.keyCatchers; }

char* Key_KeynumToString (  int  keynum  )

Definition at line 739 of file cl_keys.c. References i, j, keyname_t::keynum, and keyname_t::name. Referenced by CL_KeyEvent(), Key_Bindlist_f(), Key_KeynumToStringBuf(), and Key_WriteBindings(). { keyname_t *kn; static char tinystr[5]; int i, j; if ( keynum == -1 ) { return "<KEY NOT FOUND>"; } if ( keynum < 0 || keynum > 255 ) { return "<OUT OF RANGE>"; } // check for printable ascii (don't use quote) if ( keynum > 32 && keynum < 127 && keynum != '"' && keynum != ';' ) { tinystr[0] = keynum; tinystr[1] = 0; return tinystr; } // check for a key string for ( kn=keynames ; kn->name ; kn++ ) { if (keynum == kn->keynum) { return kn->name; } } // make a hex string i = keynum >> 4; j = keynum & 15; tinystr[0] = '0'; tinystr[1] = 'x'; tinystr[2] = i > 9 ? i - 10 + 'a' : i + '0'; tinystr[3] = j > 9 ? j - 10 + 'a' : j + '0'; tinystr[4] = 0; return tinystr; }

void Key_SetCatcher (  int  catcher  )

Definition at line 679 of file cl_ui.c. References cls, and clientStatic_t::keyCatchers. Referenced by CL_CgameSystemCalls(), and CL_UISystemCalls(). { cls.keyCatchers = catcher; }

void LAN_LoadCachedServers (   )

Definition at line 50 of file cl_ui.c. References cls, clientStatic_t::favoriteServers, fileHandle_t, FS_FCloseFile(), FS_Read(), FS_SV_FOpenFileRead(), clientStatic_t::globalServers, clientStatic_t::mplayerServers, clientStatic_t::numfavoriteservers, clientStatic_t::numGlobalServerAddresses, clientStatic_t::numglobalservers, and clientStatic_t::nummplayerservers. Referenced by CL_UISystemCalls(). { int size; fileHandle_t fileIn; cls.numglobalservers = cls.nummplayerservers = cls.numfavoriteservers = 0; cls.numGlobalServerAddresses = 0; if (FS_SV_FOpenFileRead("servercache.dat", &fileIn)) { FS_Read(&cls.numglobalservers, sizeof(int), fileIn); FS_Read(&cls.nummplayerservers, sizeof(int), fileIn); FS_Read(&cls.numfavoriteservers, sizeof(int), fileIn); FS_Read(&size, sizeof(int), fileIn); if (size == sizeof(cls.globalServers) + sizeof(cls.favoriteServers) + sizeof(cls.mplayerServers)) { FS_Read(&cls.globalServers, sizeof(cls.globalServers), fileIn); FS_Read(&cls.mplayerServers, sizeof(cls.mplayerServers), fileIn); FS_Read(&cls.favoriteServers, sizeof(cls.favoriteServers), fileIn); } else { cls.numglobalservers = cls.nummplayerservers = cls.numfavoriteservers = 0; cls.numGlobalServerAddresses = 0; } FS_FCloseFile(fileIn); } }

Here is the call graph for this function:

void LAN_SaveServersToCache (   )

Definition at line 77 of file cl_ui.c. References cls, clientStatic_t::favoriteServers, fileHandle_t, FS_FCloseFile(), FS_SV_FOpenFileWrite(), FS_Write(), clientStatic_t::globalServers, clientStatic_t::mplayerServers, clientStatic_t::numfavoriteservers, clientStatic_t::numglobalservers, and clientStatic_t::nummplayerservers. Referenced by CL_UISystemCalls(). { int size; fileHandle_t fileOut = FS_SV_FOpenFileWrite("servercache.dat"); FS_Write(&cls.numglobalservers, sizeof(int), fileOut); FS_Write(&cls.nummplayerservers, sizeof(int), fileOut); FS_Write(&cls.numfavoriteservers, sizeof(int), fileOut); size = sizeof(cls.globalServers) + sizeof(cls.favoriteServers) + sizeof(cls.mplayerServers); FS_Write(&size, sizeof(int), fileOut); FS_Write(&cls.globalServers, sizeof(cls.globalServers), fileOut); FS_Write(&cls.mplayerServers, sizeof(cls.mplayerServers), fileOut); FS_Write(&cls.favoriteServers, sizeof(cls.favoriteServers), fileOut); FS_FCloseFile(fileOut); }

Here is the call graph for this function:

void SCR_AdjustFrom640 (  float *  x, float *  y, float *  w, float *  h )

Definition at line 59 of file cl_scrn.c. References cls, clientStatic_t::glconfig, h(), glconfig_t::vidHeight, glconfig_t::vidWidth, w, x, and y. Referenced by CIN_DrawCinematic(), Con_DrawSolidConsole(), SCR_DrawChar(), SCR_DrawNamedPic(), SCR_DrawPic(), and SCR_FillRect(). { float xscale; float yscale; #if 0 // adjust for wide screens if ( cls.glconfig.vidWidth * 480 > cls.glconfig.vidHeight * 640 ) { *x += 0.5 * ( cls.glconfig.vidWidth - ( cls.glconfig.vidHeight * 640 / 480 ) ); } #endif // scale for screen sizes xscale = cls.glconfig.vidWidth / 640.0; yscale = cls.glconfig.vidHeight / 480.0; if ( x ) { *x *= xscale; } if ( y ) { *y *= yscale; } if ( w ) { *w *= xscale; } if ( h ) { *h *= yscale; } }

Here is the call graph for this function:

void SCR_DebugGraph (  float  value, int  color )

Definition at line 368 of file cl_scrn.c. { values[current&1023].value = value; values[current&1023].color = color; current++; }

void SCR_DrawBigString (  int  x, int  y, const char *  s, float  alpha )

Definition at line 243 of file cl_scrn.c. References BIGCHAR_WIDTH, qfalse, s, SCR_DrawStringExt(), x, and y. Referenced by Con_DrawNotify(), and Field_VariableSizeDraw(). { float color[4]; color[0] = color[1] = color[2] = 1.0; color[3] = alpha; SCR_DrawStringExt( x, y, BIGCHAR_WIDTH, s, color, qfalse ); }

Here is the call graph for this function:

void SCR_DrawBigStringColor (  int  x, int  y, const char *  s, vec4_t  color )

Definition at line 251 of file cl_scrn.c. References BIGCHAR_WIDTH, qtrue, s, SCR_DrawStringExt(), x, and y. { SCR_DrawStringExt( x, y, BIGCHAR_WIDTH, s, color, qtrue ); }

Here is the call graph for this function:

void SCR_DrawCinematic (  void   )

Definition at line 1697 of file cl_cin.c. References CIN_DrawCinematic(), and CL_handle. Referenced by SCR_DrawScreenField(). { if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) { CIN_DrawCinematic(CL_handle); } }

Here is the call graph for this function:

void SCR_DrawNamedPic (  float  x, float  y, float  width, float  height, const char *  picname )

Definition at line 41 of file cl_scrn.c. References assert, refexport_t::DrawStretchPic, height, qhandle_t, re, refexport_t::RegisterShader, SCR_AdjustFrom640(), width, x, and y. { qhandle_t hShader; assert( width != 0 ); hShader = re.RegisterShader( picname ); SCR_AdjustFrom640( &x, &y, &width, &height ); re.DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader ); }

Here is the call graph for this function:

void SCR_DrawPic (  float  x, float  y, float  width, float  height, qhandle_t  hShader )

Definition at line 111 of file cl_scrn.c. References refexport_t::DrawStretchPic, height, re, SCR_AdjustFrom640(), width, x, and y. Referenced by Con_DrawSolidConsole(). { SCR_AdjustFrom640( &x, &y, &width, &height ); re.DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader ); }

Here is the call graph for this function:

void SCR_DrawSmallChar (  int  x, int  y, int  ch )

Definition at line 160 of file cl_scrn.c. References ch, clientStatic_t::charSetShader, cls, col, refexport_t::DrawStretchPic, re, SMALLCHAR_HEIGHT, SMALLCHAR_WIDTH, x, and y. Referenced by Con_DrawInput(), Con_DrawNotify(), Con_DrawSolidConsole(), Field_VariableSizeDraw(), and SCR_DrawSmallStringExt(). { int row, col; float frow, fcol; float size; ch &= 255; if ( ch == ' ' ) { return; } if ( y < -SMALLCHAR_HEIGHT ) { return; } row = ch>>4; col = ch&15; frow = row*0.0625; fcol = col*0.0625; size = 0.0625; re.DrawStretchPic( x, y, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, fcol, frow, fcol + size, frow + size, cls.charSetShader ); }

void SCR_DrawSmallStringExt (  int  x, int  y, const char *  string, float *  setColor, qboolean  forceColor )

Definition at line 266 of file cl_scrn.c. References ColorIndex, Com_Memcpy(), g_color_table, NULL, Q_IsColorString, re, s, SCR_DrawSmallChar(), refexport_t::SetColor, xx, and y. Referenced by Field_VariableSizeDraw(). { vec4_t color; const char *s; int xx; // draw the colored text s = string; xx = x; re.SetColor( setColor ); while ( *s ) { if ( Q_IsColorString( s ) ) { if ( !forceColor ) { Com_Memcpy( color, g_color_table[ColorIndex(*(s+1))], sizeof( color ) ); color[3] = setColor[3]; re.SetColor( color ); } s += 2; continue; } SCR_DrawSmallChar( xx, y, *s ); xx += SMALLCHAR_WIDTH; s++; } re.SetColor( NULL ); }

Here is the call graph for this function:

void SCR_FillRect (  float  x, float  y, float  width, float  height, const float *  color )

Definition at line 94 of file cl_scrn.c. References cls, refexport_t::DrawStretchPic, height, NULL, re, SCR_AdjustFrom640(), refexport_t::SetColor, clientStatic_t::whiteShader, width, x, and y. Referenced by Con_DrawSolidConsole(). { re.SetColor( color ); SCR_AdjustFrom640( &x, &y, &width, &height ); re.DrawStretchPic( x, y, width, height, 0, 0, 0, 0, cls.whiteShader ); re.SetColor( NULL ); }

Here is the call graph for this function:

int SCR_GetBigStringWidth (  const char *  str  )

Definition at line 316 of file cl_scrn.c. References SCR_Strlen(). { return SCR_Strlen( str ) * 16; }

Here is the call graph for this function:

void SCR_Init (  void   )

Definition at line 418 of file cl_scrn.c. References cl_debuggraph, cl_graphheight, cl_graphscale, cl_graphshift, cl_timegraph, CVAR_CHEAT, Cvar_Get(), and scr_initialized. Referenced by CL_Init(). { cl_timegraph = Cvar_Get ("timegraph", "0", CVAR_CHEAT); cl_debuggraph = Cvar_Get ("debuggraph", "0", CVAR_CHEAT); cl_graphheight = Cvar_Get ("graphheight", "32", CVAR_CHEAT); cl_graphscale = Cvar_Get ("graphscale", "1", CVAR_CHEAT); cl_graphshift = Cvar_Get ("graphshift", "0", CVAR_CHEAT); scr_initialized = qtrue; }

Here is the call graph for this function:

void SCR_RunCinematic (  void   )

Definition at line 1703 of file cl_cin.c. References CIN_RunCinematic(), and CL_handle. Referenced by CL_Frame(), and CL_PlayCinematic_f(). { if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) { CIN_RunCinematic(CL_handle); } }

Here is the call graph for this function:

void SCR_StopCinematic (  void   )

Definition at line 1710 of file cl_cin.c. References CIN_StopCinematic(), CL_handle, and S_StopAllSounds(). Referenced by CL_Disconnect(), CL_Disconnect_f(), and CL_PlayCinematic_f(). { if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) { CIN_StopCinematic(CL_handle); S_StopAllSounds (); CL_handle = -1; } }

Here is the call graph for this function:

void SCR_UpdateScreen (  void   )

Definition at line 519 of file cl_scrn.c. References cls, Com_Error(), com_speeds, refexport_t::EndFrame, ERR_FATAL, clientStatic_t::glconfig, cvar_s::integer, NULL, re, SCR_DrawScreenField(), STEREO_CENTER, STEREO_LEFT, STEREO_RIGHT, glconfig_t::stereoEnabled, time_backend, and time_frontend. Referenced by CL_CgameSystemCalls(), CL_Frame(), CL_MapLoading(), CL_UISystemCalls(), and Console_Key(). { static int recursive; if ( !scr_initialized ) { return; // not initialized yet } if ( ++recursive > 2 ) { Com_Error( ERR_FATAL, "SCR_UpdateScreen: recursively called" ); } recursive = 1; // if running in stereo, we need to draw the frame twice if ( cls.glconfig.stereoEnabled ) { SCR_DrawScreenField( STEREO_LEFT ); SCR_DrawScreenField( STEREO_RIGHT ); } else { SCR_DrawScreenField( STEREO_CENTER ); } if ( com_speeds->integer ) { re.EndFrame( &time_frontend, &time_backend ); } else { re.EndFrame( NULL, NULL ); } recursive = 0; }

Here is the call graph for this function:

---

Variable Documentation

vm_t* cgvm

Definition at line 75 of file cl_main.c. Referenced by CL_CGameRendering(), CL_GameCommand(), CL_InitCGame(), CL_KeyEvent(), CL_MouseEvent(), CL_ShutdownCGame(), Con_MessageMode3_f(), and Con_MessageMode4_f().

clientActive_t cl

Definition at line 72 of file cl_main.c. Referenced by CalculateRanks(), CG_EntityEffects(), CheckExitRules(), CheckIntermissionExit(), CL_AdjustAngles(), CL_AdjustTimeDelta(), CL_CGameRendering(), CL_CheckTimeout(), CL_ClearState(), CL_ConfigstringModified(), CL_Configstrings_f(), CL_CreateCmd(), CL_CreateNewCommands(), CL_DeltaEntity(), CL_FinishMove(), CL_FirstSnapshot(), CL_GetCurrentCmdNumber(), CL_GetCurrentSnapshotNumber(), CL_GetGameState(), CL_GetParseEntityState(), CL_GetServerCommand(), CL_GetSnapshot(), CL_GetUserCmd(), CL_InitCGame(), CL_JoystickEvent(), CL_JoystickMove(), CL_MapLoading(), CL_MouseEvent(), CL_MouseMove(), CL_ParseGamestate(), CL_ParsePacketEntities(), CL_ParseSnapshot(), CL_ReadyToSendPacket(), CL_Record_f(), CL_SendPureChecksums(), CL_SetCGameTime(), CL_SetUserCmdValue(), CL_SystemInfoChanged(), CL_WritePacket(), ClientForString(), ClientNumberFromString(), Com_Frame(), Con_DrawNotify(), DeathmatchScoreboardMessage(), ExitLevel(), FloodEntities(), G_AddRandomBot(), G_CountBotPlayers(), G_CountHumanPlayers(), G_RemoveRandomBot(), GetClientState(), GetConfigString(), IN_CenterView(), LogExit(), Pickup_Team(), s714(), scon(), SpectatorClientEndFrame(), SV_Ban_f(), SV_BanNum_f(), SV_BeginDownload_f(), SV_BotAllocateClient(), SV_BotFreeClient(), SV_BotGetConsoleMessage(), SV_BotGetSnapshotEntity(), SV_CalcPings(), SV_CheckPaused(), SV_CheckTimeouts(), SV_ClientCommand(), SV_ClientThink(), SV_CloseDownload(), SV_DirectConnect(), SV_Disconnect_f(), SV_DoneDownload_f(), SV_DumpUser_f(), SV_ExecuteClientCommand(), SV_ExecuteClientMessage(), SV_FinalMessage(), SV_GetPlayerByName(), SV_GetPlayerByNum(), SV_Kick_f(), SV_KickNum_f(), SV_NextDownload_f(), SV_PacketEvent(), SV_ResetPureClient_f(), SV_SendServerCommand(), SV_Status_f(), SV_StopDownload_f(), SV_UpdateUserinfo_f(), SV_UserinfoChanged(), SV_UserMove(), SV_VerifyPaks_f(), SV_WriteDownloadToClient(), SVC_Status(), Svcmd_ForceTeam_f(), Team_TouchEnemyFlag(), Team_TouchOurFlag(), typestab(), VL_LightmapMatrixFromPoints(), and VS_LightmapMatrixFromPoints().

cvar_t* cl_activeAction

Definition at line 61 of file cl_main.c. Referenced by CL_FirstSnapshot(), and CL_Init().

cvar_t* cl_allowDownload

Definition at line 65 of file cl_main.c. Referenced by CL_Init(), and CL_InitDownloads().

cvar_t* cl_anglespeedkey

Definition at line 273 of file cl_input.c. Referenced by CL_AdjustAngles(), CL_Init(), and CL_JoystickMove().

int cl_connectedToPureServer

Definition at line 316 of file cl_parse.c. Referenced by CL_Disconnect(), CL_InitCGame(), CL_InitUI(), and CL_SystemInfoChanged().

cvar_t* cl_conXOffset

Definition at line 66 of file cl_main.c. Referenced by CL_Init(), and Con_DrawNotify().

cvar_t* cl_debugMove

Definition at line 28 of file cl_main.c. Referenced by CL_CreateCmd(), CL_InitInput(), and SCR_DrawScreenField().

cvar_t* cl_freelook

Definition at line 49 of file cl_main.c. Referenced by CL_Init(), CL_MouseMove(), and IN_MLookUp().

cvar_t* cl_freezeDemo

Definition at line 41 of file cl_main.c. Referenced by CL_Init(), and CL_SetCGameTime().

cvar_t* cl_inGameVideo

Definition at line 67 of file cl_main.c. Referenced by CIN_PlayCinematic(), CIN_UploadCinematic(), and CL_Init().

cvar_t* cl_maxpackets

Definition at line 37 of file cl_main.c. Referenced by CL_Init(), and CL_ReadyToSendPacket().

cvar_t* cl_mouseAccel

Definition at line 52 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* cl_nodelta

Definition at line 27 of file cl_main.c. Referenced by CL_InitInput(), and CL_WritePacket().

cvar_t* cl_noprint

Definition at line 30 of file cl_main.c. Referenced by CL_ConsolePrint(), and CL_Init().

cvar_t* cl_packetdup

Definition at line 38 of file cl_main.c. Referenced by CL_Init(), and CL_WritePacket().

cvar_t* cl_pitchspeed

Definition at line 269 of file cl_input.c. Referenced by CL_AdjustAngles(), CL_Init(), and CL_JoystickMove().

cvar_t* cl_run

Definition at line 271 of file cl_input.c. Referenced by CL_Init(), CL_JoystickMove(), and CL_KeyMove().

cvar_t* cl_sensitivity

Definition at line 50 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* cl_showMouseRate

Definition at line 53 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* cl_shownet

Definition at line 43 of file cl_main.c.

cvar_t* cl_showSend

Definition at line 44 of file cl_main.c. Referenced by CL_Init(), CL_SendCmd(), and CL_WritePacket().

cvar_t* cl_showTimeDelta

Definition at line 40 of file cl_main.c. Referenced by CL_AdjustTimeDelta(), and CL_Init().

cvar_t* cl_timedemo

Definition at line 45 of file cl_main.c. Referenced by CL_DemoCompleted(), CL_Init(), and CL_SetCGameTime().

cvar_t* cl_timegraph

Definition at line 28 of file cl_scrn.c. Referenced by CL_Frame(), SCR_DrawScreenField(), and SCR_Init().

cvar_t* cl_timeNudge

Definition at line 39 of file cl_main.c. Referenced by CL_Init(), and CL_SetCGameTime().

cvar_t* cl_yawspeed

Definition at line 268 of file cl_input.c. Referenced by CL_AdjustAngles(), CL_Init(), and CL_JoystickMove().

clientConnection_t clc

Definition at line 73 of file cl_main.c. Referenced by CL_AddReliableCommand(), CL_AdjustTimeDelta(), CL_BeginDownload(), CL_CGameRendering(), CL_ChangeReliableCommand(), CL_CheckForResend(), CL_CheckTimeout(), CL_Connect_f(), CL_ConnectionlessPacket(), CL_DemoCompleted(), CL_Disconnect(), CL_DisconnectPacket(), CL_DownloadsComplete(), CL_FirstSnapshot(), CL_ForwardCommandToServer(), CL_ForwardToServer_f(), CL_GetServerCommand(), CL_InitCGame(), CL_InitDownloads(), CL_KeyEvent(), CL_MapLoading(), CL_Netchan_Decode(), CL_Netchan_Encode(), CL_NextDownload(), CL_PacketEvent(), CL_ParseCommandString(), CL_ParseDownload(), CL_ParseGamestate(), CL_ParseServerMessage(), CL_ParseSnapshot(), CL_PlayDemo_f(), CL_Rcon_f(), CL_ReadDemoMessage(), CL_ReadyToSendPacket(), CL_Record_f(), CL_ServerStatus_f(), CL_SetCGameTime(), CL_StopRecord_f(), CL_SystemInfoChanged(), CL_Vid_Restart_f(), CL_WriteDemoMessage(), CL_WritePacket(), GetClientState(), and SCR_DrawDemoRecording().

clientStatic_t cls

Definition at line 74 of file cl_main.c.

int g_console_field_width

Definition at line 27 of file cl_console.c. Referenced by CL_InitRenderer().

kbutton_t in_klook

kbutton_t in_mlook

kbutton_t in_speed

Definition at line 52 of file cl_input.c. Referenced by CL_AdjustAngles(), CL_JoystickMove(), CL_KeyMove(), IN_SpeedDown(), and IN_SpeedUp().

kbutton_t in_strafe

Definition at line 52 of file cl_input.c. Referenced by CL_AdjustAngles(), CL_JoystickMove(), CL_KeyMove(), CL_MouseMove(), IN_StrafeDown(), and IN_StrafeUp().

cvar_t* m_filter

Definition at line 59 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* m_forward

Definition at line 57 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* m_pitch

Definition at line 55 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* m_side

Definition at line 58 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

cvar_t* m_yaw

Definition at line 56 of file cl_main.c. Referenced by CL_Init(), and CL_MouseMove().

refexport_t re

Definition at line 78 of file cl_main.c.

vm_t* uivm

Definition at line 29 of file cl_ui.c. Referenced by CIN_PlayCinematic(), CL_CharEvent(), CL_Disconnect(), CL_Frame(), CL_InitUI(), CL_KeyEvent(), CL_MouseEvent(), CL_ShutdownUI(), SCR_DrawScreenField(), UI_GameCommand(), and UI_usesUniqueCDKey().

---