main.c File Reference

#include "client.h"

Go to the source code of this file.

Classes
struct	request_t
struct	ignore_t

Macros
#define	MAX_REQUESTS   64
#define	REQUEST_MASK   (MAX_REQUESTS - 1)

Enumerations
enum	requestType_t {   REQ_FREE, REQ_STATUS_CL, REQ_STATUS_UI, REQ_INFO,   REQ_RCON }
enum	sync_mode_t {   SYNC_FULL, SYNC_MAXFPS, SYNC_SLEEP_10, SYNC_SLEEP_60,   SYNC_SLEEP_VIDEO, ASYNC_VIDEO, ASYNC_MAXFPS, ASYNC_FULL }

Functions
static request_t *	CL_AddRequest (const netadr_t *adr, requestType_t type)
static request_t *	CL_FindRequest (void)
static void	CL_UpdateGunSetting (void)
static void	CL_UpdateGibSetting (void)
static void	CL_UpdateFootstepsSetting (void)
static void	CL_UpdatePredictSetting (void)
void	CL_UpdateRecordingSetting (void)
void	CL_ClientCommand (const char *string)
qboolean	CL_ForwardToServer (void)
static void	CL_ForwardToServer_f (void)
static void	CL_Pause_f (void)
void	CL_CheckForResend (void)
static void	CL_RecentIP_g (genctx_t *ctx)
static void	CL_Connect_c (genctx_t *ctx, int argnum)
static void	CL_Connect_f (void)
static void	CL_FollowIP_f (void)
static void	CL_PassiveConnect_f (void)
void	CL_SendRcon (const netadr_t *adr, const char *pass, const char *cmd)
static void	CL_Rcon_f (void)
static void	CL_Rcon_c (genctx_t *ctx, int argnum)
void	CL_ClearState (void)
void	CL_Disconnect (error_type_t type)
static void	CL_Disconnect_f (void)
static void	CL_ServerStatus_c (genctx_t *ctx, int argnum)
static void	CL_ServerStatus_f (void)
static int	SortPlayers (const void *v1, const void *v2)
static void	CL_ParseStatusResponse (serverStatus_t *status, const char *string)
static void	CL_DumpStatusResponse (const serverStatus_t *status)
static void	CL_ParsePrintMessage (void)
static void	CL_ParseInfoMessage (void)
static void	CL_Changing_f (void)
static void	CL_Reconnect_f (void)
static void	CL_PingServers_f (void)
static void	CL_Skins_f (void)
static void	cl_noskins_changed (cvar_t *self)
static void	cl_vwep_changed (cvar_t *self)
static void	CL_Name_g (genctx_t *ctx)
static void	CL_ConnectionlessPacket (void)
static void	CL_PacketEvent (void)
static void	CL_FixUpGender (void)
void	CL_UpdateUserinfo (cvar_t *var, from_t from)
static void	CL_Userinfo_f (void)
static void	CL_RestartSound_f (void)
static void	CL_PlaySound_c (genctx_t *ctx, int state)
static void	CL_PlaySound_f (void)
void	CL_Begin (void)
static void	CL_Precache_f (void)
static ignore_t *	find_ignore (const char *match)
static void	list_ignores (void)
static void	add_ignore (const char *match)
static void	remove_ignore (const char *match)
static void	remove_all_ignores (void)
static void	CL_IgnoreText_f (void)
static void	CL_UnIgnoreText_f (void)
static void	CL_IgnoreNick_c (genctx_t *ctx, int argnum)
static size_t	parse_ignore_nick (int argnum, char *buffer)
static void	CL_IgnoreNick_f (void)
static void	CL_UnIgnoreNick_f (void)
qboolean	CL_CheckForIgnore (const char *s)
static void	CL_DumpClients_f (void)
static void	dump_program (const char *text, const char *name)
static void	CL_DumpStatusbar_f (void)
static void	CL_DumpLayout_f (void)
static void	CL_WriteConfig_c (genctx_t *ctx, int argnum)
static void	CL_WriteConfig_f (void)
static void	CL_Say_c (genctx_t *ctx, int argnum)
static size_t	CL_Mapname_m (char *buffer, size_t size)
static size_t	CL_Server_m (char *buffer, size_t size)
static size_t	CL_Ups_m (char *buffer, size_t size)
static size_t	CL_Timer_m (char *buffer, size_t size)
static size_t	CL_DemoPos_m (char *buffer, size_t size)
static size_t	CL_Fps_m (char *buffer, size_t size)
static size_t	R_Fps_m (char *buffer, size_t size)
static size_t	CL_Mps_m (char *buffer, size_t size)
static size_t	CL_Pps_m (char *buffer, size_t size)
static size_t	CL_Ping_m (char *buffer, size_t size)
static size_t	CL_Lag_m (char *buffer, size_t size)
static size_t	CL_Health_m (char *buffer, size_t size)
static size_t	CL_Ammo_m (char *buffer, size_t size)
static size_t	CL_Armor_m (char *buffer, size_t size)
static size_t	CL_WeaponModel_m (char *buffer, size_t size)
static size_t	CL_Cluster_m (char *buffer, size_t size)
static size_t	CL_ClusterThere_m (char *buffer, size_t size)
static size_t	CL_NumLightPolys_m (char *buffer, size_t size)
static size_t	CL_Material_m (char *buffer, size_t size)
static size_t	CL_Material_Override_m (char *buffer, size_t size)
static size_t	CL_ViewPos_m (char *buffer, size_t size)
static size_t	CL_ViewDir_m (char *buffer, size_t size)
static size_t	CL_HdrColor_m (char *buffer, size_t size)
static size_t	CL_ResolutionScale_m (char *buffer, size_t size)
int	CL_GetFps ()
int	CL_GetResolutionScale ()
void	CL_WriteConfig (void)
void	CL_RestartFilesystem (qboolean total)
void	CL_RestartRefresh (qboolean total)
static void	CL_ReloadRefresh_f (void)
static void	CL_RestartRefresh_f (void)
static void	exec_server_string (cmdbuf_t *buf, const char *text)
static void	cl_player_model_changed (cvar_t *self)
static void	info_hand_changed (cvar_t *self)
static void	cl_gibs_changed (cvar_t *self)
static void	cl_footsteps_changed (cvar_t *self)
static void	cl_predict_changed (cvar_t *self)
static void	cl_sync_changed (cvar_t *self)
static void	cl_allow_download_changed (cvar_t *self)
static void	cl_chat_sound_changed (cvar_t *self)
static void	CL_InitLocal (void)
qboolean	CL_CheatsOK (void)
void	CL_Activate (active_t active)
static void	CL_SetClientTime (void)
static void	CL_MeasureStats (void)
static void	CL_CheckTimeout (void)
void	CL_CheckForPause (void)
static int	fps_to_msec (int fps)
void	CL_UpdateFrameTimes (void)
unsigned	CL_Frame (unsigned msec)
qboolean	CL_ProcessEvents (void)
void	CL_Init (void)
void	CL_Shutdown (void)

Variables
cvar_t *	rcon_address
cvar_t *	cl_noskins
cvar_t *	cl_footsteps
cvar_t *	cl_timeout
cvar_t *	cl_predict
cvar_t *	cl_gun
cvar_t *	cl_gunalpha
cvar_t *	cl_maxfps
cvar_t *	cl_async
cvar_t *	r_maxfps
cvar_t *	cl_autopause
cvar_t *	cl_kickangles
cvar_t *	cl_rollhack
cvar_t *	cl_noglow
cvar_t *	cl_nolerp
cvar_t *	cl_player_model
cvar_t *	cl_thirdperson_angle
cvar_t *	cl_thirdperson_range
cvar_t *	cl_disable_particles
cvar_t *	cl_disable_explosions
cvar_t *	cl_chat_notify
cvar_t *	cl_chat_sound
cvar_t *	cl_chat_filter
cvar_t *	cl_explosion_sprites
cvar_t *	cl_explosion_frametime
cvar_t *	cl_disconnectcmd
cvar_t *	cl_changemapcmd
cvar_t *	cl_beginmapcmd
cvar_t *	cl_gibs
cvar_t *	cl_protocol
cvar_t *	gender_auto
cvar_t *	cl_vwep
cvar_t *	cl_cinematics
cvar_t *	info_password
cvar_t *	info_spectator
cvar_t *	info_name
cvar_t *	info_skin
cvar_t *	info_rate
cvar_t *	info_fov
cvar_t *	info_msg
cvar_t *	info_hand
cvar_t *	info_gender
cvar_t *	info_uf
cvar_t *	gl_modulate_world
cvar_t *	gl_modulate_entities
cvar_t *	gl_brightness
cvar_t *	fs_shareware
client_static_t	cls
client_state_t	cl
centity_t	cl_entities [MAX_EDICTS]
cmdbuf_t	cl_cmdbuf
char	cl_cmdbuf_text [MAX_STRING_CHARS]
static request_t	clientRequests [MAX_REQUESTS]
static unsigned	nextRequest
static int	precache_spawncount
static list_t	cl_ignores
static const cmd_option_t	o_writeconfig []
static const cmdreg_t	c_client []
static int	ref_msec
static int	phys_msec
static int	main_msec
static int	ref_extra
static int	phys_extra
static int	main_extra
static sync_mode_t	sync_mode

Macro Definition Documentation

MAX_REQUESTS

#define MAX_REQUESTS   64

Definition at line 123 of file main.c.

REQUEST_MASK

#define REQUEST_MASK   (MAX_REQUESTS - 1)

Definition at line 124 of file main.c.

Enumeration Type Documentation

requestType_t

enum requestType_t

Enumerator
REQ_FREE
REQ_STATUS_CL
REQ_STATUS_UI
REQ_INFO
REQ_RCON

Definition at line 109 of file main.c.

             {
    REQ_FREE,
    REQ_STATUS_CL,
    REQ_STATUS_UI,
    REQ_INFO,
    REQ_RCON
} requestType_t;

sync_mode_t

enum sync_mode_t

Enumerator
SYNC_FULL
SYNC_MAXFPS
SYNC_SLEEP_10
SYNC_SLEEP_60
SYNC_SLEEP_VIDEO
ASYNC_VIDEO
ASYNC_MAXFPS
ASYNC_FULL

Definition at line 3092 of file main.c.

             {
    SYNC_FULL,
    SYNC_MAXFPS,
    SYNC_SLEEP_10,
    SYNC_SLEEP_60,
    SYNC_SLEEP_VIDEO,
    ASYNC_VIDEO,
    ASYNC_MAXFPS,
    ASYNC_FULL
} sync_mode_t;

Function Documentation

add_ignore()

static void add_ignore ( const char *  match )

static

Definition at line 1870 of file main.c.

{
    ignore_t *ignore;
    size_t matchlen;
 
    // don't create the same ignore twice
    if (find_ignore(match)) {
        return;
    }
 
    matchlen = strlen(match);
    if (matchlen < 3) {
        Com_Printf("Match string \"%s\" is too short.\n", match);
        return;
    }
 
    ignore = Z_Malloc(sizeof(*ignore) + matchlen);
    ignore->hits = 0;
    memcpy(ignore->match, match, matchlen + 1);
    List_Append(&cl_ignores, &ignore->entry);
}

Referenced by CL_IgnoreNick_f(), and CL_IgnoreText_f().

CL_Activate()

void CL_Activate

(

active_t

active

)

Definition at line 2905 of file main.c.

{
    if (cls.active != active) {
        Com_DDDPrintf("%s: %u\n", __func__, active);
        cls.active = active;
        cls.disable_screen = 0;
        Key_ClearStates();
        IN_Activate();
        S_Activate();
        CL_UpdateFrameTimes();
    }
}

Referenced by Win_Activate().

CL_AddRequest()

static request_t* CL_AddRequest ( const netadr_t *  adr, requestType_t  type  )

static

Definition at line 129 of file main.c.

{
    request_t *r;
 
    r = &clientRequests[nextRequest++ & REQUEST_MASK];
    r->adr = *adr;
    r->type = type;
    r->time = cls.realtime;
 
    return r;
}

Referenced by CL_PingServers_f(), CL_SendRcon(), and CL_ServerStatus_f().

cl_allow_download_changed()

static void cl_allow_download_changed ( cvar_t *  self )

static

Definition at line 2636 of file main.c.

{
    if (self->integer == -1) {
        self->flags |= CVAR_ROM;
    }
}

Referenced by CL_InitLocal().

CL_Ammo_m()

static size_t CL_Ammo_m ( char *  buffer, size_t  size  )

static

Definition at line 2312 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cl.frame.ps.stats[STAT_AMMO]);
}

Referenced by CL_InitLocal().

CL_Armor_m()

static size_t CL_Armor_m ( char *  buffer, size_t  size  )

static

Definition at line 2317 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cl.frame.ps.stats[STAT_ARMOR]);
}

Referenced by CL_InitLocal().

CL_Begin()

void CL_Begin

(

void

)

Definition at line 1757 of file main.c.

{
#if USE_REF == REF_GL
    if (!Q_stricmp(cl.gamedir, "gloom")) {
        // cheat protect our custom modulate cvars
        gl_modulate_world->flags |= CVAR_CHEAT;
        gl_modulate_entities->flags |= CVAR_CHEAT;
        gl_brightness->flags |= CVAR_CHEAT;
    }
#endif
 
    Cvar_FixCheats();
 
    CL_PrepRefresh();
    CL_LoadState(LOAD_SOUNDS);
    CL_RegisterSounds();
    LOC_LoadLocations();
    CL_LoadState(LOAD_NONE);
    cls.state = ca_precached;
 
#if USE_FPS
    CL_UpdateRateSetting();
#endif
 
    CL_ClientCommand(va("begin %i\n", precache_spawncount));
 
    CL_UpdateGunSetting();
    CL_UpdateBlendSetting();
    CL_UpdateGibSetting();
    CL_UpdateFootstepsSetting();
    CL_UpdatePredictSetting();
    CL_UpdateRecordingSetting();
}

Referenced by CL_RequestNextDownload().

CL_Changing_f()

static void CL_Changing_f ( void  )

static

Definition at line 1070 of file main.c.

{
    int i, j;
    char *s;
 
    if (cls.state < ca_connected) {
        return;
    }
 
    if (cls.demo.recording)
        CL_Stop_f();
 
    S_StopAllSounds();
 
    Com_Printf("Changing map...\n");
 
    if (!cls.demo.playback) {
        EXEC_TRIGGER(cl_changemapcmd);
        Cmd_ExecTrigger("#cl_changelevel");
    }
 
    SCR_BeginLoadingPlaque();
 
    cls.state = ca_connected;   // not active anymore, but not disconnected
    cl.mapname[0] = 0;
    cl.configstrings[CS_NAME][0] = 0;
 
    CL_CheckForPause();
 
    CL_UpdateFrameTimes();
 
    // parse additional parameters
    j = Cmd_Argc();
    for (i = 1; i < j; i++) {
        s = Cmd_Argv(i);
        if (!strncmp(s, "map=", 4)) {
            Q_strlcpy(cl.mapname, s + 4, sizeof(cl.mapname));
        }
    }
 
    SCR_UpdateScreen();
}

Referenced by exec_server_string().

cl_chat_sound_changed()

static void cl_chat_sound_changed ( cvar_t *  self )

static

Definition at line 2644 of file main.c.

{
    if (!*self->string)
        self->integer = 0;
    else if (!Q_stricmp(self->string, "misc/talk.wav"))
        self->integer = 1;
    else if (!Q_stricmp(self->string, "misc/talk1.wav"))
        self->integer = 2;
    else if (!self->integer && !COM_IsUint(self->string))
        self->integer = 1;
}

Referenced by CL_InitLocal().

CL_CheatsOK()

qboolean CL_CheatsOK

(

void

)

Definition at line 2871 of file main.c.

{
    // can cheat when disconnected or playing a demo
    if (cls.state < ca_connected || cls.demo.playback)
        return qtrue;
 
    // can't cheat on remote servers
    if (!sv_running->integer)
        return qfalse;
 
    // developer option
    if (Cvar_VariableInteger("cheats"))
        return qtrue;
 
    // single player can cheat
    if (cls.state > ca_connected && cl.maxclients == 1)
        return qtrue;
 
#if USE_MVD_CLIENT
    // can cheat when playing MVD
    if (MVD_GetDemoPercent(NULL, NULL) != -1)
        return qtrue;
#endif
 
    return qfalse;
}

Referenced by Cvar_FixCheats(), Cvar_SetByVar(), and get_engine_cvar().

CL_CheckForIgnore()

qboolean CL_CheckForIgnore

(

const char *

s

)

Definition at line 2043 of file main.c.

{
    char buffer[MAX_STRING_CHARS];
    ignore_t *ignore;
 
    if (LIST_EMPTY(&cl_ignores)) {
        return qfalse;
    }
 
    Q_strlcpy(buffer, s, sizeof(buffer));
    COM_strclr(buffer);
 
    LIST_FOR_EACH(ignore_t, ignore, &cl_ignores, entry) {
        if (Com_WildCmp(ignore->match, buffer)) {
            ignore->hits++;
            return qtrue;
        }
    }
 
    return qfalse;
}

Referenced by CL_ParsePrint().

CL_CheckForPause()

void CL_CheckForPause

(

void

)

Definition at line 3056 of file main.c.

{
    if (cls.state != ca_active) {
        // only pause when active
        Cvar_Set("cl_paused", "0");
        Cvar_Set("sv_paused", "0");
        return;
    }
 
    if (cls.key_dest & (KEY_CONSOLE | KEY_MENU)) {
        // only pause in single player
        if (cl_paused->integer == 0 && cl_autopause->integer) {
            Cvar_Set("cl_paused", "1");
        }
    } else if (cl_paused->integer == 1) {
        // only resume after automatic pause
        Cvar_Set("cl_paused", "0");
    }
 
    // hack for demo playback pause/unpause
    if (cls.demo.playback) {
        // don't pause when running timedemo!
        if (cl_paused->integer && !com_timedemo->integer) {
            if (!sv_paused->integer) {
                Cvar_Set("sv_paused", "1");
                IN_Activate();
            }
        } else {
            if (sv_paused->integer) {
                Cvar_Set("sv_paused", "0");
                IN_Activate();
            }
        }
    }
}

Referenced by CL_Changing_f(), CL_ClearState(), CL_Disconnect(), CL_Pause_f(), Key_SetDest(), and set_active_state().

CL_CheckForResend()

void CL_CheckForResend

(

void

)

Definition at line 387 of file main.c.

{
    char tail[MAX_QPATH];
    char userinfo[MAX_INFO_STRING];
    int maxmsglen;
 
    if (cls.demo.playback) {
        return;
    }
 
    // if the local server is running and we aren't
    // then connect
    if (cls.state < ca_connecting && sv_running->integer > ss_loading) {
        strcpy(cls.servername, "localhost");
        cls.serverAddress.type = NA_LOOPBACK;
        cls.serverProtocol = cl_protocol->integer;
        if (cls.serverProtocol < PROTOCOL_VERSION_DEFAULT ||
            cls.serverProtocol > PROTOCOL_VERSION_Q2PRO) {
            cls.serverProtocol = PROTOCOL_VERSION_Q2PRO;
        }
 
        // we don't need a challenge on the localhost
        cls.state = ca_connecting;
        cls.connect_time -= CONNECT_FAST;
        cls.connect_count = 0;
 
        cls.passive = qfalse;
 
        Con_Popup(qtrue);
        UI_OpenMenu(UIMENU_NONE);
    }
 
    // resend if we haven't gotten a reply yet
    if (cls.state != ca_connecting && cls.state != ca_challenging) {
        return;
    }
 
    if (cls.realtime - cls.connect_time < CONNECT_DELAY) {
        return;
    }
 
    cls.connect_time = cls.realtime;    // for retransmit requests
    cls.connect_count++;
 
    if (cls.state == ca_challenging) {
        Com_Printf("Requesting challenge... %i\n", cls.connect_count);
        OOB_PRINT(NS_CLIENT, &cls.serverAddress, "getchallenge\n");
        return;
    }
 
    //
    // We have gotten a challenge from the server, so try and connect.
    //
    Com_Printf("Requesting connection... %i\n", cls.connect_count);
 
    cls.userinfo_modified = 0;
 
    // use maximum allowed msglen for loopback
    maxmsglen = net_maxmsglen->integer;
    if (NET_IsLocalAddress(&cls.serverAddress)) {
        maxmsglen = MAX_PACKETLEN_WRITABLE;
    }
 
    // add protocol dependent stuff
    switch (cls.serverProtocol) {
    case PROTOCOL_VERSION_R1Q2:
        Q_snprintf(tail, sizeof(tail), " %d %d",
                   maxmsglen, PROTOCOL_VERSION_R1Q2_CURRENT);
        cls.quakePort = net_qport->integer & 0xff;
        break;
    case PROTOCOL_VERSION_Q2PRO:
        Q_snprintf(tail, sizeof(tail), " %d %d %d %d",
                   maxmsglen, net_chantype->integer, USE_ZLIB,
                   PROTOCOL_VERSION_Q2PRO_CURRENT);
        cls.quakePort = net_qport->integer & 0xff;
        break;
    default:
        tail[0] = 0;
        cls.quakePort = net_qport->integer;
        break;
    }
 
    Cvar_BitInfo(userinfo, CVAR_USERINFO);
    Netchan_OutOfBand(NS_CLIENT, &cls.serverAddress,
                      "connect %i %i %i \"%s\"%s\n", cls.serverProtocol, cls.quakePort,
                      cls.challenge, userinfo, tail);
}

Referenced by CL_Connect_f(), CL_ConnectionlessPacket(), CL_Frame(), and CL_ParseReconnect().

CL_CheckTimeout()

static void CL_CheckTimeout ( void  )

static

Definition at line 3022 of file main.c.

{
    unsigned delta;
 
    if (NET_IsLocalAddress(&cls.netchan->remote_address)) {
        return;
    }
 
#if USE_ICMP
    if (cls.errorReceived) {
        delta = 5000;
        if (com_localTime - cls.netchan->last_received > delta)  {
            Com_Error(ERR_DISCONNECT, "Server connection was reset.");
        }
    }
#endif
 
    delta = cl_timeout->value * 1000;
    if (delta && com_localTime - cls.netchan->last_received > delta)  {
        // timeoutcount saves debugger
        if (++cl.timeoutcount > 5) {
            Com_Error(ERR_DISCONNECT, "Server connection timed out.");
        }
    } else {
        cl.timeoutcount = 0;
    }
}

Referenced by CL_Frame().

CL_ClearState()

void CL_ClearState

(

void

)

Definition at line 699 of file main.c.

{
    S_StopAllSounds();
    CL_ClearEffects();
#if USE_LIGHTSTYLES
    CL_ClearLightStyles();
#endif
    CL_ClearTEnts();
    LOC_FreeLocations();
 
    // wipe the entire cl structure
    BSP_Free(cl.bsp);
    memset(&cl, 0, sizeof(cl));
    memset(&cl_entities, 0, sizeof(cl_entities));
 
    if (cls.state > ca_connected) {
        cls.state = ca_connected;
        CL_CheckForPause();
        CL_UpdateFrameTimes();
    }
 
    // unprotect game cvar
    fs_game->flags &= ~CVAR_ROM;
 
#if USE_REF == REF_GL
    // unprotect our custom modulate cvars
    if(gl_modulate_world) gl_modulate_world->flags &= ~CVAR_CHEAT;
    if(gl_modulate_entities) gl_modulate_entities->flags &= ~CVAR_CHEAT;
    if(gl_brightness) gl_brightness->flags &= ~CVAR_CHEAT;
#endif
}

Referenced by CL_Disconnect(), and CL_ParseServerData().

CL_ClientCommand()

void CL_ClientCommand

(

const char *

string

)

Definition at line 299 of file main.c.

{
    if (!cls.netchan) {
        return;
    }
 
    Com_DDPrintf("%s: %s\n", __func__, string);
 
    MSG_WriteByte(clc_stringcmd);
    MSG_WriteString(string);
    MSG_FlushTo(&cls.netchan->message);
}

Referenced by CL_Begin(), CL_ConnectionlessPacket(), CL_ForwardToServer(), CL_ForwardToServer_f(), CL_HandleDownload(), CL_Reconnect_f(), Con_Say(), HTTP_QueueDownload(), Key_Event(), SCR_FinishCinematic(), and start_udp_download().

CL_Cluster_m()

static size_t CL_Cluster_m ( char *  buffer, size_t  size  )

static

Definition at line 2328 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cl.refdef.feedback.viewcluster);
}

Referenced by CL_InitLocal().

CL_ClusterThere_m()

static size_t CL_ClusterThere_m ( char *  buffer, size_t  size  )

static

Definition at line 2333 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cl.refdef.feedback.lookatcluster);
}

Referenced by CL_InitLocal().

CL_Connect_c()

static void CL_Connect_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 492 of file main.c.

{
    if (argnum == 1) {
        CL_RecentIP_g(ctx);
        Com_Address_g(ctx);
    } else if (argnum == 2) {
        if (!ctx->partial[0] || (ctx->partial[0] == '3' && !ctx->partial[1])) {
            Prompt_AddMatch(ctx, "34");
            Prompt_AddMatch(ctx, "35");
            Prompt_AddMatch(ctx, "36");
        }
    }
}

CL_Connect_f()

static void CL_Connect_f ( void  )

static

Definition at line 512 of file main.c.

{
    char    *server, *p;
    netadr_t    address;
    int protocol;
    int argc = Cmd_Argc();
 
    if (fs_shareware->integer)
    {
        Com_EPrintf("Multiplayer is not supported in the shareware version of the game.\n");
        return;
    }
 
    if (argc < 2) {
usage:
        Com_Printf("Usage: %s <server> [34|35|36]\n", Cmd_Argv(0));
        return;
    }
 
    if (argc > 2) {
        protocol = atoi(Cmd_Argv(2));
        if (protocol < PROTOCOL_VERSION_DEFAULT ||
            protocol > PROTOCOL_VERSION_Q2PRO) {
            goto usage;
        }
    } else {
        protocol = cl_protocol->integer;
        if (!protocol) {
            protocol = PROTOCOL_VERSION_Q2PRO;
        }
    }
 
    server = Cmd_Argv(1);
 
    // support quake2://<address>[/] scheme
    if (!Q_strncasecmp(server, "quake2://", 9)) {
        server += 9;
        if ((p = strchr(server, '/')) != NULL) {
            *p = 0;
        }
    }
 
    if (!NET_StringToAdr(server, &address, PORT_SERVER)) {
        Com_Printf("Bad server address\n");
        return;
    }
 
    // copy early to avoid potential cmd_argv[1] clobbering
    Q_strlcpy(cls.servername, server, sizeof(cls.servername));
 
    // if running a local server, kill it and reissue
    SV_Shutdown("Server was killed.\n", ERR_DISCONNECT);
 
    NET_Config(NET_CLIENT);
 
    CL_Disconnect(ERR_RECONNECT);
 
    cls.serverAddress = address;
    cls.serverProtocol = protocol;
    cls.protocolVersion = 0;
    cls.passive = qfalse;
    cls.state = ca_challenging;
    cls.connect_time -= CONNECT_FAST;
    cls.connect_count = 0;
 
    Con_Popup(qtrue);
 
    CL_CheckForResend();
 
    Cvar_Set("timedemo", "0");
}

CL_ConnectionlessPacket()

static void CL_ConnectionlessPacket ( void  )

static

Definition at line 1315 of file main.c.

{
    char    string[MAX_STRING_CHARS];
    char    *s, *c;
    int     i, j, k;
    size_t  len;
 
    MSG_BeginReading();
    MSG_ReadLong(); // skip the -1
 
    len = MSG_ReadStringLine(string, sizeof(string));
    if (len >= sizeof(string)) {
        Com_DPrintf("Oversize message received.  Ignored.\n");
        return;
    }
 
    Cmd_TokenizeString(string, qfalse);
 
    c = Cmd_Argv(0);
 
    Com_DPrintf("%s: %s\n", NET_AdrToString(&net_from), string);
 
    // challenge from the server we are connecting to
    if (!strcmp(c, "challenge")) {
        int mask = 0;
 
        if (cls.state < ca_challenging) {
            Com_DPrintf("Challenge received while not connecting.  Ignored.\n");
            return;
        }
        if (!NET_IsEqualBaseAdr(&net_from, &cls.serverAddress)) {
            Com_DPrintf("Challenge from different address.  Ignored.\n");
            return;
        }
        if (cls.state > ca_challenging) {
            Com_DPrintf("Dup challenge received.  Ignored.\n");
            return;
        }
 
        cls.challenge = atoi(Cmd_Argv(1));
        cls.state = ca_connecting;
        cls.connect_time -= CONNECT_INSTANT; // fire immediately
        //cls.connect_count = 0;
 
        // parse additional parameters
        j = Cmd_Argc();
        for (i = 2; i < j; i++) {
            s = Cmd_Argv(i);
            if (!strncmp(s, "p=", 2)) {
                s += 2;
                while (*s) {
                    k = strtoul(s, &s, 10);
                    if (k == PROTOCOL_VERSION_R1Q2) {
                        mask |= 1;
                    } else if (k == PROTOCOL_VERSION_Q2PRO) {
                        mask |= 2;
                    }
                    s = strchr(s, ',');
                    if (s == NULL) {
                        break;
                    }
                    s++;
                }
            }
        }
 
        // choose supported protocol
        switch (cls.serverProtocol) {
        case PROTOCOL_VERSION_Q2PRO:
            if (mask & 2) {
                break;
            }
            cls.serverProtocol = PROTOCOL_VERSION_R1Q2;
        case PROTOCOL_VERSION_R1Q2:
            if (mask & 1) {
                break;
            }
        default:
            cls.serverProtocol = PROTOCOL_VERSION_DEFAULT;
            break;
        }
        Com_DPrintf("Selected protocol %d\n", cls.serverProtocol);
 
        CL_CheckForResend();
        return;
    }
 
    // server connection
    if (!strcmp(c, "client_connect")) {
        netchan_type_t type;
        int anticheat = 0;
        char mapname[MAX_QPATH];
        qboolean got_server = qfalse;
 
        if (cls.state < ca_connecting) {
            Com_DPrintf("Connect received while not connecting.  Ignored.\n");
            return;
        }
        if (!NET_IsEqualBaseAdr(&net_from, &cls.serverAddress)) {
            Com_DPrintf("Connect from different address.  Ignored.\n");
            return;
        }
        if (cls.state > ca_connecting) {
            Com_DPrintf("Dup connect received.  Ignored.\n");
            return;
        }
 
        if (cls.serverProtocol == PROTOCOL_VERSION_Q2PRO) {
            type = NETCHAN_NEW;
        } else {
            type = NETCHAN_OLD;
        }
 
        mapname[0] = 0;
 
        // parse additional parameters
        j = Cmd_Argc();
        for (i = 1; i < j; i++) {
            s = Cmd_Argv(i);
            if (!strncmp(s, "ac=", 3)) {
                s += 3;
                if (*s) {
                    anticheat = atoi(s);
                }
            } else if (!strncmp(s, "nc=", 3)) {
                s += 3;
                if (*s) {
                    type = atoi(s);
                    if (type != NETCHAN_OLD && type != NETCHAN_NEW) {
                        Com_Error(ERR_DISCONNECT,
                                  "Server returned invalid netchan type");
                    }
                }
            } else if (!strncmp(s, "map=", 4)) {
                Q_strlcpy(mapname, s + 4, sizeof(mapname));
            } else if (!strncmp(s, "dlserver=", 9)) {
                if (!got_server) {
                    HTTP_SetServer(s + 9);
                    got_server = qtrue;
                }
            }
        }
 
        if (!got_server) {
            HTTP_SetServer(NULL);
        }
 
        Com_Printf("Connected to %s (protocol %d).\n",
                   NET_AdrToString(&cls.serverAddress), cls.serverProtocol);
        if (cls.netchan) {
            // this may happen after svc_reconnect
            Netchan_Close(cls.netchan);
        }
        cls.netchan = Netchan_Setup(NS_CLIENT, type, &cls.serverAddress,
                                    cls.quakePort, 1024, cls.serverProtocol);
 
#if USE_AC_CLIENT
        if (anticheat) {
            MSG_WriteByte(clc_nop);
            MSG_FlushTo(&cls.netchan->message);
            cls.netchan->Transmit(cls.netchan, 0, NULL, 3);
            S_StopAllSounds();
            cls.connect_count = -1;
            Com_Printf("Loading anticheat, this may take a few moments...\n");
            SCR_UpdateScreen();
            if (!Sys_GetAntiCheatAPI()) {
                Com_Printf("Trying to connect without anticheat.\n");
            } else {
                Com_LPrintf(PRINT_NOTICE, "Anticheat loaded successfully.\n");
            }
        }
#else
        if (anticheat >= 2) {
            Com_Printf("Anticheat required by server, "
                       "but no anticheat support linked in.\n");
        }
#endif
 
        CL_ClientCommand("new");
        cls.state = ca_connected;
        cls.connect_count = 0;
        strcpy(cl.mapname, mapname);   // for levelshot screen
        return;
    }
 
    if (!strcmp(c, "passive_connect")) {
        if (!cls.passive) {
            Com_DPrintf("Passive connect received while not connecting.  Ignored.\n");
            return;
        }
        s = NET_AdrToString(&net_from);
        Com_Printf("Received passive connect from %s.\n", s);
 
        cls.serverAddress = net_from;
        cls.serverProtocol = cl_protocol->integer;
        Q_strlcpy(cls.servername, s, sizeof(cls.servername));
        cls.passive = qfalse;
 
        cls.state = ca_challenging;
        cls.connect_time -= CONNECT_FAST;
        cls.connect_count = 0;
 
        CL_CheckForResend();
        return;
    }
 
    // print command from somewhere
    if (!strcmp(c, "print")) {
        CL_ParsePrintMessage();
        return;
    }
 
    // server responding to a status broadcast
    if (!strcmp(c, "info")) {
        CL_ParseInfoMessage();
        return;
    }
 
    Com_DPrintf("Unknown connectionless packet command.\n");
}

Referenced by CL_PacketEvent().

CL_DemoPos_m()

static size_t CL_DemoPos_m ( char *  buffer, size_t  size  )

static

Definition at line 2256 of file main.c.

{
    int sec, min, framenum;
 
    if (cls.demo.playback)
        framenum = cls.demo.frames_read;
    else
#if USE_MVD_CLIENT
        if (MVD_GetDemoPercent(NULL, &framenum) == -1)
#endif
            framenum = 0;
 
    sec = framenum / 10; framenum %= 10;
    min = sec / 60; sec %= 60;
 
    return Q_scnprintf(buffer, size,
                       "%d:%02d.%d", min, sec, framenum);
}

Referenced by CL_InitLocal().

CL_Disconnect()

void CL_Disconnect

(

error_type_t

type

)

Definition at line 740 of file main.c.

{
    if (!cls.state) {
        return;
    }
 
    SCR_EndLoadingPlaque(); // get rid of loading plaque
 
    SCR_ClearChatHUD_f();   // clear chat HUD on server change
 
    if (cls.state > ca_disconnected && !cls.demo.playback) {
        EXEC_TRIGGER(cl_disconnectcmd);
    }
 
#if 0
    if (cls.ref_initialized) {
        R_CinematicSetPalette(NULL);
    }
#endif
 
    //cls.connect_time = 0;
    //cls.connect_count = 0;
    cls.passive = qfalse;
#if USE_ICMP
    cls.errorReceived = qfalse;
#endif
 
    if (cls.netchan) {
        // send a disconnect message to the server
        MSG_WriteByte(clc_stringcmd);
        MSG_WriteData("disconnect", 11);
 
        cls.netchan->Transmit(cls.netchan, msg_write.cursize, msg_write.data, 3);
 
        SZ_Clear(&msg_write);
 
        Netchan_Close(cls.netchan);
        cls.netchan = NULL;
    }
 
    // stop playback and/or recording
    CL_CleanupDemos();
 
    // stop download
    CL_CleanupDownloads();
 
    CL_ClearState();
 
    CL_GTV_Suspend();
 
    cls.state = ca_disconnected;
    cls.userinfo_modified = 0;
 
    if (type == ERR_DISCONNECT) {
        UI_OpenMenu(UIMENU_DEFAULT);
    } else {
        UI_OpenMenu(UIMENU_NONE);
    }
 
    CL_CheckForPause();
 
    CL_UpdateFrameTimes();
}

Referenced by CL_Connect_f(), CL_ParseReconnect(), CL_PassiveConnect_f(), CL_PlayDemo_f(), CL_Reconnect_f(), CL_Shutdown(), Com_Error(), finish_demo(), and SV_InitGame().

CL_Disconnect_f()

static void CL_Disconnect_f ( void  )

static

Definition at line 809 of file main.c.

{
    if (cls.state > ca_disconnected) {
        Com_Error(ERR_DISCONNECT, "Disconnected from server");
    }
}

CL_DumpClients_f()

static void CL_DumpClients_f ( void  )

static

Definition at line 2065 of file main.c.

{
    int i;
 
    if (cls.state != ca_active) {
        Com_Printf("Must be in a level to dump.\n");
        return;
    }
 
    for (i = 0; i < MAX_CLIENTS; i++) {
        if (!cl.clientinfo[i].name[0]) {
            continue;
        }
 
        Com_Printf("%3i: %s\n", i, cl.clientinfo[i].name);
    }
}

CL_DumpLayout_f()

static void CL_DumpLayout_f ( void  )

static

Definition at line 2113 of file main.c.

{
    dump_program(cl.layout, "layout");
}

CL_DumpStatusbar_f()

static void CL_DumpStatusbar_f ( void  )

static

Definition at line 2108 of file main.c.

{
    dump_program(cl.configstrings[CS_STATUSBAR], "status bar");
}

CL_DumpStatusResponse()

static void CL_DumpStatusResponse ( const serverStatus_t *  status )

static

Definition at line 917 of file main.c.

{
    int i;
 
    Com_Printf("Status response from %s\n\n", NET_AdrToString(&net_from));
 
    Info_Print(status->infostring);
 
    Com_Printf("\nNum Score Ping Name\n");
    for (i = 0; i < status->numPlayers; i++) {
        Com_Printf("%3i %5i %4i %s\n", i + 1,
                   status->players[i].score,
                   status->players[i].ping,
                   status->players[i].name);
    }
}

Referenced by CL_ParsePrintMessage().

CL_FindRequest()

static request_t* CL_FindRequest ( void  )

static

Definition at line 141 of file main.c.

{
    request_t *r;
    int i, count;
 
    count = MAX_REQUESTS;
    if (count > nextRequest)
        count = nextRequest;
 
    // find the most recent request sent to this address
    for (i = 0; i < count; i++) {
        r = &clientRequests[(nextRequest - i - 1) & REQUEST_MASK];
        if (!r->type) {
            continue;
        }
        if (r->adr.type == NA_BROADCAST) {
            if (cls.realtime - r->time > 3000) {
                continue;
            }
            if (!NET_IsLanAddress(&net_from)) {
                continue;
            }
        } else {
            if (cls.realtime - r->time > 6000) {
                break;
            }
            if (!NET_IsEqualBaseAdr(&net_from, &r->adr)) {
                continue;
            }
        }
 
        return r;
    }
 
    return NULL;
}

Referenced by CL_ParseInfoMessage(), and CL_ParsePrintMessage().

CL_FixUpGender()

static void CL_FixUpGender ( void  )

static

Definition at line 1633 of file main.c.

{
    char *p;
    char sk[MAX_QPATH];
 
    Q_strlcpy(sk, info_skin->string, sizeof(sk));
    if ((p = strchr(sk, '/')) != NULL)
        *p = 0;
    if (Q_stricmp(sk, "male") == 0 || Q_stricmp(sk, "cyborg") == 0)
        Cvar_Set("gender", "male");
    else if (Q_stricmp(sk, "female") == 0 || Q_stricmp(sk, "crackhor") == 0)
        Cvar_Set("gender", "female");
    else
        Cvar_Set("gender", "none");
    info_gender->modified = qfalse;
}

Referenced by CL_UpdateUserinfo().

CL_FollowIP_f()

static void CL_FollowIP_f ( void  )

static

Definition at line 584 of file main.c.

{
    netadr_t *a;
    int i, j;
 
    if (Cmd_Argc() > 1) {
        // optional second argument references less recent address
        j = atoi(Cmd_Argv(1)) + 1;
        clamp(j, 1, RECENT_ADDR);
    } else {
        j = 1;
    }
 
    i = cls.recent_head - j;
    if (i < 0) {
        Com_Printf("No IP address to follow.\n");
        return;
    }
 
    a = &cls.recent_addr[i & RECENT_MASK];
    if (a->type) {
        char *s = NET_AdrToString(a);
        Com_Printf("Following %s...\n", s);
        Cbuf_InsertText(cmd_current, va("connect %s\n", s));
    }
}

cl_footsteps_changed()

static void cl_footsteps_changed ( cvar_t *  self )

static

Definition at line 2611 of file main.c.

{
    CL_UpdateFootstepsSetting();
}

Referenced by CL_InitLocal().

CL_ForwardToServer()

qboolean CL_ForwardToServer

(

void

)

Definition at line 321 of file main.c.

{
    char    *cmd;
 
    cmd = Cmd_Argv(0);
    if (cls.state != ca_active || *cmd == '-' || *cmd == '+') {
        return qfalse;
    }
 
    CL_ClientCommand(Cmd_RawArgsFrom(0));
    return qtrue;
}

Referenced by Cmd_ExecuteCommand().

CL_ForwardToServer_f()

static void CL_ForwardToServer_f ( void  )

static

Definition at line 339 of file main.c.

{
    if (cls.state < ca_connected) {
        Com_Printf("Can't \"%s\", not connected\n", Cmd_Argv(0));
        return;
    }
 
    if (cls.demo.playback) {
        return;
    }
 
    // don't forward the first argument
    if (Cmd_Argc() > 1) {
        CL_ClientCommand(Cmd_RawArgs());
    }
}

CL_Fps_m()

static size_t CL_Fps_m ( char *  buffer, size_t  size  )

static

Definition at line 2275 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", C_FPS);
}

Referenced by CL_InitLocal().

CL_Frame()

unsigned CL_Frame

(

unsigned

msec

)

Definition at line 3204 of file main.c.

{
    qboolean phys_frame, ref_frame;
 
    time_after_ref = time_before_ref = 0;
 
    if (!cl_running->integer) {
        return UINT_MAX;
    }
 
    main_extra += msec;
    cls.realtime += msec;
 
    CL_ProcessEvents();
 
    ref_frame = phys_frame = qtrue;
    switch (sync_mode) {
    case SYNC_FULL:
        // timedemo just runs at full speed
        break;
    case SYNC_SLEEP_10:
        // don't run refresh at all
        ref_frame = qfalse;
        // fall through
    case SYNC_SLEEP_60:
        // run at limited fps if not active
        if (main_extra < main_msec) {
            return main_msec - main_extra;
        }
        break;
    case SYNC_SLEEP_VIDEO:
        // wait for vertical retrace if not active
        VID_VideoWait();
        break;
    case ASYNC_VIDEO:
    case ASYNC_MAXFPS:
    case ASYNC_FULL:
        // run physics and refresh separately
        phys_extra += main_extra;
        if (phys_extra < phys_msec) {
            phys_frame = qfalse;
        } else if (phys_extra > phys_msec * 4) {
            phys_extra = phys_msec;
        }
 
        if (sync_mode == ASYNC_VIDEO) {
            // sync refresh to vertical retrace
            ref_frame = VID_VideoSync();
        } else {
            ref_extra += main_extra;
            if (ref_extra < ref_msec) {
                ref_frame = qfalse;
            } else if (ref_extra > ref_msec * 4) {
                ref_extra = ref_msec;
            }
        }
        break;
    case SYNC_MAXFPS:
        // everything ticks in sync with refresh
        if (main_extra < main_msec) {
            if (!cl.sendPacketNow) {
                return 0;
            }
            ref_frame = qfalse;
        }
        break;
    }
 
    Com_DDDDPrintf("main_extra=%d ref_frame=%d ref_extra=%d "
                   "phys_frame=%d phys_extra=%d\n",
                   main_extra, ref_frame, ref_extra,
                   phys_frame, phys_extra);
 
    // decide the simulation time
    cls.frametime = main_extra * 0.001f;
 
    if (cls.frametime > 1.0 / 5)
        cls.frametime = 1.0 / 5;
 
    if (!sv_paused->integer) {
        cl.time += main_extra;
#if USE_FPS
        cl.keytime += main_extra;
#endif
    }
 
    // read next demo frame
    if (cls.demo.playback)
        CL_DemoFrame(main_extra);
 
    // calculate local time
    if (cls.state == ca_active && !sv_paused->integer)
        CL_SetClientTime();
 
#if USE_AUTOREPLY
    // check for version reply
    CL_CheckForReply();
#endif
 
    // resend a connection request if necessary
    CL_CheckForResend();
 
    // read user intentions
    CL_UpdateCmd(main_extra);
 
    // finalize pending cmd
    phys_frame |= cl.sendPacketNow;
    if (phys_frame) {
        CL_FinalizeCmd();
        phys_extra -= phys_msec;
        M_FRAMES++;
 
        // don't let the time go too far off
        // this can happen due to cl.sendPacketNow
        if (phys_extra < -phys_msec * 4) {
            phys_extra = 0;
        }
    }
 
    // send pending cmds
    CL_SendCmd();
 
    // predict all unacknowledged movements
    CL_PredictMovement();
 
    Con_RunConsole();
 
    UI_Frame(main_extra);
 
    if (ref_frame) {
        // update the screen
        if (host_speeds->integer)
            time_before_ref = Sys_Milliseconds();
 
        SCR_UpdateScreen();
 
        if (host_speeds->integer)
            time_after_ref = Sys_Milliseconds();
 
        ref_extra -= ref_msec;
        R_FRAMES++;
 
run_fx:
        // update audio after the 3D view was drawn
        S_Update();
 
        // advance local effects for next frame
#if USE_DLIGHTS
        CL_RunDLights();
#endif
 
#if USE_LIGHTSTYLES
        CL_RunLightStyles();
#endif
        SCR_RunCinematic();
    } else if (sync_mode == SYNC_SLEEP_10) {
        // force audio and effects update if not rendering
        CL_CalcViewValues();
        goto run_fx;
    }
 
    // check connection timeout
    if (cls.netchan)
        CL_CheckTimeout();
 
    C_FRAMES++;
 
    CL_MeasureStats();
 
    cls.framecount++;
 
    main_extra = 0;
    return 0;
}

Referenced by Qcommon_Frame().

CL_GetFps()

int CL_GetFps

(

)

Definition at line 2374 of file main.c.

{
    return C_FPS;
}

Referenced by SCR_DrawFPS().

CL_GetResolutionScale()

int CL_GetResolutionScale

(

)

Definition at line 2379 of file main.c.

{
    return cl.refdef.feedback.resolution_scale;
}

Referenced by SCR_DrawFPS().

cl_gibs_changed()

static void cl_gibs_changed ( cvar_t *  self )

static

Definition at line 2606 of file main.c.

{
    CL_UpdateGibSetting();
}

Referenced by CL_InitLocal().

CL_HdrColor_m()

static size_t CL_HdrColor_m ( char *  buffer, size_t  size  )

static

Definition at line 2363 of file main.c.

{
    const float* color = cl.refdef.feedback.hdr_color;
    return Q_scnprintf(buffer, size, "(%.5f, %.5f, %.5f)", color[0], color[1], color[2]);
}

Referenced by CL_InitLocal().

CL_Health_m()

static size_t CL_Health_m ( char *  buffer, size_t  size  )

static

Definition at line 2307 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cl.frame.ps.stats[STAT_HEALTH]);
}

Referenced by CL_InitLocal().

CL_IgnoreNick_c()

static void CL_IgnoreNick_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 1950 of file main.c.

{
    if (argnum == 1) {
        CL_Name_g(ctx);
    }
}

CL_IgnoreNick_f()

static void CL_IgnoreNick_f ( void  )

static

Definition at line 1996 of file main.c.

{
    char nick[MAX_CLIENT_NAME * 2];
    char match[MAX_CLIENT_NAME * 3];
 
    if (Cmd_Argc() == 1) {
        list_ignores();
        return;
    }
 
    if (!parse_ignore_nick(1, nick)) {
        return;
    }
 
    Q_snprintf(match, sizeof(match), "%s: *", nick);
    add_ignore(match);
 
    Q_snprintf(match, sizeof(match), "(%s): *", nick);
    add_ignore(match);
}

CL_IgnoreText_f()

static void CL_IgnoreText_f ( void  )

static

Definition at line 1920 of file main.c.

{
    if (Cmd_Argc() == 1) {
        list_ignores();
        return;
    }
 
    add_ignore(Cmd_ArgsFrom(1));
}

CL_Init()

void CL_Init

(

void

)

Definition at line 3414 of file main.c.

{
    if (dedicated->integer) {
        return; // nothing running on the client
    }
 
    if (cl_running->integer) {
        return;
    }
 
    // all archived variables will now be loaded
 
    // start with full screen console
    cls.key_dest = KEY_CONSOLE;
 
#ifdef _WIN32
    CL_InitRefresh();
    S_Init();   // sound must be initialized after window is created
#else
    S_Init();
    CL_InitRefresh();
#endif
 
    CL_InitLocal();
    IN_Init();
 
#if USE_ZLIB
    if (inflateInit2(&cls.z, -MAX_WBITS) != Z_OK) {
        Com_Error(ERR_FATAL, "%s: inflateInit2() failed", __func__);
    }
#endif
 
    CL_LoadDownloadIgnores();
 
    HTTP_Init();
 
    UI_OpenMenu(UIMENU_DEFAULT);
 
    Con_PostInit();
    Con_RunConsole();
 
    cl_cmdbuf.from = FROM_STUFFTEXT;
    cl_cmdbuf.text = cl_cmdbuf_text;
    cl_cmdbuf.maxsize = sizeof(cl_cmdbuf_text);
    cl_cmdbuf.exec = exec_server_string;
 
    Cvar_Set("cl_running", "1");
}

Referenced by Qcommon_Init().

CL_InitLocal()

static void CL_InitLocal ( void  )

static

Definition at line 2708 of file main.c.

{
    cvar_t *var;
    int i;
 
    cls.state = ca_disconnected;
    cls.connect_time -= CONNECT_INSTANT;
 
    CL_RegisterInput();
    CL_InitDemos();
    LOC_Init();
    CL_InitAscii();
    CL_InitEffects();
    CL_InitTEnts();
    CL_InitDownloads();
    CL_GTV_Init();
 
    List_Init(&cl_ignores);
 
    Cmd_Register(c_client);
 
    for (i = 0; i < MAX_LOCAL_SERVERS; i++) {
        var = Cvar_Get(va("adr%i", i), "", CVAR_ARCHIVE);
        var->generator = Com_Address_g;
    }
 
    //
    // register our variables
    //
    cl_gunalpha = Cvar_Get("cl_gunalpha", "1", 0);
    cl_footsteps = Cvar_Get("cl_footsteps", "1", 0);
    cl_footsteps->changed = cl_footsteps_changed;
    cl_noskins = Cvar_Get("cl_noskins", "0", 0);
    cl_noskins->changed = cl_noskins_changed;
    cl_predict = Cvar_Get("cl_predict", "1", 0);
    cl_predict->changed = cl_predict_changed;
    cl_kickangles = Cvar_Get("cl_kickangles", "1", CVAR_CHEAT);
    cl_maxfps = Cvar_Get("cl_maxfps", "60", 0);
    cl_maxfps->changed = cl_sync_changed;
    cl_async = Cvar_Get("cl_async", "1", 0);
    cl_async->changed = cl_sync_changed;
    r_maxfps = Cvar_Get("r_maxfps", "0", 0);
    r_maxfps->changed = cl_sync_changed;
    cl_autopause = Cvar_Get("cl_autopause", "1", 0);
    cl_rollhack = Cvar_Get("cl_rollhack", "1", 0);
    cl_noglow = Cvar_Get("cl_noglow", "0", 0);
    cl_nolerp = Cvar_Get("cl_nolerp", "0", 0);
 
    // hack for timedemo
    com_timedemo->changed = cl_sync_changed;
 
    CL_UpdateFrameTimes();
 
#ifdef _DEBUG
    cl_shownet = Cvar_Get("cl_shownet", "0", 0);
    cl_showmiss = Cvar_Get("cl_showmiss", "0", 0);
    cl_showclamp = Cvar_Get("showclamp", "0", 0);
#endif
 
    cl_timeout = Cvar_Get("cl_timeout", "120", 0);
 
    rcon_address = Cvar_Get("rcon_address", "", CVAR_PRIVATE);
    rcon_address->generator = Com_Address_g;
 
    cl_player_model = Cvar_Get("cl_player_model", va("%d", CL_PLAYER_MODEL_FIRST_PERSON), CVAR_ARCHIVE);
    cl_player_model->changed = cl_player_model_changed;
    cl_thirdperson_angle = Cvar_Get("cl_thirdperson_angle", "0", 0);
    cl_thirdperson_range = Cvar_Get("cl_thirdperson_range", "60", 0);
 
    cl_disable_particles = Cvar_Get("cl_disable_particles", "0", 0);
    cl_disable_explosions = Cvar_Get("cl_disable_explosions", "0", 0);
    cl_explosion_sprites = Cvar_Get("cl_explosion_sprites", "1", 0);
    cl_explosion_frametime = Cvar_Get("cl_explosion_frametime", "20", 0);
    cl_gibs = Cvar_Get("cl_gibs", "1", 0);
    cl_gibs->changed = cl_gibs_changed;
 
#if USE_FPS
    cl_updaterate = Cvar_Get("cl_updaterate", "0", 0);
    cl_updaterate->changed = cl_updaterate_changed;
#endif
 
    cl_chat_notify = Cvar_Get("cl_chat_notify", "1", 0);
    cl_chat_sound = Cvar_Get("cl_chat_sound", "1", 0);
    cl_chat_sound->changed = cl_chat_sound_changed;
    cl_chat_sound_changed(cl_chat_sound);
    cl_chat_filter = Cvar_Get("cl_chat_filter", "0", 0);
 
    cl_disconnectcmd = Cvar_Get("cl_disconnectcmd", "", 0);
    cl_changemapcmd = Cvar_Get("cl_changemapcmd", "", 0);
    cl_beginmapcmd = Cvar_Get("cl_beginmapcmd", "", 0);
 
    cl_protocol = Cvar_Get("cl_protocol", "0", 0);
 
    gender_auto = Cvar_Get("gender_auto", "1", CVAR_ARCHIVE);
 
    cl_vwep = Cvar_Get("cl_vwep", "1", CVAR_ARCHIVE);
    cl_vwep->changed = cl_vwep_changed;
 
    cl_cinematics = Cvar_Get("cl_cinematics", "1", CVAR_ARCHIVE);
 
    allow_download->changed = cl_allow_download_changed;
    cl_allow_download_changed(allow_download);
 
    //
    // userinfo
    //
    info_password = Cvar_Get("password", "", CVAR_USERINFO);
    info_spectator = Cvar_Get("spectator", "0", CVAR_USERINFO);
    info_name = Cvar_Get("name", "Player", CVAR_USERINFO | CVAR_ARCHIVE);
    info_skin = Cvar_Get("skin", "male/grunt", CVAR_USERINFO | CVAR_ARCHIVE);
    info_rate = Cvar_Get("rate", "5000", CVAR_USERINFO | CVAR_ARCHIVE);
    info_msg = Cvar_Get("msg", "1", CVAR_USERINFO | CVAR_ARCHIVE);
    info_hand = Cvar_Get("hand", "0", CVAR_USERINFO | CVAR_ARCHIVE);
    info_hand->changed = info_hand_changed;
    info_fov = Cvar_Get("fov", "75", CVAR_USERINFO | CVAR_ARCHIVE);
    info_gender = Cvar_Get("gender", "male", CVAR_USERINFO | CVAR_ARCHIVE);
    info_gender->modified = qfalse; // clear this so we know when user sets it manually
    info_uf = Cvar_Get("uf", "", CVAR_USERINFO);
 
    // Generate a random user name to avoid new users being kicked out of MP servers.
    // The default quake2 config files set the user name to "Player", same as the cvar initialization above.
    if (Q_strcasecmp(info_name->string, "Player") == 0)
    {
        int random_number = rand() % 10000;
        char buf[MAX_CLIENT_NAME];
        Q_snprintf(buf, sizeof(buf), "Player-%04d", random_number);
        Cvar_Set("name", buf);
    }
 
    //
    // macros
    //
    Cmd_AddMacro("cl_mapname", CL_Mapname_m);
    Cmd_AddMacro("cl_server", CL_Server_m);
    Cmd_AddMacro("cl_timer", CL_Timer_m);
    Cmd_AddMacro("cl_demopos", CL_DemoPos_m);
    Cmd_AddMacro("cl_ups", CL_Ups_m);
    Cmd_AddMacro("cl_fps", CL_Fps_m);
    Cmd_AddMacro("r_fps", R_Fps_m);
    Cmd_AddMacro("cl_mps", CL_Mps_m);   // moves per second
    Cmd_AddMacro("cl_pps", CL_Pps_m);   // packets per second
    Cmd_AddMacro("cl_ping", CL_Ping_m);
    Cmd_AddMacro("cl_lag", CL_Lag_m);
    Cmd_AddMacro("cl_health", CL_Health_m);
    Cmd_AddMacro("cl_ammo", CL_Ammo_m);
    Cmd_AddMacro("cl_armor", CL_Armor_m);
    Cmd_AddMacro("cl_weaponmodel", CL_WeaponModel_m);
    Cmd_AddMacro("cl_cluster", CL_Cluster_m);
    Cmd_AddMacro("cl_clusterthere", CL_ClusterThere_m);
    Cmd_AddMacro("cl_lightpolys", CL_NumLightPolys_m);
    Cmd_AddMacro("cl_material", CL_Material_m);
    Cmd_AddMacro("cl_material_override", CL_Material_Override_m);
    Cmd_AddMacro("cl_viewpos", CL_ViewPos_m);
    Cmd_AddMacro("cl_viewdir", CL_ViewDir_m);
    Cmd_AddMacro("cl_hdr_color", CL_HdrColor_m);
    Cmd_AddMacro("cl_resolution_scale", CL_ResolutionScale_m);
}

Referenced by CL_Init().

CL_Lag_m()

static size_t CL_Lag_m ( char *  buffer, size_t  size  )

static

Definition at line 2300 of file main.c.

{
    return Q_scnprintf(buffer, size, "%.2f%%", cls.netchan ?
                       ((float)cls.netchan->total_dropped /
                        cls.netchan->total_received) * 100.0f : 0);
}

Referenced by CL_InitLocal().

CL_Mapname_m()

static size_t CL_Mapname_m ( char *  buffer, size_t  size  )

static

Definition at line 2211 of file main.c.

{
    return Q_strlcpy(buffer, cl.mapname, size);
}

Referenced by CL_InitLocal().

CL_Material_m()

static size_t CL_Material_m ( char *  buffer, size_t  size  )

static

Definition at line 2343 of file main.c.

{
    return Q_scnprintf(buffer, size, "%s", cl.refdef.feedback.view_material);
}

Referenced by CL_InitLocal().

CL_Material_Override_m()

static size_t CL_Material_Override_m ( char *  buffer, size_t  size  )

static

Definition at line 2348 of file main.c.

{
    return Q_scnprintf(buffer, size, "%s", cl.refdef.feedback.view_material_override);
}

Referenced by CL_InitLocal().

CL_MeasureStats()

static void CL_MeasureStats ( void  )

static

Definition at line 2967 of file main.c.

{
    int i;
 
    if (com_localTime - cls.measure.time < 1000) {
        return;
    }
 
    // measure average ping
    if (cls.netchan) {
        int ack = cls.netchan->incoming_acknowledged;
        int ping = 0;
        int j, k = 0;
 
        i = ack - 16 + 1;
        if (i < cl.initialSeq) {
            i = cl.initialSeq;
        }
        for (j = i; j <= ack; j++) {
            client_history_t *h = &cl.history[j & CMD_MASK];
            if (h->rcvd > h->sent) {
                ping += h->rcvd - h->sent;
                k++;
            }
        }
 
        cls.measure.ping = k ? ping / k : 0;
    }
 
    // measure main/refresh frame counts
    for (i = 0; i < 4; i++) {
        cls.measure.fps[i] = cls.measure.frames[i];
        cls.measure.frames[i] = 0;
    }
 
    cls.measure.time = com_localTime;
}

Referenced by CL_Frame().

CL_Mps_m()

static size_t CL_Mps_m ( char *  buffer, size_t  size  )

static

Definition at line 2285 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", C_MPS);
}

Referenced by CL_InitLocal().

CL_Name_g()

static void CL_Name_g ( genctx_t *  ctx )

static

Definition at line 1285 of file main.c.

{
    int i;
    clientinfo_t *ci;
    char buffer[MAX_CLIENT_NAME];
 
    if (cls.state < ca_loading) {
        return;
    }
 
    for (i = 0; i < MAX_CLIENTS; i++) {
        ci = &cl.clientinfo[i];
        if (!ci->name[0]) {
            continue;
        }
        Q_strlcpy(buffer, ci->name, sizeof(buffer));
        if (COM_strclr(buffer) && !Prompt_AddMatch(ctx, buffer)) {
            break;
        }
    }
}

Referenced by CL_IgnoreNick_c(), and CL_Say_c().

cl_noskins_changed()

static void cl_noskins_changed ( cvar_t *  self )

static

Definition at line 1256 of file main.c.

{
    int i;
    char *s;
    clientinfo_t *ci;
 
    if (cls.state < ca_loading) {
        return;
    }
 
    for (i = 0; i < MAX_CLIENTS; i++) {
        s = cl.configstrings[CS_PLAYERSKINS + i];
        if (!s[0])
            continue;
        ci = &cl.clientinfo[i];
        CL_LoadClientinfo(ci, s);
    }
}

Referenced by CL_InitLocal(), and cl_vwep_changed().

CL_NumLightPolys_m()

static size_t CL_NumLightPolys_m ( char *  buffer, size_t  size  )

static

Definition at line 2338 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cl.refdef.feedback.num_light_polys);
}

Referenced by CL_InitLocal().

CL_PacketEvent()

static void CL_PacketEvent ( void  )

static

Definition at line 1541 of file main.c.

{
    //
    // remote command packet
    //
    if (*(int *)msg_read.data == -1) {
        CL_ConnectionlessPacket();
        return;
    }
 
    if (cls.state < ca_connected) {
        return;
    }
 
    if (!cls.netchan) {
        return;     // dump it if not connected
    }
 
    if (msg_read.cursize < 8) {
        Com_DPrintf("%s: runt packet\n", NET_AdrToString(&net_from));
        return;
    }
 
    //
    // packet from server
    //
    if (!NET_IsEqualAdr(&net_from, &cls.netchan->remote_address)) {
        Com_DPrintf("%s: sequenced packet without connection\n",
                    NET_AdrToString(&net_from));
        return;
    }
 
    if (!cls.netchan->Process(cls.netchan))
        return;     // wasn't accepted for some reason
 
#if USE_ICMP
    cls.errorReceived = qfalse; // don't drop
#endif
 
    CL_ParseServerMessage();
 
    // if recording demo, write the message out
    if (cls.demo.recording && !cls.demo.paused && CL_FRAMESYNC) {
        CL_WriteDemoMessage(&cls.demo.buffer);
    }
 
    // if running GTV server, transmit to client
    CL_GTV_Transmit();
 
    if (!cls.netchan)
        return;     // might have disconnected
 
#ifdef _DEBUG
    CL_AddNetgraph();
#endif
 
    SCR_LagSample();
}

Referenced by CL_ProcessEvents().

CL_ParseInfoMessage()

static void CL_ParseInfoMessage ( void  )

static

Definition at line 993 of file main.c.

{
    char string[MAX_QPATH];
    request_t *r;
 
    r = CL_FindRequest();
    if (!r)
        return;
    if (r->type != REQ_INFO)
        return;
 
    MSG_ReadString(string, sizeof(string));
    Com_Printf("%s", string);
    if (r->adr.type != NA_BROADCAST)
        r->type = REQ_FREE;
}

Referenced by CL_ConnectionlessPacket().

CL_ParsePrintMessage()

static void CL_ParsePrintMessage ( void  )

static

Definition at line 939 of file main.c.

{
    char string[MAX_NET_STRING];
    serverStatus_t status;
    request_t *r;
 
    MSG_ReadString(string, sizeof(string));
 
    r = CL_FindRequest();
    if (r) {
        switch (r->type) {
        case REQ_STATUS_CL:
            CL_ParseStatusResponse(&status, string);
            CL_DumpStatusResponse(&status);
            break;
#if USE_UI
        case REQ_STATUS_UI:
            CL_ParseStatusResponse(&status, string);
            UI_StatusEvent(&status);
            break;
#endif
        case REQ_RCON:
            Com_Printf("%s", string);
            return; // rcon may come in multiple packets
 
        default:
            return;
        }
 
        if (r->adr.type != NA_BROADCAST)
            r->type = REQ_FREE;
        return;
    }
 
    // finally, check is this is response from the server we are connecting to
    // and if so, start channenge cycle again
    if ((cls.state == ca_challenging || cls.state == ca_connecting) &&
        NET_IsEqualBaseAdr(&net_from, &cls.serverAddress)) {
        Com_Printf("%s", string);
        cls.state = ca_challenging;
        //cls.connect_count = 0;
        return;
    }
 
    Com_DPrintf("%s: dropped unrequested packet\n", __func__);
}

Referenced by CL_ConnectionlessPacket().

CL_ParseStatusResponse()

static void CL_ParseStatusResponse ( serverStatus_t *  status, const char *  string  )

static

Definition at line 877 of file main.c.

{
    playerStatus_t *player;
    const char *s;
    size_t infolen;
 
    // parse '\n' terminated infostring
    s = Q_strchrnul(string, '\n');
 
    // due to off-by-one error in the original version of Info_SetValueForKey,
    // some servers produce infostrings up to 512 characters long. work this
    // bug around by cutting off the last character(s).
    infolen = s - string;
    if (infolen >= MAX_INFO_STRING)
        infolen = MAX_INFO_STRING - 1;
 
    // copy infostring off
    memcpy(status->infostring, string, infolen);
    status->infostring[infolen] = 0;
 
    if (!Info_Validate(status->infostring))
        strcpy(status->infostring, "\\hostname\\badinfo");
 
    // parse optional player list
    status->numPlayers = 0;
    while (status->numPlayers < MAX_STATUS_PLAYERS) {
        player = &status->players[status->numPlayers];
        player->score = atoi(COM_Parse(&s));
        player->ping = atoi(COM_Parse(&s));
        Q_strlcpy(player->name, COM_Parse(&s), sizeof(player->name));
        if (!s)
            break;
        status->numPlayers++;
    }
 
    // sort players by frags
    qsort(status->players, status->numPlayers,
          sizeof(status->players[0]), SortPlayers);
}

Referenced by CL_ParsePrintMessage().

CL_PassiveConnect_f()

static void CL_PassiveConnect_f ( void  )

static

Definition at line 611 of file main.c.

{
    netadr_t address;
 
    if (cls.passive) {
        cls.passive = qfalse;
        Com_Printf("No longer listening for passive connections.\n");
        return;
    }
 
    // if running a local server, kill it and reissue
    SV_Shutdown("Server was killed.\n", ERR_DISCONNECT);
 
    NET_Config(NET_CLIENT);
 
    CL_Disconnect(ERR_RECONNECT);
 
    if (!NET_GetAddress(NS_CLIENT, &address)) {
        return;
    }
 
    cls.passive = qtrue;
    Com_Printf("Listening for passive connections at %s.\n",
               NET_AdrToString(&address));
}

CL_Pause_f()

static void CL_Pause_f ( void  )

static

Definition at line 361 of file main.c.

{
#if USE_MVD_CLIENT
    if (sv_running->integer == ss_broadcast) {
        Cbuf_InsertText(&cmd_buffer, "mvdpause @@\n");
        return;
    }
#endif
 
    // activate manual pause
    if (cl_paused->integer == 2) {
        Cvar_Set("cl_paused", "0");
    } else {
        Cvar_Set("cl_paused", "2");
    }
 
    CL_CheckForPause();
}

CL_Ping_m()

static size_t CL_Ping_m ( char *  buffer, size_t  size  )

static

Definition at line 2295 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", cls.measure.ping);
}

Referenced by CL_InitLocal().

CL_PingServers_f()

static void CL_PingServers_f ( void  )

static

Definition at line 1183 of file main.c.

{
    netadr_t address;
    cvar_t *var;
    int i;
 
    NET_Config(NET_CLIENT);
 
    // send a broadcast packet
    memset(&address, 0, sizeof(address));
    address.type = NA_BROADCAST;
    address.port = BigShort(PORT_SERVER);
 
    Com_DPrintf("Pinging broadcast...\n");
    CL_AddRequest(&address, REQ_INFO);
 
    OOB_PRINT(NS_CLIENT, &address, "info 34");
 
    // send a packet to each address book entry
    for (i = 0; i < 64; i++) {
        var = Cvar_FindVar(va("adr%i", i));
        if (!var)
            break;
 
        if (!var->string[0])
            continue;
 
        if (!NET_StringToAdr(var->string, &address, PORT_SERVER)) {
            Com_Printf("Bad address: %s\n", var->string);
            continue;
        }
 
        Com_DPrintf("Pinging %s...\n", var->string);
        CL_AddRequest(&address, REQ_INFO);
 
        OOB_PRINT(NS_CLIENT, &address, "info 34");
    }
}

cl_player_model_changed()

static void cl_player_model_changed ( cvar_t *  self )

static

Definition at line 2596 of file main.c.

{
    CL_UpdateGunSetting();
}

Referenced by CL_InitLocal().

CL_PlaySound_c()

static void CL_PlaySound_c ( genctx_t *  ctx, int  state  )

static

Definition at line 1726 of file main.c.

{
    FS_File_g("sound", "*.wav", FS_SEARCH_SAVEPATH | FS_SEARCH_BYFILTER | FS_SEARCH_STRIPEXT, ctx);
}

CL_PlaySound_f()

static void CL_PlaySound_f ( void  )

static

Definition at line 1731 of file main.c.

{
    int     i;
    char name[MAX_QPATH];
 
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <sound> [...]\n", Cmd_Argv(0));
        return;
    }
 
    for (i = 1; i < Cmd_Argc(); i++) {
        Cmd_ArgvBuffer(i, name, sizeof(name));
        COM_DefaultExtension(name, ".wav", sizeof(name));
        S_StartLocalSound(name);
    }
}

CL_Pps_m()

static size_t CL_Pps_m ( char *  buffer, size_t  size  )

static

Definition at line 2290 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", C_PPS);
}

Referenced by CL_InitLocal().

CL_Precache_f()

static void CL_Precache_f ( void  )

static

Definition at line 1799 of file main.c.

{
    if (cls.state < ca_connected) {
        return;
    }
 
    cls.state = ca_loading;
    CL_LoadState(LOAD_MAP);
 
    S_StopAllSounds();
 
    CL_RegisterVWepModels();
 
    // demos use different precache sequence
    if (cls.demo.playback) {
        CL_RegisterBspModels();
        CL_PrepRefresh();
        CL_LoadState(LOAD_SOUNDS);
        CL_RegisterSounds();
        CL_LoadState(LOAD_NONE);
        cls.state = ca_precached;
        return;
    }
 
    precache_spawncount = atoi(Cmd_Argv(1));
 
    CL_ResetPrecacheCheck();
    CL_RequestNextDownload();
 
    if (cls.state != ca_precached) {
        cls.state = ca_connected;
    }
}

Referenced by exec_server_string().

cl_predict_changed()

static void cl_predict_changed ( cvar_t *  self )

static

Definition at line 2616 of file main.c.

{
    CL_UpdatePredictSetting();
}

Referenced by CL_InitLocal().

CL_ProcessEvents()

qboolean CL_ProcessEvents

(

void

)

Definition at line 3384 of file main.c.

{
    if (!cl_running->integer) {
        return qfalse;
    }
 
    CL_RunRefresh();
 
    IN_Frame();
 
    NET_GetPackets(NS_CLIENT, CL_PacketEvent);
 
    // process console and stuffed commands
    Cbuf_Execute(&cmd_buffer);
    Cbuf_Execute(&cl_cmdbuf);
 
    HTTP_RunDownloads();
 
    CL_GTV_Run();
 
    return cl.sendPacketNow;
}

Referenced by CL_Frame(), and Qcommon_Frame().

CL_Rcon_c()

static void CL_Rcon_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 688 of file main.c.

{
    Com_Generic_c(ctx, argnum - 1);
}

CL_Rcon_f()

static void CL_Rcon_f ( void  )

static

Definition at line 655 of file main.c.

{
    netadr_t    address;
 
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <command>\n", Cmd_Argv(0));
        return;
    }
 
    if (!rcon_password->string[0]) {
        Com_Printf("You must set 'rcon_password' before "
                   "issuing an rcon command.\n");
        return;
    }
 
    if (!cls.netchan) {
        if (!rcon_address->string[0]) {
            Com_Printf("You must either be connected, "
                       "or set the 'rcon_address' cvar "
                       "to issue rcon commands.\n");
            return;
        }
        if (!NET_StringToAdr(rcon_address->string, &address, PORT_SERVER)) {
            Com_Printf("Bad address: %s\n", rcon_address->string);
            return;
        }
    } else {
        address = cls.netchan->remote_address;
    }
 
    CL_SendRcon(&address, rcon_password->string, Cmd_RawArgs());
}

CL_RecentIP_g()

static void CL_RecentIP_g ( genctx_t *  ctx )

static

Definition at line 475 of file main.c.

{
    netadr_t *a;
    int i, j;
 
    j = cls.recent_head - RECENT_ADDR;
    if (j < 0) {
        j = 0;
    }
    for (i = cls.recent_head - 1; i >= j; i--) {
        a = &cls.recent_addr[i & RECENT_MASK];
        if (a->type) {
            Prompt_AddMatch(ctx, NET_AdrToString(a));
        }
    }
}

Referenced by CL_Connect_c(), and CL_ServerStatus_c().

CL_Reconnect_f()

static void CL_Reconnect_f ( void  )

static

Definition at line 1121 of file main.c.

{
    if (cls.state >= ca_precached) {
        CL_Disconnect(ERR_RECONNECT);
    }
 
    if (cls.state >= ca_connected) {
        cls.state = ca_connected;
 
        if (cls.demo.playback) {
            return;
        }
        if (cls.download.file) {
            return; // if we are downloading, we don't change!
        }
 
        Com_Printf("Reconnecting...\n");
 
        CL_ClientCommand("new");
        return;
    }
 
    // issued manually at console
    if (cls.serverAddress.type == NA_UNSPECIFIED) {
        Com_Printf("No server to reconnect to.\n");
        return;
    }
    if (cls.serverAddress.type == NA_LOOPBACK) {
        Com_Printf("Can not reconnect to loopback.\n");
        return;
    }
 
    Com_Printf("Reconnecting...\n");
 
    cls.state = ca_challenging;
    cls.connect_time -= CONNECT_FAST;
    cls.connect_count = 0;
 
    SCR_UpdateScreen();
}

CL_ReloadRefresh_f()

static void CL_ReloadRefresh_f ( void  )

static

Definition at line 2542 of file main.c.

{
    CL_RestartRefresh(qfalse);
}

CL_ResolutionScale_m()

static size_t CL_ResolutionScale_m ( char *  buffer, size_t  size  )

static

Definition at line 2369 of file main.c.

{
    return Q_scnprintf(buffer, size, "%d", cl.refdef.feedback.resolution_scale);
}

Referenced by CL_InitLocal().

CL_RestartFilesystem()

void CL_RestartFilesystem

(

qboolean

total

)

Definition at line 2418 of file main.c.

{
    int cls_state;
 
    if (!cl_running->integer) {
        FS_Restart(total);
        return;
    }
 
    Com_DPrintf("%s(%d)\n", __func__, total);
 
    // temporary switch to loading state
    cls_state = cls.state;
    if (cls.state >= ca_precached) {
        cls.state = ca_loading;
    }
 
    Con_Popup(qfalse);
 
    UI_Shutdown();
 
    S_StopAllSounds();
    S_FreeAllSounds();
 
    // write current config before changing game directory
    CL_WriteConfig();
 
    if (cls.ref_initialized) {
        R_Shutdown(qfalse);
 
        FS_Restart(total);
 
        R_Init(qfalse);
 
        SCR_RegisterMedia();
        Con_RegisterMedia();
        UI_Init();
    } else {
        FS_Restart(total);
    }
 
    if (cls_state == ca_disconnected) {
        UI_OpenMenu(UIMENU_DEFAULT);
    } else if (cls_state >= ca_loading && cls_state <= ca_active) {
        CL_LoadState(LOAD_MAP);
        CL_PrepRefresh();
        CL_LoadState(LOAD_SOUNDS);
        CL_RegisterSounds();
        CL_LoadState(LOAD_NONE);
    } else if (cls_state == ca_cinematic) {
        cl.image_precache[0] = R_RegisterPic2(cl.mapname);
    }
 
    CL_LoadDownloadIgnores();
 
    // switch back to original state
    cls.state = cls_state;
 
    Con_Close(qfalse);
 
    CL_UpdateFrameTimes();
 
    cvar_modified &= ~CVAR_FILES;
}

Referenced by finish_download(), fs_game_changed(), and FS_Restart_f().

CL_RestartRefresh()

void CL_RestartRefresh

(

qboolean

total

)

Definition at line 2483 of file main.c.

{
    int cls_state;
 
    if (!cls.ref_initialized) {
        return;
    }
 
    // temporary switch to loading state
    cls_state = cls.state;
    if (cls.state >= ca_precached) {
        cls.state = ca_loading;
    }
 
    Con_Popup(qfalse);
 
    S_StopAllSounds();
 
    if (total) {
        IN_Shutdown();
        CL_ShutdownRefresh();
        CL_InitRefresh();
        IN_Init();
    } else {
        UI_Shutdown();
        R_Shutdown(qfalse);
        R_Init(qfalse);
        SCR_RegisterMedia();
        Con_RegisterMedia();
        UI_Init();
    }
 
    if (cls_state == ca_disconnected) {
        UI_OpenMenu(UIMENU_DEFAULT);
    } else if (cls_state >= ca_loading && cls_state <= ca_active) {
        CL_LoadState(LOAD_MAP);
        CL_PrepRefresh();
        CL_LoadState(LOAD_NONE);
    } else if (cls_state == ca_cinematic) {
        cl.image_precache[0] = R_RegisterPic2(cl.mapname);
    }
 
    // switch back to original state
    cls.state = cls_state;
 
    Con_Close(qfalse);
 
    CL_UpdateFrameTimes();
 
    cvar_modified &= ~CVAR_FILES;
}

Referenced by CL_ReloadRefresh_f(), CL_RestartRefresh_f(), and CL_RunRefresh().

CL_RestartRefresh_f()

static void CL_RestartRefresh_f ( void  )

static

Definition at line 2554 of file main.c.

{
    CL_RestartRefresh(qtrue);
}

CL_RestartSound_f()

static void CL_RestartSound_f ( void  )

static

Definition at line 1712 of file main.c.

{
    S_Shutdown();
    S_Init();
    CL_RegisterSounds();
}

CL_Say_c()

static void CL_Say_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 2206 of file main.c.

{
    CL_Name_g(ctx);
}

CL_SendRcon()

void CL_SendRcon	(	const netadr_t *	adr,
		const char *	pass,
		const char *	cmd
	)

Definition at line 637 of file main.c.

{
    NET_Config(NET_CLIENT);
 
    CL_AddRequest(adr, REQ_RCON);
 
    Netchan_OutOfBand(NS_CLIENT, adr, "rcon \"%s\" %s", pass, cmd);
}

Referenced by CL_Rcon_f(), and Con_Action().

CL_Server_m()

static size_t CL_Server_m ( char *  buffer, size_t  size  )

static

Definition at line 2216 of file main.c.

{
    return Q_strlcpy(buffer, cls.servername, size);
}

Referenced by CL_InitLocal().

CL_ServerStatus_c()

static void CL_ServerStatus_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 816 of file main.c.

{
    if (argnum == 1) {
        CL_RecentIP_g(ctx);
        Com_Address_g(ctx);
    }
}

CL_ServerStatus_f()

static void CL_ServerStatus_f ( void  )

static

Definition at line 829 of file main.c.

{
    char        *s;
    netadr_t    adr;
    neterr_t    ret;
 
    if (Cmd_Argc() < 2) {
        if (!cls.netchan) {
            Com_Printf("Usage: %s [address]\n", Cmd_Argv(0));
            return;
        }
        adr = cls.netchan->remote_address;
    } else {
        s = Cmd_Argv(1);
        if (!NET_StringToAdr(s, &adr, PORT_SERVER)) {
            Com_Printf("Bad address: %s\n", s);
            return;
        }
    }
 
    CL_AddRequest(&adr, REQ_STATUS_CL);
 
    NET_Config(NET_CLIENT);
 
    ret = OOB_PRINT(NS_CLIENT, &adr, "status");
    if (ret == NET_ERROR) {
        Com_Printf("%s to %s\n", NET_ErrorString(), NET_AdrToString(&adr));
    }
}

CL_SetClientTime()

static void CL_SetClientTime ( void  )

static

Definition at line 2918 of file main.c.

{
    int prevtime;
 
    if (com_timedemo->integer) {
        cl.time = cl.servertime;
        cl.lerpfrac = 1.0f;
#if USE_FPS
        cl.keytime = cl.keyservertime;
        cl.keylerpfrac = 1.0f;
#endif
        return;
    }
 
    prevtime = cl.servertime - CL_FRAMETIME;
    if (cl.time > cl.servertime) {
        SHOWCLAMP(1, "high clamp %i\n", cl.time - cl.servertime);
        cl.time = cl.servertime;
        cl.lerpfrac = 1.0f;
    } else if (cl.time < prevtime) {
        SHOWCLAMP(1, "low clamp %i\n", prevtime - cl.time);
        cl.time = prevtime;
        cl.lerpfrac = 0;
    } else {
        cl.lerpfrac = (cl.time - prevtime) * CL_1_FRAMETIME;
    }
 
    SHOWCLAMP(2, "time %d %d, lerpfrac %.3f\n",
              cl.time, cl.servertime, cl.lerpfrac);
 
#if USE_FPS
    prevtime = cl.keyservertime - BASE_FRAMETIME;
    if (cl.keytime > cl.keyservertime) {
        SHOWCLAMP(1, "high keyclamp %i\n", cl.keytime - cl.keyservertime);
        cl.keytime = cl.keyservertime;
        cl.keylerpfrac = 1.0f;
    } else if (cl.keytime < prevtime) {
        SHOWCLAMP(1, "low keyclamp %i\n", prevtime - cl.keytime);
        cl.keytime = prevtime;
        cl.keylerpfrac = 0;
    } else {
        cl.keylerpfrac = (cl.keytime - prevtime) * BASE_1_FRAMETIME;
    }
 
    SHOWCLAMP(2, "keytime %d %d keylerpfrac %.3f\n",
              cl.keytime, cl.keyservertime, cl.keylerpfrac);
#endif
}

Referenced by CL_Frame().

CL_Shutdown()

void CL_Shutdown

(

void

)

Definition at line 3471 of file main.c.

{
    static qboolean isdown = qfalse;
 
    if (isdown) {
        Com_Printf("CL_Shutdown: recursive shutdown\n");
        return;
    }
    isdown = qtrue;
 
    if (!cl_running || !cl_running->integer) {
        return;
    }
 
    CL_GTV_Shutdown();
 
    CL_Disconnect(ERR_FATAL);
 
#if USE_ZLIB
    inflateEnd(&cls.z);
#endif
 
    HTTP_Shutdown();
    S_Shutdown();
    IN_Shutdown();
    Con_Shutdown();
    CL_ShutdownRefresh();
    CL_WriteConfig();
 
    memset(&cls, 0, sizeof(cls));
 
    Cvar_Set("cl_running", "0");
 
    isdown = qfalse;
}

Referenced by Com_Error(), and Com_Quit().

CL_Skins_f()

static void CL_Skins_f ( void  )

static

Definition at line 1229 of file main.c.

{
    int i;
    char *s;
    clientinfo_t *ci;
 
    if (cls.state < ca_loading) {
        Com_Printf("Must be in a level to load skins.\n");
        return;
    }
 
    CL_RegisterVWepModels();
 
    for (i = 0; i < MAX_CLIENTS; i++) {
        s = cl.configstrings[CS_PLAYERSKINS + i];
        if (!s[0])
            continue;
        ci = &cl.clientinfo[i];
        CL_LoadClientinfo(ci, s);
        if (!ci->model_name[0] || !ci->skin_name[0])
            ci = &cl.baseclientinfo;
        Com_Printf("client %d: %s --> %s/%s\n", i, s,
                   ci->model_name, ci->skin_name);
        SCR_UpdateScreen();
    }
}

cl_sync_changed()

static void cl_sync_changed ( cvar_t *  self )

static

Definition at line 2628 of file main.c.

{
    CL_UpdateFrameTimes();
}

Referenced by CL_InitLocal().

CL_Timer_m()

static size_t CL_Timer_m ( char *  buffer, size_t  size  )

static

Definition at line 2242 of file main.c.

{
    int hour, min, sec;
 
    sec = cl.time / 1000;
    min = sec / 60; sec %= 60;
    hour = min / 60; min %= 60;
 
    if (hour) {
        return Q_scnprintf(buffer, size, "%i:%i:%02i", hour, min, sec);
    }
    return Q_scnprintf(buffer, size, "%i:%02i", min, sec);
}

Referenced by CL_InitLocal().

CL_UnIgnoreNick_f()

static void CL_UnIgnoreNick_f ( void  )

static

Definition at line 2017 of file main.c.

{
    char nick[MAX_CLIENT_NAME * 2];
    char match[MAX_CLIENT_NAME * 3];
 
    if (Cmd_Argc() == 1) {
        list_ignores();
        return;
    }
 
    if (!parse_ignore_nick(1, nick)) {
        return;
    }
 
    Q_snprintf(match, sizeof(match), "%s: *", nick);
    remove_ignore(match);
 
    Q_snprintf(match, sizeof(match), "(%s): *", nick);
    remove_ignore(match);
}

CL_UnIgnoreText_f()

static void CL_UnIgnoreText_f ( void  )

static

Definition at line 1930 of file main.c.

{
    if (Cmd_Argc() == 1) {
        list_ignores();
        return;
    }
 
    if (LIST_EMPTY(&cl_ignores)) {
        Com_Printf("No ignore filters.\n");
        return;
    }
 
    if (!strcmp(Cmd_Argv(1), "all")) {
        remove_all_ignores();
        return;
    }
 
    remove_ignore(Cmd_ArgsFrom(1));
}

CL_UpdateFootstepsSetting()

static void CL_UpdateFootstepsSetting ( void  )

static

Definition at line 218 of file main.c.

{
    if (!cls.netchan) {
        return;
    }
    if (cls.serverProtocol != PROTOCOL_VERSION_Q2PRO) {
        return;
    }
 
    MSG_WriteByte(clc_setting);
    MSG_WriteShort(CLS_NOFOOTSTEPS);
    MSG_WriteShort(!cl_footsteps->integer);
    MSG_FlushTo(&cls.netchan->message);
}

Referenced by CL_Begin(), and cl_footsteps_changed().

CL_UpdateFrameTimes()

void CL_UpdateFrameTimes

(

void

)

Definition at line 3136 of file main.c.

{
    if (!cls.state) {
        return; // not yet fully initialized
    }
 
    // check if video driver supports syncing to vertical retrace
    if (cl_async->integer > 1 && !(r_config.flags & QVF_VIDEOSYNC)) {
        Cvar_Reset(cl_async);
    }
 
    if (com_timedemo->integer) {
        // timedemo just runs at full speed
        ref_msec = phys_msec = main_msec = 0;
        sync_mode = SYNC_FULL;
    } else if (cls.active == ACT_MINIMIZED) {
        // run at 10 fps if minimized
        ref_msec = phys_msec = 0;
        main_msec = fps_to_msec(10);
        sync_mode = SYNC_SLEEP_10;
    } else if (cls.active == ACT_RESTORED || cls.state != ca_active) {
        // run at 60 fps if not active
        ref_msec = phys_msec = 0;
        if (cl_async->integer > 1) {
            main_msec = 0;
            sync_mode = SYNC_SLEEP_VIDEO;
        } else {
            main_msec = fps_to_msec(60);
            sync_mode = SYNC_SLEEP_60;
        }
    } else if (cl_async->integer > 0) {
        // run physics and refresh separately
        phys_msec = fps_to_msec(Cvar_ClampInteger(cl_maxfps, 10, 120));
        if (cl_async->integer > 1) {
            ref_msec = 0;
            sync_mode = ASYNC_VIDEO;
        } else if (r_maxfps->integer) {
            ref_msec = fps_to_msec(Cvar_ClampInteger(r_maxfps, 10, 1000));
            sync_mode = ASYNC_MAXFPS;
        } else {
            ref_msec = 1;
            sync_mode = ASYNC_FULL;
        }
        main_msec = 0;
    } else {
        // everything ticks in sync with refresh
        phys_msec = ref_msec = 0;
        if (cl_maxfps->integer) {
            main_msec = fps_to_msec(Cvar_ClampInteger(cl_maxfps, 10, 1000));
            sync_mode = SYNC_MAXFPS;
        } else {
            main_msec = 1;
            sync_mode = SYNC_FULL;
        }
    }
 
    Com_DDDPrintf("%s: mode=%s main_msec=%d ref_msec=%d, phys_msec=%d\n",
                  __func__, sync_names[sync_mode], main_msec, ref_msec, phys_msec);
 
    ref_extra = phys_extra = main_extra = 0;
}

Referenced by CL_Activate(), CL_Changing_f(), CL_ClearState(), CL_Disconnect(), CL_InitLocal(), CL_RestartFilesystem(), CL_RestartRefresh(), cl_sync_changed(), SCR_ModeChanged(), and set_active_state().

CL_UpdateGibSetting()

static void CL_UpdateGibSetting ( void  )

static

Definition at line 203 of file main.c.

{
    if (!cls.netchan) {
        return;
    }
    if (cls.serverProtocol != PROTOCOL_VERSION_Q2PRO) {
        return;
    }
 
    MSG_WriteByte(clc_setting);
    MSG_WriteShort(CLS_NOGIBS);
    MSG_WriteShort(!cl_gibs->integer);
    MSG_FlushTo(&cls.netchan->message);
}

Referenced by CL_Begin(), and cl_gibs_changed().

CL_UpdateGunSetting()

static void CL_UpdateGunSetting ( void  )

static

Definition at line 180 of file main.c.

{
    int nogun;
 
    if (!cls.netchan) {
        return;
    }
    if (cls.serverProtocol < PROTOCOL_VERSION_R1Q2) {
        return;
    }
 
    if (cl_player_model->integer == CL_PLAYER_MODEL_DISABLED || info_hand->integer == 2) {
        nogun = 1;
    } else {
        nogun = 0;
    }
 
    MSG_WriteByte(clc_setting);
    MSG_WriteShort(CLS_NOGUN);
    MSG_WriteShort(nogun);
    MSG_FlushTo(&cls.netchan->message);
}

Referenced by CL_Begin(), cl_player_model_changed(), and info_hand_changed().

CL_UpdatePredictSetting()

static void CL_UpdatePredictSetting ( void  )

static

Definition at line 233 of file main.c.

{
    if (!cls.netchan) {
        return;
    }
    if (cls.serverProtocol != PROTOCOL_VERSION_Q2PRO) {
        return;
    }
 
    MSG_WriteByte(clc_setting);
    MSG_WriteShort(CLS_NOPREDICT);
    MSG_WriteShort(!cl_predict->integer);
    MSG_FlushTo(&cls.netchan->message);
}

Referenced by CL_Begin(), and cl_predict_changed().

CL_UpdateRecordingSetting()

void CL_UpdateRecordingSetting

(

void

)

Definition at line 265 of file main.c.

{
    int rec;
 
    if (!cls.netchan) {
        return;
    }
    if (cls.serverProtocol < PROTOCOL_VERSION_R1Q2) {
        return;
    }
 
    if (cls.demo.recording) {
        rec = 1;
    } else {
        rec = 0;
    }
 
#if USE_CLIENT_GTV
    if (cls.gtv.state == ca_active) {
        rec |= 1;
    }
#endif
 
    MSG_WriteByte(clc_setting);
    MSG_WriteShort(CLS_RECORDING);
    MSG_WriteShort(rec);
    MSG_FlushTo(&cls.netchan->message);
}

Referenced by CL_Begin(), CL_Record_f(), CL_Stop_f(), parse_stream_start(), and parse_stream_stop().

CL_UpdateUserinfo()

void CL_UpdateUserinfo	(	cvar_t *	var,
		from_t	from
	)

Definition at line 1650 of file main.c.

{
    int i;
 
    if (var == info_skin && from > FROM_CONSOLE && gender_auto->integer) {
        CL_FixUpGender();
    }
 
    if (!cls.netchan) {
        return;
    }
 
    if (cls.serverProtocol != PROTOCOL_VERSION_Q2PRO) {
        // transmit at next oportunity
        cls.userinfo_modified = MAX_PACKET_USERINFOS;
        goto done;
    }
 
    if (cls.userinfo_modified == MAX_PACKET_USERINFOS) {
        // can't hold any more
        goto done;
    }
 
    // check for the same variable being modified twice
    for (i = 0; i < cls.userinfo_modified; i++) {
        if (cls.userinfo_updates[i] == var) {
            Com_DDPrintf("%s: %u: %s [DUP]\n",
                         __func__, com_framenum, var->name);
            return;
        }
    }
 
    cls.userinfo_updates[cls.userinfo_modified++] = var;
 
done:
    Com_DDPrintf("%s: %u: %s [%d]\n",
                 __func__, com_framenum, var->name, cls.userinfo_modified);
}

Referenced by change_string_value(), and Cvar_FullSet().

CL_Ups_m()

static size_t CL_Ups_m ( char *  buffer, size_t  size  )

static

Definition at line 2221 of file main.c.

{
    vec3_t vel;
 
    if (cl.frame.clientNum == CLIENTNUM_NONE) {
        if (size) {
            *buffer = 0;
        }
        return 0;
    }
 
    if (!cls.demo.playback && cl.frame.clientNum == cl.clientNum &&
        cl_predict->integer) {
        VectorCopy(cl.predicted_velocity, vel);
    } else {
        VectorScale(cl.frame.ps.pmove.velocity, 0.125f, vel);
    }
 
    return Q_scnprintf(buffer, size, "%d", (int)VectorLength(vel));
}

Referenced by CL_InitLocal().

CL_Userinfo_f()

static void CL_Userinfo_f ( void  )

static

Definition at line 1694 of file main.c.

{
    char userinfo[MAX_INFO_STRING];
 
    Cvar_BitInfo(userinfo, CVAR_USERINFO);
 
    Com_Printf("User info settings:\n");
    Info_Print(userinfo);
}

CL_ViewDir_m()

static size_t CL_ViewDir_m ( char *  buffer, size_t  size  )

static

Definition at line 2358 of file main.c.

{
    return Q_scnprintf(buffer, size, "(%.3f, %.3f, %.3f)", cl.v_forward[0], cl.v_forward[1], cl.v_forward[2]);
}

Referenced by CL_InitLocal().

CL_ViewPos_m()

static size_t CL_ViewPos_m ( char *  buffer, size_t  size  )

static

Definition at line 2353 of file main.c.

{
    return Q_scnprintf(buffer, size, "(%.1f, %.1f, %.1f)", cl.refdef.vieworg[0], cl.refdef.vieworg[1], cl.refdef.vieworg[2]);
}

Referenced by CL_InitLocal().

cl_vwep_changed()

static void cl_vwep_changed ( cvar_t *  self )

static

Definition at line 1275 of file main.c.

{
    if (cls.state < ca_loading) {
        return;
    }
 
    CL_RegisterVWepModels();
    cl_noskins_changed(self);
}

Referenced by CL_InitLocal().

CL_WeaponModel_m()

static size_t CL_WeaponModel_m ( char *  buffer, size_t  size  )

static

Definition at line 2322 of file main.c.

{
    return Q_scnprintf(buffer, size, "%s",
                       cl.configstrings[cl.frame.ps.gunindex + CS_MODELS]);
}

Referenced by CL_InitLocal().

CL_WriteConfig()

void CL_WriteConfig

(

void

)

Definition at line 2391 of file main.c.

{
    qhandle_t f;
    qerror_t ret;
 
    ret = FS_FOpenFile(COM_CONFIG_CFG, &f, FS_MODE_WRITE | FS_FLAG_TEXT);
    if (!f) {
        Com_EPrintf("Couldn't open %s for writing: %s\n",
                    COM_CONFIG_CFG, Q_ErrorString(ret));
        return;
    }
 
    FS_FPrintf(f, "// generated by " APPLICATION ", do not modify\n");
 
    Key_WriteBindings(f);
    Cvar_WriteVariables(f, CVAR_ARCHIVE, qfalse);
 
    FS_FCloseFile(f);
}

Referenced by CL_RestartFilesystem(), CL_Shutdown(), and UI_PopMenu().

CL_WriteConfig_c()

static void CL_WriteConfig_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 2127 of file main.c.

{
    Cmd_Option_c(o_writeconfig, Cmd_Config_g, ctx, argnum);
}

CL_WriteConfig_f()

static void CL_WriteConfig_f ( void  )

static

Definition at line 2137 of file main.c.

{
    char buffer[MAX_OSPATH];
    qboolean aliases = qfalse, bindings = qfalse, modified = qfalse;
    int c, mask = 0;
    qhandle_t f;
 
    while ((c = Cmd_ParseOptions(o_writeconfig)) != -1) {
        switch (c) {
        case 'a':
            aliases = qtrue;
            break;
        case 'b':
            bindings = qtrue;
            break;
        case 'c':
            mask |= CVAR_ARCHIVE;
            break;
        case 'h':
            Cmd_PrintUsage(o_writeconfig, "<filename>");
            Com_Printf("Save current configuration into file.\n");
            Cmd_PrintHelp(o_writeconfig);
            return;
        case 'm':
            modified = qtrue;
            mask = ~0;
            break;
        default:
            return;
        }
    }
 
    if (!cmd_optarg[0]) {
        Com_Printf("Missing filename argument.\n");
        Cmd_PrintHint();
        return;
    }
 
    if (!aliases && !bindings && !mask) {
        bindings = qtrue;
        mask = CVAR_ARCHIVE;
    }
 
    f = FS_EasyOpenFile(buffer, sizeof(buffer), FS_MODE_WRITE | FS_FLAG_TEXT,
                        "configs/", cmd_optarg, ".cfg");
    if (!f) {
        return;
    }
 
    FS_FPrintf(f, "// generated by q2pro\n");
 
    if (bindings) {
        FS_FPrintf(f, "\n// key bindings\n");
        Key_WriteBindings(f);
    }
    if (aliases) {
        FS_FPrintf(f, "\n// command aliases\n");
        Cmd_WriteAliases(f);
    }
    if (mask) {
        FS_FPrintf(f, "\n//%s cvars\n", modified ? "modified" : "archived");
        Cvar_WriteVariables(f, mask, modified);
    }
 
    FS_FCloseFile(f);
 
    Com_Printf("Wrote %s.\n", buffer);
}

dump_program()

static void dump_program ( const char *  text, const char *  name  )

static

Definition at line 2083 of file main.c.

{
    char buffer[MAX_OSPATH];
 
    if (cls.state != ca_active) {
        Com_Printf("Must be in a level to dump.\n");
        return;
    }
 
    if (Cmd_Argc() != 2) {
        Com_Printf("Usage: %s <filename>\n", Cmd_Argv(0));
        return;
    }
 
    if (!*text) {
        Com_Printf("No %s to dump.\n", name);
        return;
    }
 
    if (FS_EasyWriteFile(buffer, sizeof(buffer), FS_MODE_WRITE | FS_FLAG_TEXT,
                         "layouts/", Cmd_Argv(1), ".txt", text, strlen(text))) {
        Com_Printf("Dumped %s program to %s.\n", name, buffer);
    }
}

Referenced by CL_DumpLayout_f(), and CL_DumpStatusbar_f().

exec_server_string()

static void exec_server_string ( cmdbuf_t *  buf, const char *  text  )

static

Definition at line 2560 of file main.c.

{
    char *s;
 
    Cmd_TokenizeString(text, qtrue);
 
    // execute the command line
    if (!Cmd_Argc()) {
        return;        // no tokens
    }
 
    Com_DPrintf("stufftext: %s\n", text);
 
    s = Cmd_Argv(0);
 
    // handle private client commands
    if (!strcmp(s, "changing")) {
        CL_Changing_f();
        return;
    }
    if (!strcmp(s, "precache")) {
        CL_Precache_f();
        return;
    }
 
    // forbid nearly every command from demos
    if (cls.demo.playback) {
        if (strcmp(s, "play")) {
            return;
        }
    }
 
    // execute regular commands
    Cmd_ExecuteCommand(buf);
}

Referenced by CL_Init().

find_ignore()

static ignore_t* find_ignore ( const char *  match )

static

Definition at line 1841 of file main.c.

{
    ignore_t *ignore;
 
    LIST_FOR_EACH(ignore_t, ignore, &cl_ignores, entry) {
        if (!strcmp(ignore->match, match)) {
            return ignore;
        }
    }
 
    return NULL;
}

Referenced by add_ignore(), and remove_ignore().

fps_to_msec()

static int fps_to_msec ( int  fps )

inlinestatic

Definition at line 3120 of file main.c.

{
#if 0
    return (1000 + fps / 2) / fps;
#else
    return 1000 / fps;
#endif
}

Referenced by CL_UpdateFrameTimes().

info_hand_changed()

static void info_hand_changed ( cvar_t *  self )

static

Definition at line 2601 of file main.c.

{
    CL_UpdateGunSetting();
}

Referenced by CL_InitLocal().

list_ignores()

static void list_ignores ( void  )

static

Definition at line 1854 of file main.c.

{
    ignore_t *ignore;
 
    if (LIST_EMPTY(&cl_ignores)) {
        Com_Printf("No ignore filters.\n");
        return;
    }
 
    Com_Printf("Current ignore filters:\n");
    LIST_FOR_EACH(ignore_t, ignore, &cl_ignores, entry) {
        Com_Printf("\"%s\" (%u hit%s)\n", ignore->match,
                   ignore->hits, ignore->hits == 1 ? "" : "s");
    }
}

Referenced by CL_IgnoreNick_f(), CL_IgnoreText_f(), CL_UnIgnoreNick_f(), and CL_UnIgnoreText_f().

parse_ignore_nick()

static size_t parse_ignore_nick ( int  argnum, char *  buffer  )

static

Definition at line 1958 of file main.c.

{
    char temp[MAX_CLIENT_NAME];
    char *p, *s;
    int c;
    size_t len;
 
    Cmd_ArgvBuffer(argnum, temp, sizeof(temp));
 
    s = temp;
    p = buffer;
    len = 0;
    while (*s) {
        c = *s++;
        c &= 127;
        if (c == '?') {
            *p++ = '\\';
            *p++ = '?';
            len += 2;
        } else if (c == '*') {
            *p++ = '\\';
            *p++ = '*';
            len += 2;
        } else if (c == '\\') {
            *p++ = '\\';
            *p++ = '\\';
            len += 2;
        } else if (Q_isprint(c)) {
            *p++ = c;
            len++;
        }
    }
 
    *p = 0;
 
    return len;
}

Referenced by CL_IgnoreNick_f(), and CL_UnIgnoreNick_f().

R_Fps_m()

static size_t R_Fps_m ( char *  buffer, size_t  size  )

static

Definition at line 2280 of file main.c.

{
    return Q_scnprintf(buffer, size, "%i", R_FPS);
}

Referenced by CL_InitLocal().

remove_all_ignores()

static void remove_all_ignores ( void  )

static

Definition at line 1906 of file main.c.

{
    ignore_t *ignore, *next;
    int count = 0;
 
    LIST_FOR_EACH_SAFE(ignore_t, ignore, next, &cl_ignores, entry) {
        Z_Free(ignore);
        count++;
    }
 
    Com_Printf("Removed %d ignore filter%s.\n", count, count == 1 ? "" : "s");
    List_Init(&cl_ignores);
}

Referenced by CL_UnIgnoreText_f().

remove_ignore()

static void remove_ignore ( const char *  match )

static

Definition at line 1892 of file main.c.

{
    ignore_t *ignore;
 
    ignore = find_ignore(match);
    if (!ignore) {
        Com_Printf("Can't find ignore filter \"%s\"\n", match);
        return;
    }
 
    List_Remove(&ignore->entry);
    Z_Free(ignore);
}

Referenced by CL_UnIgnoreNick_f(), and CL_UnIgnoreText_f().

SortPlayers()

static int SortPlayers ( const void *  v1, const void *  v2  )

static

Definition at line 864 of file main.c.

{
    const playerStatus_t *p1 = (const playerStatus_t *)v1;
    const playerStatus_t *p2 = (const playerStatus_t *)v2;
 
    return p2->score - p1->score;
}

Referenced by CL_ParseStatusResponse().

Variable Documentation

c_client

const cmdreg_t c_client[]

static

Definition at line 2656 of file main.c.

Referenced by CL_InitLocal().

cl

client_state_t cl

Definition at line 99 of file main.c.

Referenced by AC_CheckTimeouts(), AC_ClientAnnounce(), AC_ClientBegin(), AC_ClientConnect(), AC_ClientDisconnect(), AC_ClientQuery(), AC_ClientToken(), AC_Drop(), AC_Info_f(), AC_Invalidate_f(), AC_List_f(), AC_ParseClient(), AC_ParseClientAck(), AC_ParseDisconnect(), AC_ParseFileViolation(), AC_ParseQueryReply(), AC_ParseViolation(), AC_Update_f(), active_sun_preset(), AL_AddLoopSounds(), AL_Update(), build_gamestate(), check_player(), CheckDMRules(), CL_AddBeams(), CL_AddExplosions(), CL_AddLasers(), CL_AddPacketEntities(), CL_AddParticles(), CL_AddPlayerBeams(), CL_AddViewWeapon(), CL_AdjustAngles(), CL_AllocExplosion(), CL_AllocLaser(), CL_Ammo_m(), CL_Armor_m(), CL_Begin(), CL_BFGExplosionParticles(), CL_BfgParticles(), CL_BigTeleportParticles(), CL_BlasterParticles(), CL_BlasterParticles2(), CL_BlasterTrail(), CL_BlasterTrail2(), CL_BloodParticleEffect(), CL_BubbleTrail(), CL_BubbleTrail2(), CL_CalcViewValues(), CL_Changing_f(), CL_CheatsOK(), CL_CheckPredictionError(), CL_CheckTimeout(), CL_ClampPitch(), CL_ClampSpeed(), CL_ClearState(), CL_ClipMoveToEntities(), CL_Cluster_m(), CL_ClusterThere_m(), CL_ColorExplosionParticles(), CL_ConnectionlessPacket(), CL_DebugTrail(), CL_DeltaFrame(), CL_DemoFrame(), CL_DiminishingTrail(), CL_DumpClients_f(), CL_DumpLayout_f(), CL_DumpStatusbar_f(), CL_EmitDemoFrame(), CL_EmitDemoSnapshot(), CL_ExplosionParticles(), CL_FinalizeCmd(), CL_FinishViewValues(), CL_FirstDemoFrame(), CL_FlagTrail(), CL_FlyEffect(), CL_FlyParticles(), CL_ForceWall(), CL_Frame(), CL_GenericParticleEffect(), CL_GetEntitySoundOrigin(), CL_GetResolutionScale(), CL_GTV_EmitFrame(), CL_GTV_WriteMessage(), CL_HdrColor_m(), CL_Health_m(), CL_Heatbeam(), CL_IonripperTrail(), CL_ItemRespawnParticles(), CL_KeyState(), CL_LoadClientinfo(), CL_LogoutEffect(), CL_Mapname_m(), CL_Material_m(), CL_Material_Override_m(), CL_MeasureStats(), CL_MonsterPlasma_Shell(), CL_MouseMove(), CL_MuzzleFlash(), CL_MuzzleFlash2(), CL_Name_g(), cl_noskins_changed(), CL_Nukeblast(), CL_NumLightPolys_m(), CL_OldRailTrail(), CL_ParseBaseline(), CL_ParseBeam(), CL_ParseCenterPrint(), CL_ParseConfigstring(), CL_ParseDeltaEntity(), CL_ParseFrame(), CL_ParseInventory(), CL_ParseLayout(), CL_ParseNuke(), CL_ParsePacketEntities(), CL_ParsePlayerBeam(), CL_ParsePrint(), CL_ParseServerData(), CL_ParseStartSoundPacket(), CL_ParseSteam(), CL_ParseTEnt(), CL_ParseWidow(), CL_ParticleEffect(), CL_ParticleEffect2(), CL_ParticleEffect3(), CL_ParticleEffectWaterSplash(), CL_ParticleSmokeEffect(), CL_ParticleSteamEffect(), CL_ParticleSteamEffect2(), CL_PlainExplosion(), CL_PointContents(), CL_PredictAngles(), CL_PredictMovement(), CL_PrepRefresh(), CL_ProcessEvents(), CL_ProcessSustain(), CL_QuadTrail(), CL_RailLights(), CL_RailSpiral(), CL_Record_f(), CL_RegisterBspModels(), CL_RegisterSounds(), CL_RegisterVWepModels(), CL_RequestNextDownload(), CL_ResolutionScale_m(), CL_RestartFilesystem(), CL_RestartRefresh(), CL_RocketTrail(), CL_Seek_f(), CL_SendBatchedCmd(), CL_SendCmd(), CL_SendDefaultCmd(), CL_SendKeepAlive(), CL_SetClientTime(), CL_SetSky(), CL_SetupFirstPersonView(), CL_SetupThirdPersionView(), CL_Skins_f(), CL_SmokeAndFlash(), CL_SmokeTrail(), CL_Suspend_f(), CL_TagTrail(), CL_TeleporterParticles(), CL_TeleportParticles(), CL_Timer_m(), CL_Trace(), CL_Tracker_Explode(), CL_Tracker_Shell(), CL_TrackerTrail(), CL_TrapParticles(), CL_UpdateCmd(), CL_UpdateConfigstring(), CL_Ups_m(), CL_ViewDir_m(), CL_ViewPos_m(), CL_WeaponModel_m(), CL_Widowbeamout(), CL_WidowSplash(), Cmd_Inven_f(), Cmd_Say_f(), Cmd_WeapLast_f(), Cmd_WeapNext_f(), Cmd_WeapPrev_f(), Con_DrawSolidConsole(), DeathmatchScoreboardMessage(), DMA_DriftBeginofs(), dump_lag(), dump_protocols(), dump_settings(), emit_gamestate(), emit_packet_entities(), entity_event(), entity_new(), entity_optimized(), entity_update(), entity_update_new(), entity_update_old(), find_client_slot(), G_CheckChaseStats(), G_SetSpectatorStats(), IN_AttackDown(), IN_CenterView(), IN_GetCurrentGrab(), IN_UseDown(), Key_Event(), LOC_Add_f(), LOC_AddLocationsToScene(), LOC_Delete_f(), LOC_FindClosest(), LOC_Here_m(), LOC_LoadLocations(), LOC_There_m(), LOC_Update_f(), LOC_Write_f(), MVD_BroadcastPrintf(), MVD_GameClientDisconnect(), MVD_GameClientDrop(), MVD_GameClientNameChanged(), MVD_LayoutClients(), MVD_ParseMulticast(), MVD_ParseSound(), MVD_RemoveClient(), MVD_Say_f(), MVD_SetServerState(), MVD_SwitchChannel(), MVD_UnicastPrint(), MVD_UnicastSend(), permit_connection(), ping_avg(), ping_min(), prepare_entities(), print_channel(), Qcommon_Frame(), ready_to_send(), ready_to_send_hacked(), resume_record(), S_BuildSoundList(), S_ParseStartSound(), S_RegisterSexedSound(), S_RegisterSexedSounds(), S_Update(), SCR_DrawActive(), SCR_DrawInventory(), SCR_DrawLayout(), SCR_DrawSelectedItemName(), SCR_DrawStats(), SCR_DrawTurtle(), SCR_ExecuteLayoutString(), SCR_FinishCinematic(), SCR_LagSample(), SCR_PlayCinematic(), SCR_RunCinematic(), SCR_ScoreDump_f(), SCR_ScoreShot_f(), SCR_SetCrosshairColor(), SCR_StopCinematic(), SCR_TimeRefresh_f(), SelectNextItem(), SelectPrevItem(), set_active_state(), shell_effect_hack(), SV_CalcPings(), SV_CountClients(), SV_GiveMsec(), SV_Lag_f(), SV_Player_g(), SV_SetPlayer(), SV_StatusString(), SV_UserinfoChanged(), TH_DrawLayoutString(), V_RenderView(), V_SetLightLevel(), V_Viewpos_f(), ValidateSelectedItem(), and vkpt_freecam_mousemove().

cl_async

cvar_t* cl_async

Definition at line 32 of file main.c.

Referenced by CL_InitLocal(), and CL_UpdateFrameTimes().

cl_autopause

cvar_t* cl_autopause

Definition at line 34 of file main.c.

Referenced by CL_CheckForPause(), and CL_InitLocal().

cl_beginmapcmd

cvar_t* cl_beginmapcmd

Definition at line 61 of file main.c.

Referenced by CL_InitLocal(), and set_active_state().

cl_changemapcmd

cvar_t* cl_changemapcmd

Definition at line 60 of file main.c.

Referenced by CL_Changing_f(), and CL_InitLocal().

cl_chat_filter

cvar_t* cl_chat_filter

Definition at line 55 of file main.c.

Referenced by CL_InitLocal(), and CL_ParsePrint().

cl_chat_notify

cvar_t* cl_chat_notify

Definition at line 53 of file main.c.

Referenced by CL_InitLocal(), and CL_ParsePrint().

cl_chat_sound

cvar_t* cl_chat_sound

Definition at line 54 of file main.c.

Referenced by CL_InitLocal(), and CL_ParsePrint().

cl_cinematics

cvar_t* cl_cinematics

Definition at line 74 of file main.c.

Referenced by CL_InitLocal().

cl_cmdbuf

cmdbuf_t cl_cmdbuf

Definition at line 104 of file main.c.

Referenced by CL_FinalizeCmd(), CL_Init(), CL_ParseServerData(), CL_ParseStuffText(), CL_PlayDemo_f(), and CL_ProcessEvents().

cl_cmdbuf_text

char cl_cmdbuf_text[MAX_STRING_CHARS]

Definition at line 105 of file main.c.

Referenced by CL_Init().

cl_disable_explosions

cvar_t* cl_disable_explosions

Definition at line 52 of file main.c.

Referenced by CL_InitLocal(), and CL_ParseTEnt().

cl_disable_particles

cvar_t* cl_disable_particles

Definition at line 51 of file main.c.

Referenced by CL_AddPacketEntities(), CL_InitLocal(), and CL_ParseTEnt().

cl_disconnectcmd

cvar_t* cl_disconnectcmd

Definition at line 59 of file main.c.

Referenced by CL_Disconnect(), and CL_InitLocal().

cl_entities

centity_t cl_entities[MAX_EDICTS]

Definition at line 101 of file main.c.

Referenced by build_gamestate(), CL_AddPacketEntities(), CL_ClearState(), CL_DeltaFrame(), CL_FinishViewValues(), CL_GetEntitySoundOrigin(), CL_GTV_EmitFrame(), CL_MuzzleFlash(), CL_MuzzleFlash2(), entity_event(), entity_update(), player_update(), and shell_effect_hack().

cl_explosion_frametime

cvar_t* cl_explosion_frametime

Definition at line 57 of file main.c.

Referenced by CL_InitLocal(), and CL_PlainExplosion().

cl_explosion_sprites

cvar_t* cl_explosion_sprites

Definition at line 56 of file main.c.

Referenced by CL_InitLocal(), CL_ParseTEnt(), and CL_PlainExplosion().

cl_footsteps

cvar_t* cl_footsteps

Definition at line 26 of file main.c.

Referenced by CL_InitLocal(), CL_UpdateFootstepsSetting(), and entity_event().

cl_gibs

cvar_t* cl_gibs

Definition at line 63 of file main.c.

Referenced by CL_AddPacketEntities(), CL_InitLocal(), and CL_UpdateGibSetting().

cl_gun

cvar_t* cl_gun

Definition at line 29 of file main.c.

cl_gunalpha

cvar_t* cl_gunalpha

Definition at line 30 of file main.c.

Referenced by CL_AddViewWeapon(), and CL_InitLocal().

cl_ignores

list_t cl_ignores

static

Definition at line 1839 of file main.c.

Referenced by add_ignore(), CL_CheckForIgnore(), CL_InitLocal(), CL_UnIgnoreText_f(), find_ignore(), list_ignores(), and remove_all_ignores().

cl_kickangles

cvar_t* cl_kickangles

Definition at line 36 of file main.c.

Referenced by CL_InitLocal(), and CL_SetupFirstPersonView().

cl_maxfps

cvar_t* cl_maxfps

Definition at line 31 of file main.c.

Referenced by CL_InitLocal(), and CL_UpdateFrameTimes().

cl_noglow

cvar_t* cl_noglow

Definition at line 38 of file main.c.

Referenced by CL_AddPacketEntities(), and CL_InitLocal().

cl_nolerp

cvar_t* cl_nolerp

Definition at line 39 of file main.c.

Referenced by CL_InitLocal(), entity_new(), entity_update_old(), and player_update().

cl_noskins

cvar_t* cl_noskins

Definition at line 25 of file main.c.

Referenced by CL_InitLocal(), and CL_ParsePlayerSkin().

cl_player_model

cvar_t* cl_player_model

Definition at line 47 of file main.c.

Referenced by CL_AddViewWeapon(), CL_FinishViewValues(), CL_InitLocal(), CL_UpdateGunSetting(), prepare_entities(), prepare_ubo(), vkpt_freecam_reset(), vkpt_freecam_update(), and vkpt_pt_create_toplevel().

cl_predict

cvar_t* cl_predict

Definition at line 28 of file main.c.

Referenced by CL_CalcViewValues(), CL_CheckPredictionError(), CL_InitLocal(), CL_PredictMovement(), CL_UpdatePredictSetting(), and CL_Ups_m().

cl_protocol

cvar_t* cl_protocol

Definition at line 68 of file main.c.

Referenced by CL_CheckForResend(), CL_Connect_f(), CL_ConnectionlessPacket(), and CL_InitLocal().

cl_rollhack

cvar_t* cl_rollhack

Definition at line 37 of file main.c.

Referenced by CL_AddPacketEntities(), and CL_InitLocal().

cl_thirdperson_angle

cvar_t* cl_thirdperson_angle

Definition at line 48 of file main.c.

Referenced by CL_InitLocal(), and CL_SetupThirdPersionView().

cl_thirdperson_range

cvar_t* cl_thirdperson_range

Definition at line 49 of file main.c.

Referenced by CL_InitLocal(), and CL_SetupThirdPersionView().

cl_timeout

cvar_t* cl_timeout

Definition at line 27 of file main.c.

Referenced by CL_CheckTimeout(), and CL_InitLocal().

cl_vwep

cvar_t* cl_vwep

Definition at line 72 of file main.c.

Referenced by CL_InitLocal(), and CL_RegisterVWepModels().

clientRequests

request_t clientRequests[MAX_REQUESTS]

static

Definition at line 126 of file main.c.

Referenced by CL_AddRequest(), and CL_FindRequest().

cls

client_static_t cls

Definition at line 98 of file main.c.

Referenced by abort_downloads(), AL_AddLoopSounds(), build_gamestate(), CL_Activate(), CL_AddRequest(), CL_Begin(), CL_CalcViewValues(), CL_Changing_f(), CL_CheatsOK(), CL_CheckForIP(), CL_CheckForPause(), CL_CheckForResend(), CL_CheckPredictionError(), CL_CheckTimeout(), CL_CleanupDemos(), CL_CleanupDownloads(), CL_ClearState(), CL_ClientCommand(), CL_Connect_f(), CL_ConnectionlessPacket(), CL_DeltaFrame(), CL_DemoFrame(), CL_DemoPos_m(), CL_Disconnect(), CL_Disconnect_f(), CL_Download_f(), CL_DumpClients_f(), CL_EmitDemoFrame(), CL_EmitDemoSnapshot(), CL_FinalizeCmd(), CL_FindRequest(), CL_FinishDownload(), CL_FirstDemoFrame(), CL_FollowIP_f(), CL_ForwardToServer(), CL_ForwardToServer_f(), CL_Frame(), CL_GTV_EmitFrame(), CL_GTV_Resume(), CL_GTV_Run(), CL_GTV_Shutdown(), CL_GTV_Start_f(), CL_GTV_Status_f(), CL_GTV_Stop_f(), CL_GTV_Suspend(), CL_GTV_Transmit(), CL_GTV_WriteMessage(), CL_HandleDownload(), CL_IgnoreDownload(), CL_Init(), CL_InitDemos(), CL_InitDownloads(), CL_InitLocal(), CL_InitRefresh(), CL_Lag_m(), CL_LoadDownloadIgnores(), CL_MeasureStats(), CL_MouseMove(), CL_Name_g(), cl_noskins_changed(), CL_PacketEvent(), CL_ParseCenterPrint(), CL_ParseConfigstring(), CL_ParseDownload(), CL_ParseFrame(), CL_ParsePrint(), CL_ParsePrintMessage(), CL_ParseReconnect(), CL_ParseServerData(), CL_ParseServerMessage(), CL_ParseZPacket(), CL_PassiveConnect_f(), CL_Ping_m(), CL_PlayDemo_f(), CL_Precache_f(), CL_PredictMovement(), CL_PrepRefresh(), CL_QueueDownload(), CL_Rcon_f(), CL_RecentIP_g(), CL_Reconnect_f(), CL_Record_f(), CL_RegisterBspModels(), CL_RequestNextDownload(), CL_RestartFilesystem(), CL_RestartRefresh(), CL_RunRefresh(), CL_Seek_f(), CL_SendBatchedCmd(), CL_SendCmd(), CL_SendDefaultCmd(), CL_SendKeepAlive(), CL_SendUserinfo(), CL_Server_m(), CL_ServerStatus_f(), CL_Shutdown(), CL_ShutdownRefresh(), CL_Skins_f(), CL_StartNextDownload(), CL_Stop_f(), CL_Suspend_f(), CL_UpdateBlendSetting(), CL_UpdateConfigstring(), CL_UpdateFootstepsSetting(), CL_UpdateFrameTimes(), CL_UpdateGibSetting(), CL_UpdateGunSetting(), CL_UpdatePredictSetting(), CL_UpdateRecordingSetting(), CL_UpdateUserinfo(), CL_Ups_m(), cl_vwep_changed(), CL_WriteDemoMessage(), Con_Action(), Con_CarriageRet(), Con_Close(), Con_DrawNotify(), Con_DrawSolidConsole(), con_param_changed(), Con_Popup(), Con_RemoteMode_f(), Con_RunConsole(), con_scale_changed(), downloads_pending(), drop_client(), dump_program(), emit_gamestate(), entity_optimized(), exec_server_string(), find_snapshot(), finish_download(), finish_udp_download(), format_demo_size(), format_demo_status(), HTTP_QueueDownload(), HTTP_SetServer(), IN_AttackDown(), IN_GetCurrentGrab(), IN_UseDown(), inflate_udp_download(), Key_Event(), Key_GetDest(), Key_Message(), Key_SetDest(), lerp_client_fov(), LOC_Add_f(), LOC_Delete_f(), LOC_Here_m(), LOC_There_m(), LOC_Update_f(), LOC_Write_f(), parse_hello(), parse_message(), parse_next_message(), parse_ping(), parse_stream_start(), parse_stream_stop(), progress_func(), R_RenderFrame_RTX(), ready_to_send(), resume_record(), S_Activate(), S_Update(), SCR_AddToChatHUD(), SCR_BeginLoadingPlaque(), SCR_CenterPrint(), SCR_Draw2D(), SCR_DrawActive(), SCR_DrawDemo(), SCR_DrawInventory(), SCR_DrawLayout(), SCR_DrawNet(), SCR_EndLoadingPlaque(), SCR_FadeAlpha(), SCR_LagSample(), SCR_ModeChanged(), SCR_PlayCinematic(), SCR_RunCinematic(), SCR_ScoreDump_f(), SCR_ScoreShot_f(), SCR_Sky_f(), SCR_TimeRefresh_f(), SCR_UpdateScreen(), set_active_state(), start_message_mode(), start_next_download(), start_udp_download(), toggle_console(), UI_PopMenu(), update_status(), write_stream(), and write_udp_download().

fs_shareware

cvar_t* fs_shareware

Definition at line 204 of file files.c.

Referenced by CL_Connect_f().

gender_auto

cvar_t* gender_auto

Definition at line 70 of file main.c.

Referenced by CL_InitLocal(), and CL_UpdateUserinfo().

gl_brightness

cvar_t* gl_brightness

Definition at line 45 of file main.c.

Referenced by CL_Begin(), CL_ClearState(), gl_lightmap_changed(), and GL_Register().

gl_modulate_entities

cvar_t* gl_modulate_entities

Definition at line 50 of file main.c.

Referenced by CL_Begin(), CL_ClearState(), gl_modulate_entities_changed(), and GL_Register().

gl_modulate_world

cvar_t* gl_modulate_world

Definition at line 43 of file main.c.

Referenced by CL_Begin(), CL_ClearState(), gl_lightmap_changed(), and GL_Register().

info_fov

cvar_t* info_fov

Definition at line 84 of file main.c.

Referenced by CL_InitLocal(), and lerp_client_fov().

info_gender

cvar_t* info_gender

Definition at line 87 of file main.c.

Referenced by CL_FixUpGender(), and CL_InitLocal().

info_hand

cvar_t* info_hand

Definition at line 86 of file main.c.

Referenced by CL_AddPlayerBeams(), CL_AddViewWeapon(), CL_InitLocal(), and CL_UpdateGunSetting().

info_msg

cvar_t* info_msg

Definition at line 85 of file main.c.

Referenced by CL_InitLocal().

info_name

cvar_t* info_name

Definition at line 81 of file main.c.

Referenced by CL_InitLocal().

info_password

cvar_t* info_password

Definition at line 79 of file main.c.

Referenced by CL_InitLocal().

info_rate

cvar_t* info_rate

Definition at line 83 of file main.c.

Referenced by CalcPingRate(), and CL_InitLocal().

info_skin

cvar_t* info_skin

Definition at line 82 of file main.c.

Referenced by CL_FixUpGender(), CL_InitLocal(), and CL_UpdateUserinfo().

info_spectator

cvar_t* info_spectator

Definition at line 80 of file main.c.

Referenced by CL_InitLocal().

info_uf

cvar_t* info_uf

Definition at line 88 of file main.c.

Referenced by CL_InitLocal(), and lerp_client_fov().

main_extra

int main_extra

static

Definition at line 3117 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().

main_msec

int main_msec

static

Definition at line 3116 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().

nextRequest

unsigned nextRequest

static

Definition at line 127 of file main.c.

Referenced by CL_AddRequest(), and CL_FindRequest().

o_writeconfig

const cmd_option_t o_writeconfig[]

static

Initial value:

= {
    { "a", "aliases", "write aliases" },
    { "b", "bindings", "write bindings" },
    { "c", "cvars", "write archived cvars" },
    { "h", "help", "display this help message" },
    { "m", "modified", "write modified cvars" },
    { NULL }
}

Definition at line 2118 of file main.c.

Referenced by CL_WriteConfig_c(), and CL_WriteConfig_f().

phys_extra

int phys_extra

static

Definition at line 3117 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().

phys_msec

int phys_msec

static

Definition at line 3116 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().

precache_spawncount

int precache_spawncount

static

Definition at line 1748 of file main.c.

Referenced by CL_Begin(), and CL_Precache_f().

r_maxfps

cvar_t* r_maxfps

Definition at line 33 of file main.c.

Referenced by CL_InitLocal(), and CL_UpdateFrameTimes().

rcon_address

cvar_t* rcon_address

Definition at line 23 of file main.c.

Referenced by CL_InitLocal(), and CL_Rcon_f().

ref_extra

int ref_extra

static

Definition at line 3117 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().

ref_msec

int ref_msec

static

Definition at line 3116 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().

sync_mode

sync_mode_t sync_mode

static

Definition at line 3118 of file main.c.

Referenced by CL_Frame(), and CL_UpdateFrameTimes().