menu.c File Reference

#include <ctype.h>
#include <io.h>
#include "client.h"
#include "../client/qmenu.h"

Go to the source code of this file.

Classes
struct	menulayer_t
struct	playermodelinfo_s

Macros
#define	NUM_CURSOR_FRAMES   15
#define	MAX_MENU_DEPTH   8
#define	MAIN_ITEMS   5
#define	MAX_SAVEGAMES   15
#define	MAX_LOCAL_SERVERS   8
#define	NO_SERVER_STRING   "<no server>"
#define	NUM_ADDRESSBOOK_ENTRIES   9
#define	MAX_DISPLAYNAME   16
#define	MAX_PLAYERMODELS   1024

Functions
void	M_Menu_Main_f (void)
void	M_Menu_Game_f (void)
void	M_Menu_LoadGame_f (void)
void	M_Menu_SaveGame_f (void)
void	M_Menu_PlayerConfig_f (void)
void	M_Menu_DownloadOptions_f (void)
void	M_Menu_Credits_f (void)
void	M_Menu_Multiplayer_f (void)
void	M_Menu_JoinServer_f (void)
void	M_Menu_AddressBook_f (void)
void	M_Menu_StartServer_f (void)
void	M_Menu_DMOptions_f (void)
void	M_Menu_Video_f (void)
void	M_Menu_Options_f (void)
void	M_Menu_Keys_f (void)
void	M_Menu_Quit_f (void)
void	M_Menu_Credits (void)
static void	M_Banner (char *name)
void	M_PushMenu (void(*draw)(void), const char *(*key)(int k))
void	M_ForceMenuOff (void)
void	M_PopMenu (void)
const char *	Default_MenuKey (menuframework_s *m, int key)
void	M_DrawCharacter (int cx, int cy, int num)
void	M_Print (int cx, int cy, char *str)
void	M_PrintWhite (int cx, int cy, char *str)
void	M_DrawPic (int x, int y, char *pic)
void	M_DrawCursor (int x, int y, int f)
void	M_DrawTextBox (int x, int y, int width, int lines)
void	M_Main_Draw (void)
const char *	M_Main_Key (int key)
static void	Multiplayer_MenuDraw (void)
static void	PlayerSetupFunc (void *unused)
static void	JoinNetworkServerFunc (void *unused)
static void	StartNetworkServerFunc (void *unused)
void	Multiplayer_MenuInit (void)
const char *	Multiplayer_MenuKey (int key)
static void	M_UnbindCommand (char *command)
static void	M_FindKeysForCommand (char *command, int *twokeys)
static void	KeyCursorDrawFunc (menuframework_s *menu)
static void	DrawKeyBindingFunc (void *self)
static void	KeyBindingFunc (void *self)
static void	Keys_MenuInit (void)
static void	Keys_MenuDraw (void)
static const char *	Keys_MenuKey (int key)
static void	CrosshairFunc (void *unused)
static void	JoystickFunc (void *unused)
static void	CustomizeControlsFunc (void *unused)
static void	AlwaysRunFunc (void *unused)
static void	FreeLookFunc (void *unused)
static void	MouseSpeedFunc (void *unused)
static void	NoAltTabFunc (void *unused)
static float	ClampCvar (float min, float max, float value)
static void	ControlsSetMenuItemValues (void)
static void	ControlsResetDefaultsFunc (void *unused)
static void	InvertMouseFunc (void *unused)
static void	LookspringFunc (void *unused)
static void	LookstrafeFunc (void *unused)
static void	UpdateVolumeFunc (void *unused)
static void	UpdateCDVolumeFunc (void *unused)
static void	ConsoleFunc (void *unused)
static void	UpdateSoundQualityFunc (void *unused)
void	Options_MenuInit (void)
void	Options_MenuDraw (void)
const char *	Options_MenuKey (int key)
void	M_Credits_MenuDraw (void)
const char *	M_Credits_Key (int key)
int	Developer_searchpath (int who)
static void	StartGame (void)
static void	EasyGameFunc (void *data)
static void	MediumGameFunc (void *data)
static void	HardGameFunc (void *data)
static void	LoadGameFunc (void *unused)
static void	SaveGameFunc (void *unused)
static void	CreditsFunc (void *unused)
void	Game_MenuInit (void)
void	Game_MenuDraw (void)
const char *	Game_MenuKey (int key)
void	Create_Savestrings (void)
void	LoadGameCallback (void *self)
void	LoadGame_MenuInit (void)
void	LoadGame_MenuDraw (void)
const char *	LoadGame_MenuKey (int key)
void	SaveGameCallback (void *self)
void	SaveGame_MenuDraw (void)
void	SaveGame_MenuInit (void)
const char *	SaveGame_MenuKey (int key)
void	M_AddToServerList (netadr_t adr, char *info)
void	JoinServerFunc (void *self)
void	AddressBookFunc (void *self)
void	NullCursorDraw (void *self)
void	SearchLocalGames (void)
void	SearchLocalGamesFunc (void *self)
void	JoinServer_MenuInit (void)
void	JoinServer_MenuDraw (void)
const char *	JoinServer_MenuKey (int key)
void	DMOptionsFunc (void *self)
void	RulesChangeFunc (void *self)
void	StartServerActionFunc (void *self)
void	StartServer_MenuInit (void)
void	StartServer_MenuDraw (void)
const char *	StartServer_MenuKey (int key)
static void	DMFlagCallback (void *self)
void	DMOptions_MenuInit (void)
void	DMOptions_MenuDraw (void)
const char *	DMOptions_MenuKey (int key)
static void	DownloadCallback (void *self)
void	DownloadOptions_MenuInit (void)
void	DownloadOptions_MenuDraw (void)
const char *	DownloadOptions_MenuKey (int key)
void	AddressBook_MenuInit (void)
const char *	AddressBook_MenuKey (int key)
void	AddressBook_MenuDraw (void)
void	DownloadOptionsFunc (void *self)
static void	HandednessCallback (void *unused)
static void	RateCallback (void *unused)
static void	ModelCallback (void *unused)
static void	FreeFileList (char **list, int n)
static qboolean	IconOfSkinExists (char *skin, char **pcxfiles, int npcxfiles)
static qboolean	PlayerConfig_ScanDirectories (void)
static int	pmicmpfnc (const void *_a, const void *_b)
qboolean	PlayerConfig_MenuInit (void)
void	PlayerConfig_MenuDraw (void)
const char *	PlayerConfig_MenuKey (int key)
const char *	M_Quit_Key (int key)
void	M_Quit_Draw (void)
void	M_Init (void)
void	M_Draw (void)
void	M_Keydown (int key)

Variables
cvar_t *	vid_hudscale
static int	m_main_cursor
static qboolean	update_sound_quality = false
static qboolean	search_local_games = false
static char *	menu_in_sound = "misc/menu1.wav"
static char *	menu_move_sound = "misc/menu2.wav"
static char *	menu_out_sound = "misc/menu3.wav"
qboolean	m_entersound
void(*	m_drawfunc )(void)
const char *(*	m_keyfunc )(int key)
menulayer_t	m_layers [MAX_MENU_DEPTH]
int	m_menudepth
static menuframework_s	s_multiplayer_menu
static menuaction_s	s_join_network_server_action
static menuaction_s	s_start_network_server_action
static menuaction_s	s_player_setup_action
char *	bindnames [][2]
int	keys_cursor
static int	bind_grab
static menuframework_s	s_keys_menu
static menuaction_s	s_keys_attack_action
static menuaction_s	s_keys_change_weapon_action
static menuaction_s	s_keys_change_weapon_prev_action
static menuaction_s	s_keys_change_weapon_last_action
static menuaction_s	s_keys_walk_forward_action
static menuaction_s	s_keys_backpedal_action
static menuaction_s	s_keys_turn_left_action
static menuaction_s	s_keys_turn_right_action
static menuaction_s	s_keys_run_action
static menuaction_s	s_keys_step_left_action
static menuaction_s	s_keys_step_right_action
static menuaction_s	s_keys_sidestep_action
static menuaction_s	s_keys_look_up_action
static menuaction_s	s_keys_look_down_action
static menuaction_s	s_keys_center_view_action
static menuaction_s	s_keys_mouse_look_action
static menuaction_s	s_keys_keyboard_look_action
static menuaction_s	s_keys_move_up_action
static menuaction_s	s_keys_move_down_action
static menuaction_s	s_keys_inventory_action
static menuaction_s	s_keys_inv_use_action
static menuaction_s	s_keys_inv_drop_action
static menuaction_s	s_keys_inv_prev_action
static menuaction_s	s_keys_inv_next_action
static menuaction_s	s_keys_help_computer_action
static cvar_t *	win_noalttab
cvar_t *	in_joystick
static menuframework_s	s_options_menu
static menuaction_s	s_options_defaults_action
static menuaction_s	s_options_customize_options_action
static menuslider_s	s_options_sensitivity_slider
static menulist_s	s_options_freelook_box
static menulist_s	s_options_noalttab_box
static menulist_s	s_options_alwaysrun_box
static menulist_s	s_options_invertmouse_box
static menulist_s	s_options_lookspring_box
static menulist_s	s_options_lookstrafe_box
static menulist_s	s_options_crosshair_box
static menuslider_s	s_options_sfxvolume_slider
static menulist_s	s_options_joystick_box
static menulist_s	s_options_cdvolume_box
static menulist_s	s_options_quality_list
static menulist_s	s_options_compatibility_list
static menulist_s	s_options_console_action
static int	credits_start_time
static const char **	credits
static char *	creditsIndex [256]
static char *	creditsBuffer
static const char *	idcredits []
static const char *	xatcredits []
static const char *	roguecredits []
static int	m_game_cursor
static menuframework_s	s_game_menu
static menuaction_s	s_easy_game_action
static menuaction_s	s_medium_game_action
static menuaction_s	s_hard_game_action
static menuaction_s	s_load_game_action
static menuaction_s	s_save_game_action
static menuaction_s	s_credits_action
static menuseparator_s	s_blankline
static menuframework_s	s_savegame_menu
static menuframework_s	s_loadgame_menu
static menuaction_s	s_loadgame_actions [MAX_SAVEGAMES]
char	m_savestrings [MAX_SAVEGAMES][32]
qboolean	m_savevalid [MAX_SAVEGAMES]
static menuaction_s	s_savegame_actions [MAX_SAVEGAMES]
static menuframework_s	s_joinserver_menu
static menuseparator_s	s_joinserver_server_title
static menuaction_s	s_joinserver_search_action
static menuaction_s	s_joinserver_address_book_action
static menuaction_s	s_joinserver_server_actions [MAX_LOCAL_SERVERS]
int	m_num_servers
static char	local_server_names [MAX_LOCAL_SERVERS][80]
static netadr_t	local_server_netadr [MAX_LOCAL_SERVERS]
static menuframework_s	s_startserver_menu
static char **	mapnames
static int	nummaps
static menuaction_s	s_startserver_start_action
static menuaction_s	s_startserver_dmoptions_action
static menufield_s	s_timelimit_field
static menufield_s	s_fraglimit_field
static menufield_s	s_maxclients_field
static menufield_s	s_hostname_field
static menulist_s	s_startmap_list
static menulist_s	s_rules_box
static char	dmoptions_statusbar [128]
static menuframework_s	s_dmoptions_menu
static menulist_s	s_friendlyfire_box
static menulist_s	s_falls_box
static menulist_s	s_weapons_stay_box
static menulist_s	s_instant_powerups_box
static menulist_s	s_powerups_box
static menulist_s	s_health_box
static menulist_s	s_spawn_farthest_box
static menulist_s	s_teamplay_box
static menulist_s	s_samelevel_box
static menulist_s	s_force_respawn_box
static menulist_s	s_armor_box
static menulist_s	s_allow_exit_box
static menulist_s	s_infinite_ammo_box
static menulist_s	s_fixed_fov_box
static menulist_s	s_quad_drop_box
static menulist_s	s_no_mines_box
static menulist_s	s_no_nukes_box
static menulist_s	s_stack_double_box
static menulist_s	s_no_spheres_box
static menuframework_s	s_downloadoptions_menu
static menuseparator_s	s_download_title
static menulist_s	s_allow_download_box
static menulist_s	s_allow_download_maps_box
static menulist_s	s_allow_download_models_box
static menulist_s	s_allow_download_players_box
static menulist_s	s_allow_download_sounds_box
static menuframework_s	s_addressbook_menu
static menufield_s	s_addressbook_fields [NUM_ADDRESSBOOK_ENTRIES]
static menuframework_s	s_player_config_menu
static menufield_s	s_player_name_field
static menulist_s	s_player_model_box
static menulist_s	s_player_skin_box
static menulist_s	s_player_handedness_box
static menulist_s	s_player_rate_box
static menuseparator_s	s_player_skin_title
static menuseparator_s	s_player_model_title
static menuseparator_s	s_player_hand_title
static menuseparator_s	s_player_rate_title
static menuaction_s	s_player_download_action
static playermodelinfo_s	s_pmi [MAX_PLAYERMODELS]
static char *	s_pmnames [MAX_PLAYERMODELS]
static int	s_numplayermodels
static int	rate_tbl [] = { 2500, 3200, 5000, 10000, 25000, 0 }
static const char *	rate_names []

Macro Definition Documentation

MAIN_ITEMS

#define MAIN_ITEMS   5

Definition at line 388 of file menu.c.

MAX_DISPLAYNAME

#define MAX_DISPLAYNAME   16

Definition at line 3391 of file menu.c.

MAX_LOCAL_SERVERS

#define MAX_LOCAL_SERVERS   8

Definition at line 2222 of file menu.c.

MAX_MENU_DEPTH

#define MAX_MENU_DEPTH   8

Definition at line 69 of file menu.c.

MAX_PLAYERMODELS

#define MAX_PLAYERMODELS   1024

Definition at line 3392 of file menu.c.

MAX_SAVEGAMES

#define MAX_SAVEGAMES   15

Definition at line 2045 of file menu.c.

NO_SERVER_STRING

#define NO_SERVER_STRING   "<no server>"

Definition at line 2231 of file menu.c.

NUM_ADDRESSBOOK_ENTRIES

#define NUM_ADDRESSBOOK_ENTRIES   9

Definition at line 3306 of file menu.c.

NUM_CURSOR_FRAMES

#define NUM_CURSOR_FRAMES   15

Definition at line 35 of file menu.c.

Function Documentation

AddressBook_MenuDraw()

void AddressBook_MenuDraw

(

void

)

Definition at line 3360 of file menu.c.

{
    M_Banner( "m_banner_addressbook" );
    Menu_Draw( &s_addressbook_menu );
}

Referenced by M_Menu_AddressBook_f().

AddressBook_MenuInit()

void AddressBook_MenuInit

(

void

)

Definition at line 3311 of file menu.c.

{
    int i;
 
    s_addressbook_menu.x = viddef.width / 2 - 142 * vid_hudscale->value;
    s_addressbook_menu.y = viddef.height / 2 - 58 * vid_hudscale->value;
    s_addressbook_menu.nitems = 0;
 
    for ( i = 0; i < NUM_ADDRESSBOOK_ENTRIES; i++ )
    {
        cvar_t *adr;
        char buffer[20];
 
        Com_sprintf( buffer, sizeof( buffer ), "adr%d", i );
 
        adr = Cvar_Get( buffer, "", CVAR_ARCHIVE );
 
        s_addressbook_fields[i].generic.type = MTYPE_FIELD;
        s_addressbook_fields[i].generic.name = 0;
        s_addressbook_fields[i].generic.callback = 0;
        s_addressbook_fields[i].generic.x       = 0;
        s_addressbook_fields[i].generic.y       = i * 18 * vid_hudscale->value + 0;
        s_addressbook_fields[i].generic.localdata[0] = i;
        s_addressbook_fields[i].cursor          = 0;
        s_addressbook_fields[i].length          = 60;
        s_addressbook_fields[i].visible_length  = 30;
 
        strcpy( s_addressbook_fields[i].buffer, adr->string );
 
        Menu_AddItem( &s_addressbook_menu, &s_addressbook_fields[i] );
    }
}

Referenced by M_Menu_AddressBook_f().

AddressBook_MenuKey()

const char* AddressBook_MenuKey

(

int

key

)

Definition at line 3344 of file menu.c.

{
    if ( key == K_ESCAPE )
    {
        int index;
        char buffer[20];
 
        for ( index = 0; index < NUM_ADDRESSBOOK_ENTRIES; index++ )
        {
            Com_sprintf( buffer, sizeof( buffer ), "adr%d", index );
            Cvar_Set( buffer, s_addressbook_fields[index].buffer );
        }
    }
    return Default_MenuKey( &s_addressbook_menu, key );
}

Referenced by M_Menu_AddressBook_f().

AddressBookFunc()

void AddressBookFunc

(

void *

self

)

Definition at line 2277 of file menu.c.

{
    M_Menu_AddressBook_f();
}

Referenced by JoinServer_MenuInit().

AlwaysRunFunc()

static void AlwaysRunFunc ( void *  unused )

static

Definition at line 1079 of file menu.c.

{
    Cvar_SetValue( "cl_run", s_options_alwaysrun_box.curvalue );
}

Referenced by Options_MenuInit().

ClampCvar()

static float ClampCvar ( float  min, float  max, float  value  )

static

Definition at line 1099 of file menu.c.

{
    if ( value < min ) return min;
    if ( value > max ) return max;
    return value;
}

Referenced by ControlsSetMenuItemValues(), and StartServerActionFunc().

ConsoleFunc()

static void ConsoleFunc ( void *  unused )

static

Definition at line 1169 of file menu.c.

{
    /*
    ** the proper way to do this is probably to have ToggleConsole_f accept a parameter
    */
    extern void Key_ClearTyping( void );
 
    if ( cl.attractloop )
    {
        Cbuf_AddText ("killserver\n");
        return;
    }
 
    Key_ClearTyping ();
    Con_ClearNotify ();
 
    M_ForceMenuOff ();
    cls.key_dest = key_console;
}

Referenced by Options_MenuInit().

ControlsResetDefaultsFunc()

static void ControlsResetDefaultsFunc ( void *  unused )

static

Definition at line 1136 of file menu.c.

{
    Cbuf_AddText ("exec default.cfg\n");
    Cbuf_Execute();
 
    ControlsSetMenuItemValues();
}

Referenced by Options_MenuInit().

ControlsSetMenuItemValues()

static void ControlsSetMenuItemValues ( void  )

static

Definition at line 1106 of file menu.c.

{
    s_options_sfxvolume_slider.curvalue     = Cvar_VariableValue( "s_volume" ) * 10;
    s_options_cdvolume_box.curvalue         = !Cvar_VariableValue("cd_nocd");
    s_options_quality_list.curvalue         = !Cvar_VariableValue( "s_loadas8bit" );
    s_options_sensitivity_slider.curvalue   = ( sensitivity->value ) * 2;
 
    Cvar_SetValue( "cl_run", ClampCvar( 0, 1, cl_run->value ) );
    s_options_alwaysrun_box.curvalue        = cl_run->value;
 
    s_options_invertmouse_box.curvalue      = m_pitch->value < 0;
 
    Cvar_SetValue( "lookspring", ClampCvar( 0, 1, lookspring->value ) );
    s_options_lookspring_box.curvalue       = lookspring->value;
 
    Cvar_SetValue( "lookstrafe", ClampCvar( 0, 1, lookstrafe->value ) );
    s_options_lookstrafe_box.curvalue       = lookstrafe->value;
 
    Cvar_SetValue( "freelook", ClampCvar( 0, 1, freelook->value ) );
    s_options_freelook_box.curvalue         = freelook->value;
 
    Cvar_SetValue( "crosshair", ClampCvar( 0, 3, crosshair->value ) );
    s_options_crosshair_box.curvalue        = crosshair->value;
 
    Cvar_SetValue( "in_joystick", ClampCvar( 0, 1, in_joystick->value ) );
    s_options_joystick_box.curvalue     = in_joystick->value;
 
    s_options_noalttab_box.curvalue         = win_noalttab->value;
}

Referenced by ControlsResetDefaultsFunc(), and Options_MenuInit().

Create_Savestrings()

void Create_Savestrings

(

void

)

Definition at line 2055 of file menu.c.

{
    int     i;
    FILE    *f;
    char    name[MAX_OSPATH];
 
    for (i=0 ; i<MAX_SAVEGAMES ; i++)
    {
        Com_sprintf (name, sizeof(name), "%s/save/save%i/server.ssv", FS_Gamedir(), i);
        f = fopen (name, "rb");
        if (!f)
        {
            strcpy (m_savestrings[i], "<EMPTY>");
            m_savevalid[i] = false;
        }
        else
        {
            FS_Read (m_savestrings[i], sizeof(m_savestrings[i]), f);
            fclose (f);
            m_savevalid[i] = true;
        }
    }
}

Referenced by LoadGame_MenuInit(), M_Menu_SaveGame_f(), and SaveGame_MenuInit().

CreditsFunc()

static void CreditsFunc ( void *  unused )

static

Definition at line 1952 of file menu.c.

{
    M_Menu_Credits_f();
}

Referenced by Game_MenuInit().

CrosshairFunc()

static void CrosshairFunc ( void *  unused )

static

Definition at line 1064 of file menu.c.

{
    Cvar_SetValue( "crosshair", s_options_crosshair_box.curvalue );
}

Referenced by Options_MenuInit().

CustomizeControlsFunc()

static void CustomizeControlsFunc ( void *  unused )

static

Definition at line 1074 of file menu.c.

{
    M_Menu_Keys_f();
}

Referenced by Options_MenuInit().

Default_MenuKey()

const char* Default_MenuKey	(	menuframework_s *	m,
		int	key
	)

Definition at line 148 of file menu.c.

{
    const char *sound = NULL;
    menucommon_s *item;
 
    if ( m )
    {
        if ( ( item = Menu_ItemAtCursor( m ) ) != 0 )
        {
            if ( item->type == MTYPE_FIELD )
            {
                if ( Field_Key( ( menufield_s * ) item, key ) )
                    return NULL;
            }
        }
    }
 
    switch ( key )
    {
    case K_ESCAPE:
        M_PopMenu();
        return menu_out_sound;
    case K_KP_UPARROW:
    case K_UPARROW:
        if ( m )
        {
            m->cursor--;
            Menu_AdjustCursor( m, -1 );
            sound = menu_move_sound;
        }
        break;
    case K_TAB:
        if ( m )
        {
            m->cursor++;
            Menu_AdjustCursor( m, 1 );
            sound = menu_move_sound;
        }
        break;
    case K_KP_DOWNARROW:
    case K_DOWNARROW:
        if ( m )
        {
            m->cursor++;
            Menu_AdjustCursor( m, 1 );
            sound = menu_move_sound;
        }
        break;
    case K_KP_LEFTARROW:
    case K_LEFTARROW:
        if ( m )
        {
            Menu_SlideItem( m, -1 );
            sound = menu_move_sound;
        }
        break;
    case K_KP_RIGHTARROW:
    case K_RIGHTARROW:
        if ( m )
        {
            Menu_SlideItem( m, 1 );
            sound = menu_move_sound;
        }
        break;
 
    case K_MOUSE1:
    case K_MOUSE2:
    case K_MOUSE3:
    case K_JOY1:
    case K_JOY2:
    case K_JOY3:
    case K_JOY4:
    case K_AUX1:
    case K_AUX2:
    case K_AUX3:
    case K_AUX4:
    case K_AUX5:
    case K_AUX6:
    case K_AUX7:
    case K_AUX8:
    case K_AUX9:
    case K_AUX10:
    case K_AUX11:
    case K_AUX12:
    case K_AUX13:
    case K_AUX14:
    case K_AUX15:
    case K_AUX16:
    case K_AUX17:
    case K_AUX18:
    case K_AUX19:
    case K_AUX20:
    case K_AUX21:
    case K_AUX22:
    case K_AUX23:
    case K_AUX24:
    case K_AUX25:
    case K_AUX26:
    case K_AUX27:
    case K_AUX28:
    case K_AUX29:
    case K_AUX30:
    case K_AUX31:
    case K_AUX32:
        
    case K_KP_ENTER:
    case K_ENTER:
        if ( m )
            Menu_SelectItem( m );
        sound = menu_move_sound;
        break;
    }
 
    return sound;
}

Referenced by AddressBook_MenuKey(), DMOptions_MenuKey(), DownloadOptions_MenuKey(), Game_MenuKey(), JoinServer_MenuKey(), Keys_MenuKey(), LoadGame_MenuKey(), Multiplayer_MenuKey(), Options_MenuKey(), PlayerConfig_MenuKey(), SaveGame_MenuKey(), and StartServer_MenuKey().

Developer_searchpath()

int Developer_searchpath

(

int

who

)

Definition at line 159 of file files.c.

{
    
    int     ch;
    // PMM - warning removal
//  char    *start;
    searchpath_t    *search;
    
    if (who == 1) // xatrix
        ch = 'x';
    else if (who == 2)
        ch = 'r';
 
    for (search = fs_searchpaths ; search ; search = search->next)
    {
        if (strstr (search->filename, "xatrix"))
            return 1;
 
        if (strstr (search->filename, "rogue"))
            return 2;
/*
        start = strchr (search->filename, ch);
 
        if (start == NULL)
            continue;
 
        if (strcmp (start ,"xatrix") == 0)
            return (1);
*/
    }
    return (0);
 
}

Referenced by DMFlagCallback(), DMOptions_MenuInit(), M_Menu_Credits_f(), RulesChangeFunc(), StartServer_MenuInit(), and StartServerActionFunc().

DMFlagCallback()

static void DMFlagCallback ( void *  self )

static

Definition at line 2799 of file menu.c.

{
    menulist_s *f = ( menulist_s * ) self;
    int flags;
    int bit = 0;
 
    flags = Cvar_VariableValue( "dmflags" );
 
    if ( f == &s_friendlyfire_box )
    {
        if ( f->curvalue )
            flags &= ~DF_NO_FRIENDLY_FIRE;
        else
            flags |= DF_NO_FRIENDLY_FIRE;
        goto setvalue;
    }
    else if ( f == &s_falls_box )
    {
        if ( f->curvalue )
            flags &= ~DF_NO_FALLING;
        else
            flags |= DF_NO_FALLING;
        goto setvalue;
    }
    else if ( f == &s_weapons_stay_box ) 
    {
        bit = DF_WEAPONS_STAY;
    }
    else if ( f == &s_instant_powerups_box )
    {
        bit = DF_INSTANT_ITEMS;
    }
    else if ( f == &s_allow_exit_box )
    {
        bit = DF_ALLOW_EXIT;
    }
    else if ( f == &s_powerups_box )
    {
        if ( f->curvalue )
            flags &= ~DF_NO_ITEMS;
        else
            flags |= DF_NO_ITEMS;
        goto setvalue;
    }
    else if ( f == &s_health_box )
    {
        if ( f->curvalue )
            flags &= ~DF_NO_HEALTH;
        else
            flags |= DF_NO_HEALTH;
        goto setvalue;
    }
    else if ( f == &s_spawn_farthest_box )
    {
        bit = DF_SPAWN_FARTHEST;
    }
    else if ( f == &s_teamplay_box )
    {
        if ( f->curvalue == 1 )
        {
            flags |=  DF_SKINTEAMS;
            flags &= ~DF_MODELTEAMS;
        }
        else if ( f->curvalue == 2 )
        {
            flags |=  DF_MODELTEAMS;
            flags &= ~DF_SKINTEAMS;
        }
        else
        {
            flags &= ~( DF_MODELTEAMS | DF_SKINTEAMS );
        }
 
        goto setvalue;
    }
    else if ( f == &s_samelevel_box )
    {
        bit = DF_SAME_LEVEL;
    }
    else if ( f == &s_force_respawn_box )
    {
        bit = DF_FORCE_RESPAWN;
    }
    else if ( f == &s_armor_box )
    {
        if ( f->curvalue )
            flags &= ~DF_NO_ARMOR;
        else
            flags |= DF_NO_ARMOR;
        goto setvalue;
    }
    else if ( f == &s_infinite_ammo_box )
    {
        bit = DF_INFINITE_AMMO;
    }
    else if ( f == &s_fixed_fov_box )
    {
        bit = DF_FIXED_FOV;
    }
    else if ( f == &s_quad_drop_box )
    {
        bit = DF_QUAD_DROP;
    }
 
//=======
//ROGUE
    else if (Developer_searchpath(2) == 2)
    {
        if ( f == &s_no_mines_box)
        {
            bit = DF_NO_MINES;
        }
        else if ( f == &s_no_nukes_box)
        {
            bit = DF_NO_NUKES;
        }
        else if ( f == &s_stack_double_box)
        {
            bit = DF_NO_STACK_DOUBLE;
        }
        else if ( f == &s_no_spheres_box)
        {
            bit = DF_NO_SPHERES;
        }
    }
//ROGUE
//=======
 
    if ( f )
    {
        if ( f->curvalue == 0 )
            flags &= ~bit;
        else
            flags |= bit;
    }
 
setvalue:
    Cvar_SetValue ("dmflags", flags);
 
    Com_sprintf( dmoptions_statusbar, sizeof( dmoptions_statusbar ), "dmflags = %d", flags );
 
}

Referenced by DMOptions_MenuInit().

DMOptions_MenuDraw()

void DMOptions_MenuDraw

(

void

)

Definition at line 3152 of file menu.c.

{
    Menu_Draw( &s_dmoptions_menu );
}

Referenced by M_Menu_DMOptions_f().

DMOptions_MenuInit()

void DMOptions_MenuInit

(

void

)

Definition at line 2942 of file menu.c.

{
    static const char *yes_no_names[] =
    {
        "no", "yes", 0
    };
    static const char *teamplay_names[] = 
    {
        "disabled", "by skin", "by model", 0
    };
    int dmflags = Cvar_VariableValue( "dmflags" );
    int y = 0;
 
    s_dmoptions_menu.x = viddef.width * 0.50;
    s_dmoptions_menu.nitems = 0;
 
    s_falls_box.generic.type = MTYPE_SPINCONTROL;
    s_falls_box.generic.x   = 0;
    s_falls_box.generic.y   = y * vid_hudscale->value;
    s_falls_box.generic.name    = "falling damage";
    s_falls_box.generic.callback = DMFlagCallback;
    s_falls_box.itemnames = yes_no_names;
    s_falls_box.curvalue = ( dmflags & DF_NO_FALLING ) == 0;
 
    s_weapons_stay_box.generic.type = MTYPE_SPINCONTROL;
    s_weapons_stay_box.generic.x    = 0;
    s_weapons_stay_box.generic.y    = y += 10 * vid_hudscale->value;
    s_weapons_stay_box.generic.name = "weapons stay";
    s_weapons_stay_box.generic.callback = DMFlagCallback;
    s_weapons_stay_box.itemnames = yes_no_names;
    s_weapons_stay_box.curvalue = ( dmflags & DF_WEAPONS_STAY ) != 0;
 
    s_instant_powerups_box.generic.type = MTYPE_SPINCONTROL;
    s_instant_powerups_box.generic.x    = 0;
    s_instant_powerups_box.generic.y    = y += 10 * vid_hudscale->value;
    s_instant_powerups_box.generic.name = "instant powerups";
    s_instant_powerups_box.generic.callback = DMFlagCallback;
    s_instant_powerups_box.itemnames = yes_no_names;
    s_instant_powerups_box.curvalue = ( dmflags & DF_INSTANT_ITEMS ) != 0;
 
    s_powerups_box.generic.type = MTYPE_SPINCONTROL;
    s_powerups_box.generic.x    = 0;
    s_powerups_box.generic.y    = y += 10 * vid_hudscale->value;
    s_powerups_box.generic.name = "allow powerups";
    s_powerups_box.generic.callback = DMFlagCallback;
    s_powerups_box.itemnames = yes_no_names;
    s_powerups_box.curvalue = ( dmflags & DF_NO_ITEMS ) == 0;
 
    s_health_box.generic.type = MTYPE_SPINCONTROL;
    s_health_box.generic.x  = 0;
    s_health_box.generic.y  = y += 10 * vid_hudscale->value;
    s_health_box.generic.callback = DMFlagCallback;
    s_health_box.generic.name   = "allow health";
    s_health_box.itemnames = yes_no_names;
    s_health_box.curvalue = ( dmflags & DF_NO_HEALTH ) == 0;
 
    s_armor_box.generic.type = MTYPE_SPINCONTROL;
    s_armor_box.generic.x   = 0;
    s_armor_box.generic.y   = y += 10 * vid_hudscale->value;
    s_armor_box.generic.name    = "allow armor";
    s_armor_box.generic.callback = DMFlagCallback;
    s_armor_box.itemnames = yes_no_names;
    s_armor_box.curvalue = ( dmflags & DF_NO_ARMOR ) == 0;
 
    s_spawn_farthest_box.generic.type = MTYPE_SPINCONTROL;
    s_spawn_farthest_box.generic.x  = 0;
    s_spawn_farthest_box.generic.y  = y += 10 * vid_hudscale->value;
    s_spawn_farthest_box.generic.name   = "spawn farthest";
    s_spawn_farthest_box.generic.callback = DMFlagCallback;
    s_spawn_farthest_box.itemnames = yes_no_names;
    s_spawn_farthest_box.curvalue = ( dmflags & DF_SPAWN_FARTHEST ) != 0;
 
    s_samelevel_box.generic.type = MTYPE_SPINCONTROL;
    s_samelevel_box.generic.x   = 0;
    s_samelevel_box.generic.y   = y += 10 * vid_hudscale->value;
    s_samelevel_box.generic.name    = "same map";
    s_samelevel_box.generic.callback = DMFlagCallback;
    s_samelevel_box.itemnames = yes_no_names;
    s_samelevel_box.curvalue = ( dmflags & DF_SAME_LEVEL ) != 0;
 
    s_force_respawn_box.generic.type = MTYPE_SPINCONTROL;
    s_force_respawn_box.generic.x   = 0;
    s_force_respawn_box.generic.y   = y += 10 * vid_hudscale->value;
    s_force_respawn_box.generic.name    = "force respawn";
    s_force_respawn_box.generic.callback = DMFlagCallback;
    s_force_respawn_box.itemnames = yes_no_names;
    s_force_respawn_box.curvalue = ( dmflags & DF_FORCE_RESPAWN ) != 0;
 
    s_teamplay_box.generic.type = MTYPE_SPINCONTROL;
    s_teamplay_box.generic.x    = 0;
    s_teamplay_box.generic.y    = y += 10 * vid_hudscale->value;
    s_teamplay_box.generic.name = "teamplay";
    s_teamplay_box.generic.callback = DMFlagCallback;
    s_teamplay_box.itemnames = teamplay_names;
 
    s_allow_exit_box.generic.type = MTYPE_SPINCONTROL;
    s_allow_exit_box.generic.x  = 0;
    s_allow_exit_box.generic.y  = y += 10 * vid_hudscale->value;
    s_allow_exit_box.generic.name   = "allow exit";
    s_allow_exit_box.generic.callback = DMFlagCallback;
    s_allow_exit_box.itemnames = yes_no_names;
    s_allow_exit_box.curvalue = ( dmflags & DF_ALLOW_EXIT ) != 0;
 
    s_infinite_ammo_box.generic.type = MTYPE_SPINCONTROL;
    s_infinite_ammo_box.generic.x   = 0;
    s_infinite_ammo_box.generic.y   = y += 10 * vid_hudscale->value;
    s_infinite_ammo_box.generic.name    = "infinite ammo";
    s_infinite_ammo_box.generic.callback = DMFlagCallback;
    s_infinite_ammo_box.itemnames = yes_no_names;
    s_infinite_ammo_box.curvalue = ( dmflags & DF_INFINITE_AMMO ) != 0;
 
    s_fixed_fov_box.generic.type = MTYPE_SPINCONTROL;
    s_fixed_fov_box.generic.x   = 0;
    s_fixed_fov_box.generic.y   = y += 10 * vid_hudscale->value;
    s_fixed_fov_box.generic.name    = "fixed FOV";
    s_fixed_fov_box.generic.callback = DMFlagCallback;
    s_fixed_fov_box.itemnames = yes_no_names;
    s_fixed_fov_box.curvalue = ( dmflags & DF_FIXED_FOV ) != 0;
 
    s_quad_drop_box.generic.type = MTYPE_SPINCONTROL;
    s_quad_drop_box.generic.x   = 0;
    s_quad_drop_box.generic.y   = y += 10 * vid_hudscale->value;
    s_quad_drop_box.generic.name    = "quad drop";
    s_quad_drop_box.generic.callback = DMFlagCallback;
    s_quad_drop_box.itemnames = yes_no_names;
    s_quad_drop_box.curvalue = ( dmflags & DF_QUAD_DROP ) != 0;
 
    s_friendlyfire_box.generic.type = MTYPE_SPINCONTROL;
    s_friendlyfire_box.generic.x    = 0;
    s_friendlyfire_box.generic.y    = y += 10 * vid_hudscale->value;
    s_friendlyfire_box.generic.name = "friendly fire";
    s_friendlyfire_box.generic.callback = DMFlagCallback;
    s_friendlyfire_box.itemnames = yes_no_names;
    s_friendlyfire_box.curvalue = ( dmflags & DF_NO_FRIENDLY_FIRE ) == 0;
 
//============
//ROGUE
    if(Developer_searchpath(2) == 2)
    {
        s_no_mines_box.generic.type = MTYPE_SPINCONTROL;
        s_no_mines_box.generic.x    = 0;
        s_no_mines_box.generic.y    = y += 10 * vid_hudscale->value;
        s_no_mines_box.generic.name = "remove mines";
        s_no_mines_box.generic.callback = DMFlagCallback;
        s_no_mines_box.itemnames = yes_no_names;
        s_no_mines_box.curvalue = ( dmflags & DF_NO_MINES ) != 0;
 
        s_no_nukes_box.generic.type = MTYPE_SPINCONTROL;
        s_no_nukes_box.generic.x    = 0;
        s_no_nukes_box.generic.y    = y += 10 * vid_hudscale->value;
        s_no_nukes_box.generic.name = "remove nukes";
        s_no_nukes_box.generic.callback = DMFlagCallback;
        s_no_nukes_box.itemnames = yes_no_names;
        s_no_nukes_box.curvalue = ( dmflags & DF_NO_NUKES ) != 0;
 
        s_stack_double_box.generic.type = MTYPE_SPINCONTROL;
        s_stack_double_box.generic.x    = 0;
        s_stack_double_box.generic.y    = y += 10 * vid_hudscale->value;
        s_stack_double_box.generic.name = "2x/4x stacking off";
        s_stack_double_box.generic.callback = DMFlagCallback;
        s_stack_double_box.itemnames = yes_no_names;
        s_stack_double_box.curvalue = ( dmflags & DF_NO_STACK_DOUBLE ) != 0;
 
        s_no_spheres_box.generic.type = MTYPE_SPINCONTROL;
        s_no_spheres_box.generic.x  = 0;
        s_no_spheres_box.generic.y  = y += 10 * vid_hudscale->value;
        s_no_spheres_box.generic.name   = "remove spheres";
        s_no_spheres_box.generic.callback = DMFlagCallback;
        s_no_spheres_box.itemnames = yes_no_names;
        s_no_spheres_box.curvalue = ( dmflags & DF_NO_SPHERES ) != 0;
 
    }
//ROGUE
//============
 
    Menu_AddItem( &s_dmoptions_menu, &s_falls_box );
    Menu_AddItem( &s_dmoptions_menu, &s_weapons_stay_box );
    Menu_AddItem( &s_dmoptions_menu, &s_instant_powerups_box );
    Menu_AddItem( &s_dmoptions_menu, &s_powerups_box );
    Menu_AddItem( &s_dmoptions_menu, &s_health_box );
    Menu_AddItem( &s_dmoptions_menu, &s_armor_box );
    Menu_AddItem( &s_dmoptions_menu, &s_spawn_farthest_box );
    Menu_AddItem( &s_dmoptions_menu, &s_samelevel_box );
    Menu_AddItem( &s_dmoptions_menu, &s_force_respawn_box );
    Menu_AddItem( &s_dmoptions_menu, &s_teamplay_box );
    Menu_AddItem( &s_dmoptions_menu, &s_allow_exit_box );
    Menu_AddItem( &s_dmoptions_menu, &s_infinite_ammo_box );
    Menu_AddItem( &s_dmoptions_menu, &s_fixed_fov_box );
    Menu_AddItem( &s_dmoptions_menu, &s_quad_drop_box );
    Menu_AddItem( &s_dmoptions_menu, &s_friendlyfire_box );
 
//=======
//ROGUE
    if(Developer_searchpath(2) == 2)
    {
        Menu_AddItem( &s_dmoptions_menu, &s_no_mines_box );
        Menu_AddItem( &s_dmoptions_menu, &s_no_nukes_box );
        Menu_AddItem( &s_dmoptions_menu, &s_stack_double_box );
        Menu_AddItem( &s_dmoptions_menu, &s_no_spheres_box );
    }
//ROGUE
//=======
 
    Menu_Center( &s_dmoptions_menu );
 
    // set the original dmflags statusbar
    DMFlagCallback( 0 );
    Menu_SetStatusBar( &s_dmoptions_menu, dmoptions_statusbar );
}

Referenced by M_Menu_DMOptions_f().

DMOptions_MenuKey()

const char* DMOptions_MenuKey

(

int

key

)

Definition at line 3157 of file menu.c.

{
    return Default_MenuKey( &s_dmoptions_menu, key );
}

Referenced by M_Menu_DMOptions_f().

DMOptionsFunc()

void DMOptionsFunc

(

void *

self

)

Definition at line 2404 of file menu.c.

{
    if (s_rules_box.curvalue == 1)
        return;
    M_Menu_DMOptions_f();
}

Referenced by StartServer_MenuInit().

DownloadCallback()

static void DownloadCallback ( void *  self )

static

Definition at line 3184 of file menu.c.

{
    menulist_s *f = ( menulist_s * ) self;
 
    if (f == &s_allow_download_box)
    {
        Cvar_SetValue("allow_download", f->curvalue);
    }
 
    else if (f == &s_allow_download_maps_box)
    {
        Cvar_SetValue("allow_download_maps", f->curvalue);
    }
 
    else if (f == &s_allow_download_models_box)
    {
        Cvar_SetValue("allow_download_models", f->curvalue);
    }
 
    else if (f == &s_allow_download_players_box)
    {
        Cvar_SetValue("allow_download_players", f->curvalue);
    }
 
    else if (f == &s_allow_download_sounds_box)
    {
        Cvar_SetValue("allow_download_sounds", f->curvalue);
    }
}

Referenced by DownloadOptions_MenuInit().

DownloadOptions_MenuDraw()

void DownloadOptions_MenuDraw

(

void

)

Definition at line 3284 of file menu.c.

{
    Menu_Draw( &s_downloadoptions_menu );
}

Referenced by M_Menu_DownloadOptions_f().

DownloadOptions_MenuInit()

void DownloadOptions_MenuInit

(

void

)

Definition at line 3214 of file menu.c.

{
    static const char *yes_no_names[] =
    {
        "no", "yes", 0
    };
    int y = 0;
 
    s_downloadoptions_menu.x = viddef.width * 0.50;
    s_downloadoptions_menu.nitems = 0;
 
    s_download_title.generic.type = MTYPE_SEPARATOR;
    s_download_title.generic.name = "Download Options";
    s_download_title.generic.x    = 48;
    s_download_title.generic.y   = y * vid_hudscale->value;
 
    s_allow_download_box.generic.type = MTYPE_SPINCONTROL;
    s_allow_download_box.generic.x  = 0;
    s_allow_download_box.generic.y  = y += 20 * vid_hudscale->value;
    s_allow_download_box.generic.name   = "allow downloading";
    s_allow_download_box.generic.callback = DownloadCallback;
    s_allow_download_box.itemnames = yes_no_names;
    s_allow_download_box.curvalue = (Cvar_VariableValue("allow_download") != 0);
 
    s_allow_download_maps_box.generic.type = MTYPE_SPINCONTROL;
    s_allow_download_maps_box.generic.x = 0;
    s_allow_download_maps_box.generic.y = y += 20 * vid_hudscale->value;
    s_allow_download_maps_box.generic.name  = "maps";
    s_allow_download_maps_box.generic.callback = DownloadCallback;
    s_allow_download_maps_box.itemnames = yes_no_names;
    s_allow_download_maps_box.curvalue = (Cvar_VariableValue("allow_download_maps") != 0);
 
    s_allow_download_players_box.generic.type = MTYPE_SPINCONTROL;
    s_allow_download_players_box.generic.x  = 0;
    s_allow_download_players_box.generic.y  = y += 10 * vid_hudscale->value;
    s_allow_download_players_box.generic.name   = "player models/skins";
    s_allow_download_players_box.generic.callback = DownloadCallback;
    s_allow_download_players_box.itemnames = yes_no_names;
    s_allow_download_players_box.curvalue = (Cvar_VariableValue("allow_download_players") != 0);
 
    s_allow_download_models_box.generic.type = MTYPE_SPINCONTROL;
    s_allow_download_models_box.generic.x   = 0;
    s_allow_download_models_box.generic.y   = y += 10 * vid_hudscale->value;
    s_allow_download_models_box.generic.name    = "models";
    s_allow_download_models_box.generic.callback = DownloadCallback;
    s_allow_download_models_box.itemnames = yes_no_names;
    s_allow_download_models_box.curvalue = (Cvar_VariableValue("allow_download_models") != 0);
 
    s_allow_download_sounds_box.generic.type = MTYPE_SPINCONTROL;
    s_allow_download_sounds_box.generic.x   = 0;
    s_allow_download_sounds_box.generic.y   = y += 10 * vid_hudscale->value;
    s_allow_download_sounds_box.generic.name    = "sounds";
    s_allow_download_sounds_box.generic.callback = DownloadCallback;
    s_allow_download_sounds_box.itemnames = yes_no_names;
    s_allow_download_sounds_box.curvalue = (Cvar_VariableValue("allow_download_sounds") != 0);
 
    Menu_AddItem( &s_downloadoptions_menu, &s_download_title );
    Menu_AddItem( &s_downloadoptions_menu, &s_allow_download_box );
    Menu_AddItem( &s_downloadoptions_menu, &s_allow_download_maps_box );
    Menu_AddItem( &s_downloadoptions_menu, &s_allow_download_players_box );
    Menu_AddItem( &s_downloadoptions_menu, &s_allow_download_models_box );
    Menu_AddItem( &s_downloadoptions_menu, &s_allow_download_sounds_box );
 
    Menu_Center( &s_downloadoptions_menu );
 
    // skip over title
    if (s_downloadoptions_menu.cursor == 0)
        s_downloadoptions_menu.cursor = 1;
}

Referenced by M_Menu_DownloadOptions_f().

DownloadOptions_MenuKey()

const char* DownloadOptions_MenuKey

(

int

key

)

Definition at line 3289 of file menu.c.

{
    return Default_MenuKey( &s_downloadoptions_menu, key );
}

Referenced by M_Menu_DownloadOptions_f().

DownloadOptionsFunc()

void DownloadOptionsFunc

(

void *

self

)

Definition at line 3410 of file menu.c.

{
    M_Menu_DownloadOptions_f();
}

Referenced by PlayerConfig_MenuInit().

DrawKeyBindingFunc()

static void DrawKeyBindingFunc ( void *  self )

static

Definition at line 702 of file menu.c.

{
    int keys[2];
    menuaction_s *a = ( menuaction_s * ) self;
 
    M_FindKeysForCommand( bindnames[a->generic.localdata[0]][0], keys);
        
    if (keys[0] == -1)
    {
        Menu_DrawString( a->generic.x + a->generic.parent->x + 16 * vid_hudscale->value, a->generic.y + a->generic.parent->y, "???" );
    }
    else
    {
        int x;
        const char *name;
 
        name = Key_KeynumToString (keys[0]);
 
        Menu_DrawString( a->generic.x + a->generic.parent->x + 16 * vid_hudscale->value, a->generic.y + a->generic.parent->y, name );
 
        x = strlen(name) * 8 * vid_hudscale->value;
 
        if (keys[1] != -1)
        {
            Menu_DrawString( a->generic.x + a->generic.parent->x + 24 * vid_hudscale->value + x, a->generic.y + a->generic.parent->y, "or" );
            Menu_DrawString( a->generic.x + a->generic.parent->x + 48 * vid_hudscale->value + x, a->generic.y + a->generic.parent->y, Key_KeynumToString (keys[1]) );
        }
    }
}

Referenced by Keys_MenuInit().

EasyGameFunc()

static void EasyGameFunc ( void *  data )

static

Definition at line 1924 of file menu.c.

{
    Cvar_ForceSet( "skill", "0" );
    StartGame();
}

Referenced by Game_MenuInit().

FreeFileList()

static void FreeFileList ( char **  list, int  n  )

static

Definition at line 3432 of file menu.c.

{
    int i;
 
    for ( i = 0; i < n; i++ )
    {
        if ( list[i] )
        {
            free( list[i] );
            list[i] = 0;
        }
    }
    free( list );
}

Referenced by PlayerConfig_ScanDirectories().

FreeLookFunc()

static void FreeLookFunc ( void *  unused )

static

Definition at line 1084 of file menu.c.

{
    Cvar_SetValue( "freelook", s_options_freelook_box.curvalue );
}

Referenced by Options_MenuInit().

Game_MenuDraw()

void Game_MenuDraw

(

void

)

Definition at line 2018 of file menu.c.

{
    M_Banner( "m_banner_game" );
    Menu_AdjustCursor( &s_game_menu, 1 );
    Menu_Draw( &s_game_menu );
}

Referenced by M_Menu_Game_f().

Game_MenuInit()

void Game_MenuInit

(

void

)

Definition at line 1957 of file menu.c.

{
    s_game_menu.x = viddef.width * 0.50;
    s_game_menu.nitems = 0;
 
    s_easy_game_action.generic.type = MTYPE_ACTION;
    s_easy_game_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_easy_game_action.generic.x        = 0;
    s_easy_game_action.generic.y        = 0;
    s_easy_game_action.generic.name = "easy";
    s_easy_game_action.generic.callback = EasyGameFunc;
 
    s_medium_game_action.generic.type   = MTYPE_ACTION;
    s_medium_game_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_medium_game_action.generic.x      = 0;
    s_medium_game_action.generic.y      = 10 * vid_hudscale->value;
    s_medium_game_action.generic.name   = "medium";
    s_medium_game_action.generic.callback = MediumGameFunc;
 
    s_hard_game_action.generic.type = MTYPE_ACTION;
    s_hard_game_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_hard_game_action.generic.x        = 0;
    s_hard_game_action.generic.y        = 20 * vid_hudscale->value;
    s_hard_game_action.generic.name = "hard";
    s_hard_game_action.generic.callback = HardGameFunc;
 
    s_blankline.generic.type = MTYPE_SEPARATOR;
 
    s_load_game_action.generic.type = MTYPE_ACTION;
    s_load_game_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_load_game_action.generic.x        = 0;
    s_load_game_action.generic.y        = 40 * vid_hudscale->value;
    s_load_game_action.generic.name = "load game";
    s_load_game_action.generic.callback = LoadGameFunc;
 
    s_save_game_action.generic.type = MTYPE_ACTION;
    s_save_game_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_save_game_action.generic.x        = 0;
    s_save_game_action.generic.y        = 50 * vid_hudscale->value;
    s_save_game_action.generic.name = "save game";
    s_save_game_action.generic.callback = SaveGameFunc;
 
    s_credits_action.generic.type   = MTYPE_ACTION;
    s_credits_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_credits_action.generic.x      = 0;
    s_credits_action.generic.y      = 60 * vid_hudscale->value;
    s_credits_action.generic.name   = "credits";
    s_credits_action.generic.callback = CreditsFunc;
 
    Menu_AddItem( &s_game_menu, ( void * ) &s_easy_game_action );
    Menu_AddItem( &s_game_menu, ( void * ) &s_medium_game_action );
    Menu_AddItem( &s_game_menu, ( void * ) &s_hard_game_action );
    Menu_AddItem( &s_game_menu, ( void * ) &s_blankline );
    Menu_AddItem( &s_game_menu, ( void * ) &s_load_game_action );
    Menu_AddItem( &s_game_menu, ( void * ) &s_save_game_action );
    Menu_AddItem( &s_game_menu, ( void * ) &s_blankline );
    Menu_AddItem( &s_game_menu, ( void * ) &s_credits_action );
 
    Menu_Center( &s_game_menu );
}

Referenced by M_Menu_Game_f().

Game_MenuKey()

const char* Game_MenuKey

(

int

key

)

Definition at line 2025 of file menu.c.

{
    return Default_MenuKey( &s_game_menu, key );
}

Referenced by M_Menu_Game_f().

HandednessCallback()

static void HandednessCallback ( void *  unused )

static

Definition at line 3415 of file menu.c.

{
    Cvar_SetValue( "hand", s_player_handedness_box.curvalue );
}

Referenced by PlayerConfig_MenuInit().

HardGameFunc()

static void HardGameFunc ( void *  data )

static

Definition at line 1936 of file menu.c.

{
    Cvar_ForceSet( "skill", "2" );
    StartGame();
}

Referenced by Game_MenuInit().

IconOfSkinExists()

static qboolean IconOfSkinExists ( char *  skin, char **  pcxfiles, int  npcxfiles  )

static

Definition at line 3447 of file menu.c.

{
    int i;
    char scratch[1024];
 
    strcpy( scratch, skin );
    *strrchr( scratch, '.' ) = 0;
    strcat( scratch, "_i.pcx" );
 
    for ( i = 0; i < npcxfiles; i++ )
    {
        if ( strcmp( pcxfiles[i], scratch ) == 0 )
            return true;
    }
 
    return false;
}

Referenced by PlayerConfig_ScanDirectories().

InvertMouseFunc()

static void InvertMouseFunc ( void *  unused )

static

Definition at line 1144 of file menu.c.

{
    Cvar_SetValue( "m_pitch", -m_pitch->value );
}

Referenced by Options_MenuInit().

JoinNetworkServerFunc()

static void JoinNetworkServerFunc ( void *  unused )

static

Definition at line 524 of file menu.c.

{
    M_Menu_JoinServer_f();
}

Referenced by Multiplayer_MenuInit().

JoinServer_MenuDraw()

void JoinServer_MenuDraw

(

void

)

Definition at line 2353 of file menu.c.

{
    M_Banner( "m_banner_join_server" );
    Menu_Draw( &s_joinserver_menu );
 
    if (search_local_games)
    {
        M_DrawTextBox(8 - 152 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value, 36, 3);
        M_Print(32 - 136 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value + 8 * vid_hudscale->value, "Searching for local servers, this");
        M_Print(32 - 136 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value + 16 * vid_hudscale->value, "could take up to a minute, so");
        M_Print(32 - 136 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value + 24 * vid_hudscale->value, "please be patient.");
 
        // send out info packets
        CL_PingServers_f();
        search_local_games = false;
    }
}

Referenced by M_Menu_JoinServer_f().

JoinServer_MenuInit()

void JoinServer_MenuInit

(

void

)

Definition at line 2302 of file menu.c.

{
    int i;
 
    s_joinserver_menu.x = viddef.width * 0.50 - 120 * vid_hudscale->value;
    s_joinserver_menu.nitems = 0;
 
    s_joinserver_address_book_action.generic.type   = MTYPE_ACTION;
    s_joinserver_address_book_action.generic.name   = "address book";
    s_joinserver_address_book_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_joinserver_address_book_action.generic.x      = 0;
    s_joinserver_address_book_action.generic.y      = 0;
    s_joinserver_address_book_action.generic.callback = AddressBookFunc;
 
    s_joinserver_search_action.generic.type = MTYPE_ACTION;
    s_joinserver_search_action.generic.name = "refresh server list";
    s_joinserver_search_action.generic.flags    = QMF_LEFT_JUSTIFY;
    s_joinserver_search_action.generic.x    = 0;
    s_joinserver_search_action.generic.y    = 10 * vid_hudscale->value;
    s_joinserver_search_action.generic.callback = SearchLocalGamesFunc;
    s_joinserver_search_action.generic.statusbar = "search for servers";
 
    s_joinserver_server_title.generic.type = MTYPE_SEPARATOR;
    s_joinserver_server_title.generic.name = "connect to...";
    s_joinserver_server_title.generic.x    = 80 * vid_hudscale->value;
    s_joinserver_server_title.generic.y    = 30 * vid_hudscale->value;
 
    for ( i = 0; i < MAX_LOCAL_SERVERS; i++ )
    {
        s_joinserver_server_actions[i].generic.type = MTYPE_ACTION;
        strcpy (local_server_names[i], NO_SERVER_STRING);
        s_joinserver_server_actions[i].generic.name = local_server_names[i];
        s_joinserver_server_actions[i].generic.flags    = QMF_LEFT_JUSTIFY;
        s_joinserver_server_actions[i].generic.x        = 0;
        s_joinserver_server_actions[i].generic.y        = (40 + i*10) * vid_hudscale->value;
        s_joinserver_server_actions[i].generic.callback = JoinServerFunc;
        s_joinserver_server_actions[i].generic.statusbar = "press ENTER to connect";
    }
 
    Menu_AddItem( &s_joinserver_menu, &s_joinserver_address_book_action );
    Menu_AddItem( &s_joinserver_menu, &s_joinserver_server_title );
    Menu_AddItem( &s_joinserver_menu, &s_joinserver_search_action );
 
    for ( i = 0; i < 8; i++ )
        Menu_AddItem( &s_joinserver_menu, &s_joinserver_server_actions[i] );
 
    Menu_Center( &s_joinserver_menu );
 
    SearchLocalGames();
}

Referenced by M_Menu_JoinServer_f().

JoinServer_MenuKey()

const char* JoinServer_MenuKey

(

int

key

)

Definition at line 2372 of file menu.c.

{
    return Default_MenuKey( &s_joinserver_menu, key );
}

Referenced by M_Menu_JoinServer_f().

JoinServerFunc()

void JoinServerFunc

(

void *

self

)

Definition at line 2259 of file menu.c.

{
    char    buffer[128];
    int     index;
 
    index = ( menuaction_s * ) self - s_joinserver_server_actions;
 
    if ( Q_stricmp( local_server_names[index], NO_SERVER_STRING ) == 0 )
        return;
 
    if (index >= m_num_servers)
        return;
 
    Com_sprintf (buffer, sizeof(buffer), "connect %s\n", NET_AdrToString (local_server_netadr[index]));
    Cbuf_AddText (buffer);
    M_ForceMenuOff ();
}

Referenced by JoinServer_MenuInit().

JoystickFunc()

static void JoystickFunc ( void *  unused )

static

Definition at line 1069 of file menu.c.

{
    Cvar_SetValue( "in_joystick", s_options_joystick_box.curvalue );
}

Referenced by Options_MenuInit().

KeyBindingFunc()

static void KeyBindingFunc ( void *  self )

static

Definition at line 732 of file menu.c.

{
    menuaction_s *a = ( menuaction_s * ) self;
    int keys[2];
 
    M_FindKeysForCommand( bindnames[a->generic.localdata[0]][0], keys );
 
    if (keys[1] != -1)
        M_UnbindCommand( bindnames[a->generic.localdata[0]][0]);
 
    bind_grab = true;
 
    Menu_SetStatusBar( &s_keys_menu, "press a key or button for this action" );
}

Referenced by Keys_MenuKey().

KeyCursorDrawFunc()

static void KeyCursorDrawFunc ( menuframework_s *  menu )

static

Definition at line 694 of file menu.c.

{
    if ( bind_grab )
        re.DrawChar( menu->x, menu->y + menu->cursor * 9 * vid_hudscale->value, '=' );
    else
        re.DrawChar( menu->x, menu->y + menu->cursor * 9 * vid_hudscale->value, 12 + ( ( int ) ( Sys_Milliseconds() / 250 ) & 1 ) );
}

Referenced by Keys_MenuInit().

Keys_MenuDraw()

static void Keys_MenuDraw ( void  )

static

Definition at line 988 of file menu.c.

{
    Menu_AdjustCursor( &s_keys_menu, 1 );
    Menu_Draw( &s_keys_menu );
}

Referenced by M_Menu_Keys_f().

Keys_MenuInit()

static void Keys_MenuInit ( void  )

static

Definition at line 747 of file menu.c.

{
    int y = 0;
    int i = 0;
 
    s_keys_menu.x = viddef.width * 0.50;
    s_keys_menu.nitems = 0;
    s_keys_menu.cursordraw = KeyCursorDrawFunc;
 
    s_keys_attack_action.generic.type   = MTYPE_ACTION;
    s_keys_attack_action.generic.flags  = QMF_GRAYED;
    s_keys_attack_action.generic.x      = 0;
    s_keys_attack_action.generic.y      = y * vid_hudscale->value;
    s_keys_attack_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_attack_action.generic.localdata[0] = i;
    s_keys_attack_action.generic.name   = bindnames[s_keys_attack_action.generic.localdata[0]][1];
 
    s_keys_change_weapon_action.generic.type    = MTYPE_ACTION;
    s_keys_change_weapon_action.generic.flags  = QMF_GRAYED;
    s_keys_change_weapon_action.generic.x       = 0;
    s_keys_change_weapon_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_change_weapon_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_change_weapon_action.generic.localdata[0] = ++i;
    s_keys_change_weapon_action.generic.name    = bindnames[s_keys_change_weapon_action.generic.localdata[0]][1];
 
    s_keys_change_weapon_prev_action.generic.type   = MTYPE_ACTION;
    s_keys_change_weapon_prev_action.generic.flags  = QMF_GRAYED;
    s_keys_change_weapon_prev_action.generic.x      = 0;
    s_keys_change_weapon_prev_action.generic.y      = y += 9 * vid_hudscale->value;
    s_keys_change_weapon_prev_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_change_weapon_prev_action.generic.localdata[0] = ++i;
    s_keys_change_weapon_prev_action.generic.name   = bindnames[s_keys_change_weapon_prev_action.generic.localdata[0]][1];
 
    s_keys_change_weapon_last_action.generic.type   = MTYPE_ACTION;
    s_keys_change_weapon_last_action.generic.flags  = QMF_GRAYED;
    s_keys_change_weapon_last_action.generic.x      = 0;
    s_keys_change_weapon_last_action.generic.y      = y += 9 * vid_hudscale->value;
    s_keys_change_weapon_last_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_change_weapon_last_action.generic.localdata[0] = ++i;
    s_keys_change_weapon_last_action.generic.name   = bindnames[s_keys_change_weapon_last_action.generic.localdata[0]][1];
 
    s_keys_walk_forward_action.generic.type = MTYPE_ACTION;
    s_keys_walk_forward_action.generic.flags  = QMF_GRAYED;
    s_keys_walk_forward_action.generic.x        = 0;
    s_keys_walk_forward_action.generic.y        = y += 9 * vid_hudscale->value;
    s_keys_walk_forward_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_walk_forward_action.generic.localdata[0] = ++i;
    s_keys_walk_forward_action.generic.name = bindnames[s_keys_walk_forward_action.generic.localdata[0]][1];
 
    s_keys_backpedal_action.generic.type    = MTYPE_ACTION;
    s_keys_backpedal_action.generic.flags  = QMF_GRAYED;
    s_keys_backpedal_action.generic.x       = 0;
    s_keys_backpedal_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_backpedal_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_backpedal_action.generic.localdata[0] = ++i;
    s_keys_backpedal_action.generic.name    = bindnames[s_keys_backpedal_action.generic.localdata[0]][1];
 
    s_keys_turn_left_action.generic.type    = MTYPE_ACTION;
    s_keys_turn_left_action.generic.flags  = QMF_GRAYED;
    s_keys_turn_left_action.generic.x       = 0;
    s_keys_turn_left_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_turn_left_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_turn_left_action.generic.localdata[0] = ++i;
    s_keys_turn_left_action.generic.name    = bindnames[s_keys_turn_left_action.generic.localdata[0]][1];
 
    s_keys_turn_right_action.generic.type   = MTYPE_ACTION;
    s_keys_turn_right_action.generic.flags  = QMF_GRAYED;
    s_keys_turn_right_action.generic.x      = 0;
    s_keys_turn_right_action.generic.y      = y += 9 * vid_hudscale->value;
    s_keys_turn_right_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_turn_right_action.generic.localdata[0] = ++i;
    s_keys_turn_right_action.generic.name   = bindnames[s_keys_turn_right_action.generic.localdata[0]][1];
 
    s_keys_run_action.generic.type  = MTYPE_ACTION;
    s_keys_run_action.generic.flags  = QMF_GRAYED;
    s_keys_run_action.generic.x     = 0;
    s_keys_run_action.generic.y     = y += 9 * vid_hudscale->value;
    s_keys_run_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_run_action.generic.localdata[0] = ++i;
    s_keys_run_action.generic.name  = bindnames[s_keys_run_action.generic.localdata[0]][1];
 
    s_keys_step_left_action.generic.type    = MTYPE_ACTION;
    s_keys_step_left_action.generic.flags  = QMF_GRAYED;
    s_keys_step_left_action.generic.x       = 0;
    s_keys_step_left_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_step_left_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_step_left_action.generic.localdata[0] = ++i;
    s_keys_step_left_action.generic.name    = bindnames[s_keys_step_left_action.generic.localdata[0]][1];
 
    s_keys_step_right_action.generic.type   = MTYPE_ACTION;
    s_keys_step_right_action.generic.flags  = QMF_GRAYED;
    s_keys_step_right_action.generic.x      = 0;
    s_keys_step_right_action.generic.y      = y += 9 * vid_hudscale->value;
    s_keys_step_right_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_step_right_action.generic.localdata[0] = ++i;
    s_keys_step_right_action.generic.name   = bindnames[s_keys_step_right_action.generic.localdata[0]][1];
 
    s_keys_sidestep_action.generic.type = MTYPE_ACTION;
    s_keys_sidestep_action.generic.flags  = QMF_GRAYED;
    s_keys_sidestep_action.generic.x        = 0;
    s_keys_sidestep_action.generic.y        = y += 9 * vid_hudscale->value;
    s_keys_sidestep_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_sidestep_action.generic.localdata[0] = ++i;
    s_keys_sidestep_action.generic.name = bindnames[s_keys_sidestep_action.generic.localdata[0]][1];
 
    s_keys_look_up_action.generic.type  = MTYPE_ACTION;
    s_keys_look_up_action.generic.flags  = QMF_GRAYED;
    s_keys_look_up_action.generic.x     = 0;
    s_keys_look_up_action.generic.y     = y += 9 * vid_hudscale->value;
    s_keys_look_up_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_look_up_action.generic.localdata[0] = ++i;
    s_keys_look_up_action.generic.name  = bindnames[s_keys_look_up_action.generic.localdata[0]][1];
 
    s_keys_look_down_action.generic.type    = MTYPE_ACTION;
    s_keys_look_down_action.generic.flags  = QMF_GRAYED;
    s_keys_look_down_action.generic.x       = 0;
    s_keys_look_down_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_look_down_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_look_down_action.generic.localdata[0] = ++i;
    s_keys_look_down_action.generic.name    = bindnames[s_keys_look_down_action.generic.localdata[0]][1];
 
    s_keys_center_view_action.generic.type  = MTYPE_ACTION;
    s_keys_center_view_action.generic.flags  = QMF_GRAYED;
    s_keys_center_view_action.generic.x     = 0;
    s_keys_center_view_action.generic.y     = y += 9 * vid_hudscale->value;
    s_keys_center_view_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_center_view_action.generic.localdata[0] = ++i;
    s_keys_center_view_action.generic.name  = bindnames[s_keys_center_view_action.generic.localdata[0]][1];
 
    s_keys_mouse_look_action.generic.type   = MTYPE_ACTION;
    s_keys_mouse_look_action.generic.flags  = QMF_GRAYED;
    s_keys_mouse_look_action.generic.x      = 0;
    s_keys_mouse_look_action.generic.y      = y += 9 * vid_hudscale->value;
    s_keys_mouse_look_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_mouse_look_action.generic.localdata[0] = ++i;
    s_keys_mouse_look_action.generic.name   = bindnames[s_keys_mouse_look_action.generic.localdata[0]][1];
 
    s_keys_keyboard_look_action.generic.type    = MTYPE_ACTION;
    s_keys_keyboard_look_action.generic.flags  = QMF_GRAYED;
    s_keys_keyboard_look_action.generic.x       = 0;
    s_keys_keyboard_look_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_keyboard_look_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_keyboard_look_action.generic.localdata[0] = ++i;
    s_keys_keyboard_look_action.generic.name    = bindnames[s_keys_keyboard_look_action.generic.localdata[0]][1];
 
    s_keys_move_up_action.generic.type  = MTYPE_ACTION;
    s_keys_move_up_action.generic.flags  = QMF_GRAYED;
    s_keys_move_up_action.generic.x     = 0;
    s_keys_move_up_action.generic.y     = y += 9 * vid_hudscale->value;
    s_keys_move_up_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_move_up_action.generic.localdata[0] = ++i;
    s_keys_move_up_action.generic.name  = bindnames[s_keys_move_up_action.generic.localdata[0]][1];
 
    s_keys_move_down_action.generic.type    = MTYPE_ACTION;
    s_keys_move_down_action.generic.flags  = QMF_GRAYED;
    s_keys_move_down_action.generic.x       = 0;
    s_keys_move_down_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_move_down_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_move_down_action.generic.localdata[0] = ++i;
    s_keys_move_down_action.generic.name    = bindnames[s_keys_move_down_action.generic.localdata[0]][1];
 
    s_keys_inventory_action.generic.type    = MTYPE_ACTION;
    s_keys_inventory_action.generic.flags  = QMF_GRAYED;
    s_keys_inventory_action.generic.x       = 0;
    s_keys_inventory_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_inventory_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_inventory_action.generic.localdata[0] = ++i;
    s_keys_inventory_action.generic.name    = bindnames[s_keys_inventory_action.generic.localdata[0]][1];
 
    s_keys_inv_use_action.generic.type  = MTYPE_ACTION;
    s_keys_inv_use_action.generic.flags  = QMF_GRAYED;
    s_keys_inv_use_action.generic.x     = 0;
    s_keys_inv_use_action.generic.y     = y += 9 * vid_hudscale->value;
    s_keys_inv_use_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_inv_use_action.generic.localdata[0] = ++i;
    s_keys_inv_use_action.generic.name  = bindnames[s_keys_inv_use_action.generic.localdata[0]][1];
 
    s_keys_inv_drop_action.generic.type = MTYPE_ACTION;
    s_keys_inv_drop_action.generic.flags  = QMF_GRAYED;
    s_keys_inv_drop_action.generic.x        = 0;
    s_keys_inv_drop_action.generic.y        = y += 9 * vid_hudscale->value;
    s_keys_inv_drop_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_inv_drop_action.generic.localdata[0] = ++i;
    s_keys_inv_drop_action.generic.name = bindnames[s_keys_inv_drop_action.generic.localdata[0]][1];
 
    s_keys_inv_prev_action.generic.type = MTYPE_ACTION;
    s_keys_inv_prev_action.generic.flags  = QMF_GRAYED;
    s_keys_inv_prev_action.generic.x        = 0;
    s_keys_inv_prev_action.generic.y        = y += 9 * vid_hudscale->value;
    s_keys_inv_prev_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_inv_prev_action.generic.localdata[0] = ++i;
    s_keys_inv_prev_action.generic.name = bindnames[s_keys_inv_prev_action.generic.localdata[0]][1];
 
    s_keys_inv_next_action.generic.type = MTYPE_ACTION;
    s_keys_inv_next_action.generic.flags  = QMF_GRAYED;
    s_keys_inv_next_action.generic.x        = 0;
    s_keys_inv_next_action.generic.y        = y += 9 * vid_hudscale->value;
    s_keys_inv_next_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_inv_next_action.generic.localdata[0] = ++i;
    s_keys_inv_next_action.generic.name = bindnames[s_keys_inv_next_action.generic.localdata[0]][1];
 
    s_keys_help_computer_action.generic.type    = MTYPE_ACTION;
    s_keys_help_computer_action.generic.flags  = QMF_GRAYED;
    s_keys_help_computer_action.generic.x       = 0;
    s_keys_help_computer_action.generic.y       = y += 9 * vid_hudscale->value;
    s_keys_help_computer_action.generic.ownerdraw = DrawKeyBindingFunc;
    s_keys_help_computer_action.generic.localdata[0] = ++i;
    s_keys_help_computer_action.generic.name    = bindnames[s_keys_help_computer_action.generic.localdata[0]][1];
 
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_attack_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_change_weapon_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_change_weapon_prev_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_change_weapon_last_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_walk_forward_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_backpedal_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_turn_left_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_turn_right_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_run_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_step_left_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_step_right_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_sidestep_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_look_up_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_look_down_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_center_view_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_mouse_look_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_keyboard_look_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_move_up_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_move_down_action );
 
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_inventory_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_inv_use_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_inv_drop_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_inv_prev_action );
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_inv_next_action );
 
    Menu_AddItem( &s_keys_menu, ( void * ) &s_keys_help_computer_action );
    
    Menu_SetStatusBar( &s_keys_menu, "enter to change, backspace to clear" );
    Menu_Center( &s_keys_menu );
}

Referenced by M_Menu_Keys_f().

Keys_MenuKey()

static const char* Keys_MenuKey ( int  key )

static

Definition at line 994 of file menu.c.

{
    menuaction_s *item = ( menuaction_s * ) Menu_ItemAtCursor( &s_keys_menu );
 
    if ( bind_grab )
    {   
        if ( key != K_ESCAPE && key != '`' )
        {
            char cmd[1024];
 
            Com_sprintf (cmd, sizeof(cmd), "bind \"%s\" \"%s\"\n", Key_KeynumToString(key), bindnames[item->generic.localdata[0]][0]);
            Cbuf_InsertText (cmd);
        }
        
        Menu_SetStatusBar( &s_keys_menu, "enter to change, backspace to clear" );
        bind_grab = false;
        return menu_out_sound;
    }
 
    switch ( key )
    {
    case K_KP_ENTER:
    case K_ENTER:
        KeyBindingFunc( item );
        return menu_in_sound;
    case K_BACKSPACE:       // delete bindings
    case K_DEL:             // delete bindings
    case K_KP_DEL:
        M_UnbindCommand( bindnames[item->generic.localdata[0]][0] );
        return menu_out_sound;
    default:
        return Default_MenuKey( &s_keys_menu, key );
    }
}

Referenced by M_Menu_Keys_f().

LoadGame_MenuDraw()

void LoadGame_MenuDraw

(

void

)

Definition at line 2116 of file menu.c.

{
    M_Banner( "m_banner_load_game" );
//  Menu_AdjustCursor( &s_loadgame_menu, 1 );
    Menu_Draw( &s_loadgame_menu );
}

Referenced by M_Menu_LoadGame_f().

LoadGame_MenuInit()

void LoadGame_MenuInit

(

void

)

Definition at line 2088 of file menu.c.

{
    int i;
 
    s_loadgame_menu.x = viddef.width / 2 - 120 * vid_hudscale->value;
    s_loadgame_menu.y = viddef.height / 2 - 58 * vid_hudscale->value;
    s_loadgame_menu.nitems = 0;
 
    Create_Savestrings();
 
    for ( i = 0; i < MAX_SAVEGAMES; i++ )
    {
        s_loadgame_actions[i].generic.name          = m_savestrings[i];
        s_loadgame_actions[i].generic.flags         = QMF_LEFT_JUSTIFY;
        s_loadgame_actions[i].generic.localdata[0]  = i;
        s_loadgame_actions[i].generic.callback      = LoadGameCallback;
 
        s_loadgame_actions[i].generic.x = 0;
        s_loadgame_actions[i].generic.y = ( i ) * 10 * vid_hudscale->value;
        if (i>0)    // separate from autosave
            s_loadgame_actions[i].generic.y += 10 * vid_hudscale->value;
 
        s_loadgame_actions[i].generic.type = MTYPE_ACTION;
 
        Menu_AddItem( &s_loadgame_menu, &s_loadgame_actions[i] );
    }
}

Referenced by M_Menu_LoadGame_f().

LoadGame_MenuKey()

const char* LoadGame_MenuKey

(

int

key

)

Definition at line 2123 of file menu.c.

{
    if ( key == K_ESCAPE || key == K_ENTER )
    {
        s_savegame_menu.cursor = s_loadgame_menu.cursor - 1;
        if ( s_savegame_menu.cursor < 0 )
            s_savegame_menu.cursor = 0;
    }
    return Default_MenuKey( &s_loadgame_menu, key );
}

Referenced by M_Menu_LoadGame_f().

LoadGameCallback()

void LoadGameCallback

(

void *

self

)

Definition at line 2079 of file menu.c.

{
    menuaction_s *a = ( menuaction_s * ) self;
 
    if ( m_savevalid[ a->generic.localdata[0] ] )
        Cbuf_AddText (va("load save%i\n",  a->generic.localdata[0] ) );
    M_ForceMenuOff ();
}

Referenced by LoadGame_MenuInit().

LoadGameFunc()

static void LoadGameFunc ( void *  unused )

static

Definition at line 1942 of file menu.c.

{
    M_Menu_LoadGame_f ();
}

Referenced by Game_MenuInit().

LookspringFunc()

static void LookspringFunc ( void *  unused )

static

Definition at line 1149 of file menu.c.

{
    Cvar_SetValue( "lookspring", !lookspring->value );
}

Referenced by Options_MenuInit().

LookstrafeFunc()

static void LookstrafeFunc ( void *  unused )

static

Definition at line 1154 of file menu.c.

{
    Cvar_SetValue( "lookstrafe", !lookstrafe->value );
}

Referenced by Options_MenuInit().

M_AddToServerList()

void M_AddToServerList	(	netadr_t	adr,
		char *	info
	)

Definition at line 2239 of file menu.c.

{
    int     i;
 
    if (m_num_servers == MAX_LOCAL_SERVERS)
        return;
    while ( *info == ' ' )
        info++;
 
    // ignore if duplicated
    for (i=0 ; i<m_num_servers ; i++)
        if (!strcmp(info, local_server_names[i]))
            return;
 
    local_server_netadr[m_num_servers] = adr;
    strncpy (local_server_names[m_num_servers], info, sizeof(local_server_names[0])-1);
    m_num_servers++;
}

Referenced by CL_ParseStatusMessage().

M_Banner()

static void M_Banner ( char *  name )

static

Definition at line 81 of file menu.c.

{
    int w, h;
 
    re.DrawGetPicSize (&w, &h, name );
    re.DrawPic( viddef.width / 2 - w / 2, viddef.height / 2 - 110 * vid_hudscale->value, name );
}

Referenced by AddressBook_MenuDraw(), Game_MenuDraw(), JoinServer_MenuDraw(), LoadGame_MenuDraw(), Multiplayer_MenuDraw(), Options_MenuDraw(), and SaveGame_MenuDraw().

M_Credits_Key()

const char* M_Credits_Key

(

int

key

)

Definition at line 1821 of file menu.c.

{
    switch (key)
    {
    case K_ESCAPE:
        if (creditsBuffer)
            FS_FreeFile (creditsBuffer);
        M_PopMenu ();
        break;
    }
 
    return menu_out_sound;
 
}

Referenced by M_Menu_Credits_f().

M_Credits_MenuDraw()

void M_Credits_MenuDraw

(

void

)

Definition at line 1778 of file menu.c.

{
    int i, y;
 
    /*
    ** draw the credits
    */
    for ( i = 0, y = viddef.height - ( ( cls.realtime - credits_start_time ) / 40.0F ); credits[i] && y < viddef.height; y += 10 * vid_hudscale->value, i++ )
    {
        int j, stringoffset = 0;
        int bold = false;
 
        if ( y <= -8 )
            continue;
 
        if ( credits[i][0] == '+' )
        {
            bold = true;
            stringoffset = 1;
        }
        else
        {
            bold = false;
            stringoffset = 0;
        }
 
        for ( j = 0; credits[i][j+stringoffset]; j++ )
        {
            int x;
 
            x = ( viddef.width - strlen( credits[i] ) * 8 * vid_hudscale->value - stringoffset * 8 * vid_hudscale->value) / 2 + ( j + stringoffset ) * 8 * vid_hudscale->value;
 
            if ( bold )
                re.DrawChar( x, y, credits[i][j+stringoffset] + 128 );
            else
                re.DrawChar( x, y, credits[i][j+stringoffset] );
        }
    }
 
    if ( y < 0 )
        credits_start_time = cls.realtime;
}

Referenced by M_Menu_Credits_f().

M_Draw()

void M_Draw

(

void

)

Definition at line 3999 of file menu.c.

{
    if (cls.key_dest != key_menu)
        return;
 
    // repaint everything next frame
    SCR_DirtyScreen ();
 
    // dim everything behind it down
    if (cl.cinematictime > 0)
        re.DrawFill (0,0,viddef.width, viddef.height, 0);
    else
        re.DrawFadeScreen ();
 
    m_drawfunc ();
 
    // delay playing the enter sound until after the
    // menu has been drawn, to avoid delay while
    // caching images
    if (m_entersound)
    {
        S_StartLocalSound( menu_in_sound );
        m_entersound = false;
    }
}

Referenced by SCR_UpdateScreen().

M_DrawCharacter()

void M_DrawCharacter	(	int	cx,
		int	cy,
		int	num
	)

Definition at line 275 of file menu.c.

{
    re.DrawChar ( cx + ((viddef.width - 320)>>1), cy + ((viddef.height - 240)>>1), num);
}

Referenced by M_DrawTextBox(), M_Print(), and M_PrintWhite().

M_DrawCursor()

void M_DrawCursor	(	int	x,
		int	y,
		int	f
	)

Definition at line 315 of file menu.c.

{
    char    cursorname[80];
    static qboolean cached;
 
    if ( !cached )
    {
        int i;
 
        for ( i = 0; i < NUM_CURSOR_FRAMES; i++ )
        {
            Com_sprintf( cursorname, sizeof( cursorname ), "m_cursor%d", i );
 
            re.RegisterPic( cursorname );
        }
        cached = true;
    }
 
    Com_sprintf( cursorname, sizeof(cursorname), "m_cursor%d", f );
    re.DrawPic( x, y, cursorname );
}

Referenced by M_Main_Draw().

M_DrawPic()

void M_DrawPic	(	int	x,
		int	y,
		char *	pic
	)

Definition at line 300 of file menu.c.

{
    re.DrawPic (x + ((viddef.width - 320)>>1), y + ((viddef.height - 240)>>1), pic);
}

M_DrawTextBox()

void M_DrawTextBox	(	int	x,
		int	y,
		int	width,
		int	lines
	)

Definition at line 337 of file menu.c.

{
    int     cx, cy;
    int     n;
 
    // draw left side
    cx = x;
    cy = y;
    M_DrawCharacter (cx, cy, 1);
    for (n = 0; n < lines; n++)
    {
        cy += 8 * vid_hudscale->value;
        M_DrawCharacter (cx, cy, 4);
    }
    M_DrawCharacter (cx, cy + 8 * vid_hudscale->value, 7);
 
    // draw middle
    cx += 8 * vid_hudscale->value;
    while (width > 0)
    {
        cy = y;
        M_DrawCharacter (cx, cy, 2);
        for (n = 0; n < lines; n++)
        {
            cy += 8 * vid_hudscale->value;
            M_DrawCharacter (cx, cy, 5);
        }
        M_DrawCharacter (cx, cy + 8 * vid_hudscale->value, 8);
        width -= 1;
        cx += 8 * vid_hudscale->value;
    }
 
    // draw right side
    cy = y;
    M_DrawCharacter (cx, cy, 3);
    for (n = 0; n < lines; n++)
    {
        cy += 8 * vid_hudscale->value;
        M_DrawCharacter (cx, cy, 6);
    }
    M_DrawCharacter (cx, cy + 8 * vid_hudscale->value, 9);
}

Referenced by JoinServer_MenuDraw(), Options_MenuDraw(), and PlayerConfig_MenuDraw().

M_FindKeysForCommand()

static void M_FindKeysForCommand ( char *  command, int *  twokeys  )

static

Definition at line 668 of file menu.c.

{
    int     count;
    int     j;
    int     l;
    char    *b;
 
    twokeys[0] = twokeys[1] = -1;
    l = (int)strlen(command);
    count = 0;
 
    for (j=0 ; j<256 ; j++)
    {
        b = keybindings[j];
        if (!b)
            continue;
        if (!strncmp (b, command, l) )
        {
            twokeys[count] = j;
            count++;
            if (count == 2)
                break;
        }
    }
}

Referenced by DrawKeyBindingFunc(), and KeyBindingFunc().

M_ForceMenuOff()

void M_ForceMenuOff

(

void

)

Definition at line 123 of file menu.c.

{
    m_drawfunc = 0;
    m_keyfunc = 0;
    cls.key_dest = key_game;
    m_menudepth = 0;
    Key_ClearStates ();
    Cvar_Set ("paused", "0");
}

Referenced by ApplyChanges(), CL_Disconnect(), Con_ToggleChat_f(), Con_ToggleConsole_f(), ConsoleFunc(), JoinServerFunc(), LoadGameCallback(), M_PopMenu(), SaveGameCallback(), StartGame(), and StartServerActionFunc().

M_Init()

void M_Init

(

void

)

Definition at line 3973 of file menu.c.

{
    Cmd_AddCommand ("menu_main", M_Menu_Main_f);
    Cmd_AddCommand ("menu_game", M_Menu_Game_f);
        Cmd_AddCommand ("menu_loadgame", M_Menu_LoadGame_f);
        Cmd_AddCommand ("menu_savegame", M_Menu_SaveGame_f);
        Cmd_AddCommand ("menu_joinserver", M_Menu_JoinServer_f);
            Cmd_AddCommand ("menu_addressbook", M_Menu_AddressBook_f);
        Cmd_AddCommand ("menu_startserver", M_Menu_StartServer_f);
            Cmd_AddCommand ("menu_dmoptions", M_Menu_DMOptions_f);
        Cmd_AddCommand ("menu_playerconfig", M_Menu_PlayerConfig_f);
            Cmd_AddCommand ("menu_downloadoptions", M_Menu_DownloadOptions_f);
        Cmd_AddCommand ("menu_credits", M_Menu_Credits_f );
    Cmd_AddCommand ("menu_multiplayer", M_Menu_Multiplayer_f );
    Cmd_AddCommand ("menu_video", M_Menu_Video_f);
    Cmd_AddCommand ("menu_options", M_Menu_Options_f);
        Cmd_AddCommand ("menu_keys", M_Menu_Keys_f);
    Cmd_AddCommand ("menu_quit", M_Menu_Quit_f);
}

Referenced by CL_Init().

M_Keydown()

void M_Keydown

(

int

key

)

Definition at line 4031 of file menu.c.

{
    const char *s;
 
    if (m_keyfunc)
        if ( ( s = m_keyfunc( key ) ) != 0 )
            S_StartLocalSound( ( char * ) s );
}

Referenced by Key_Event().

M_Main_Draw()

void M_Main_Draw

(

void

)

Definition at line 391 of file menu.c.

{
    int i;
    int w, h;
    int ystart;
    int xoffset;
    int widest = -1;
    int totalheight = 0;
    char litname[80];
    char *names[] =
    {
        "m_main_game",
        "m_main_multiplayer",
        "m_main_options",
        "m_main_video",
        "m_main_quit",
        0
    };
 
    for ( i = 0; names[i] != 0; i++ )
    {
        re.DrawGetPicSize( &w, &h, names[i] );
 
        if ( w > widest )
            widest = w;
        totalheight += ( h + 12 );
    }
 
    ystart = ( viddef.height / 2 - 110 * vid_hudscale->value);
    xoffset = ( viddef.width - widest + 70 * vid_hudscale->value) / 2;
 
    for ( i = 0; names[i] != 0; i++ )
    {
        if ( i != m_main_cursor )
            re.DrawPic( xoffset, ystart + (i * 40 + 13)*vid_hudscale->value, names[i] );
    }
    strcpy( litname, names[m_main_cursor] );
    strcat( litname, "_sel" );
    re.DrawPic( xoffset, ystart + (m_main_cursor * 40 + 13) * vid_hudscale->value, litname );
 
    M_DrawCursor( xoffset - 25 * vid_hudscale->value, ystart + (m_main_cursor * 40 + 11)*vid_hudscale->value, (int)(cls.realtime / 100)%NUM_CURSOR_FRAMES );
 
    re.DrawGetPicSize( &w, &h, "m_main_plaque" );
    re.DrawPic( xoffset - 30 * vid_hudscale->value - w, ystart, "m_main_plaque" );
 
    re.DrawPic( xoffset - 30 * vid_hudscale->value - w, ystart + h + 5*vid_hudscale->value, "m_main_logo" );
}

Referenced by M_Menu_Main_f().

M_Main_Key()

const char* M_Main_Key

(

int

key

)

Definition at line 440 of file menu.c.

{
    const char *sound = menu_move_sound;
 
    switch (key)
    {
    case K_ESCAPE:
        M_PopMenu ();
        break;
 
    case K_KP_DOWNARROW:
    case K_DOWNARROW:
        if (++m_main_cursor >= MAIN_ITEMS)
            m_main_cursor = 0;
        return sound;
 
    case K_KP_UPARROW:
    case K_UPARROW:
        if (--m_main_cursor < 0)
            m_main_cursor = MAIN_ITEMS - 1;
        return sound;
 
    case K_KP_ENTER:
    case K_ENTER:
        m_entersound = true;
 
        switch (m_main_cursor)
        {
        case 0:
            M_Menu_Game_f ();
            break;
 
        case 1:
            M_Menu_Multiplayer_f();
            break;
 
        case 2:
            M_Menu_Options_f ();
            break;
 
        case 3:
            M_Menu_Video_f ();
            break;
 
        case 4:
            M_Menu_Quit_f ();
            break;
        }
    }
 
    return NULL;
}

Referenced by M_Menu_Main_f().

M_Menu_AddressBook_f()

void M_Menu_AddressBook_f

(

void

)

Definition at line 3366 of file menu.c.

{
    AddressBook_MenuInit();
    M_PushMenu( AddressBook_MenuDraw, AddressBook_MenuKey );
}

Referenced by AddressBookFunc(), and M_Init().

M_Menu_Credits()

void M_Menu_Credits

(

void

)

M_Menu_Credits_f()

void M_Menu_Credits_f

(

void

)

Definition at line 1838 of file menu.c.

{
    int     n;
    int     count;
    char    *p;
    int     isdeveloper = 0;
 
    creditsBuffer = NULL;
    count = FS_LoadFile ("credits", (void **)&creditsBuffer);
    if (count != -1)
    {
        p = creditsBuffer;
        for (n = 0; n < 255; n++)
        {
            creditsIndex[n] = p;
            while (*p != '\r' && *p != '\n')
            {
                p++;
                if (--count == 0)
                    break;
            }
            if (*p == '\r')
            {
                *p++ = 0;
                if (--count == 0)
                    break;
            }
            *p++ = 0;
            if (--count == 0)
                break;
        }
        creditsIndex[++n] = 0;
        credits = (const char**)creditsIndex;
    }
    else
    {
        isdeveloper = Developer_searchpath (1);
        
        if (isdeveloper == 1)           // xatrix
            credits = xatcredits;
        else if (isdeveloper == 2)      // ROGUE
            credits = roguecredits;
        else
        {
            credits = idcredits;    
        }
 
    }
 
    credits_start_time = cls.realtime;
    M_PushMenu( M_Credits_MenuDraw, M_Credits_Key);
}

Referenced by CreditsFunc(), and M_Init().

M_Menu_DMOptions_f()

void M_Menu_DMOptions_f

(

void

)

Definition at line 3162 of file menu.c.

{
    DMOptions_MenuInit();
    M_PushMenu( DMOptions_MenuDraw, DMOptions_MenuKey );
}

Referenced by DMOptionsFunc(), and M_Init().

M_Menu_DownloadOptions_f()

void M_Menu_DownloadOptions_f

(

void

)

Definition at line 3294 of file menu.c.

{
    DownloadOptions_MenuInit();
    M_PushMenu( DownloadOptions_MenuDraw, DownloadOptions_MenuKey );
}

Referenced by DownloadOptionsFunc(), and M_Init().

M_Menu_Game_f()

void M_Menu_Game_f

(

void

)

Definition at line 2030 of file menu.c.

{
    Game_MenuInit();
    M_PushMenu( Game_MenuDraw, Game_MenuKey );
    m_game_cursor = 1;
}

Referenced by M_Init(), and M_Main_Key().

M_Menu_JoinServer_f()

void M_Menu_JoinServer_f

(

void

)

Definition at line 2377 of file menu.c.

{
    JoinServer_MenuInit();
    M_PushMenu( JoinServer_MenuDraw, JoinServer_MenuKey );
}

Referenced by JoinNetworkServerFunc(), and M_Init().

M_Menu_Keys_f()

void M_Menu_Keys_f

(

void

)

Definition at line 1029 of file menu.c.

{
    Keys_MenuInit();
    M_PushMenu( Keys_MenuDraw, Keys_MenuKey );
}

Referenced by CustomizeControlsFunc(), and M_Init().

M_Menu_LoadGame_f()

void M_Menu_LoadGame_f

(

void

)

Definition at line 2134 of file menu.c.

{
    LoadGame_MenuInit();
    M_PushMenu( LoadGame_MenuDraw, LoadGame_MenuKey );
}

Referenced by LoadGameFunc(), and M_Init().

M_Menu_Main_f()

void M_Menu_Main_f

(

void

)

Definition at line 494 of file menu.c.

{
    M_PushMenu (M_Main_Draw, M_Main_Key);
}

Referenced by Key_Event(), and M_Init().

M_Menu_Multiplayer_f()

void M_Menu_Multiplayer_f

(

void

)

Definition at line 574 of file menu.c.

{
    Multiplayer_MenuInit();
    M_PushMenu( Multiplayer_MenuDraw, Multiplayer_MenuKey );
}

Referenced by M_Init(), and M_Main_Key().

M_Menu_Options_f()

void M_Menu_Options_f

(

void

)

Definition at line 1400 of file menu.c.

{
    Options_MenuInit();
    M_PushMenu ( Options_MenuDraw, Options_MenuKey );
}

Referenced by M_Init(), and M_Main_Key().

M_Menu_PlayerConfig_f()

void M_Menu_PlayerConfig_f

(

void

)

Definition at line 3886 of file menu.c.

{
    if (!PlayerConfig_MenuInit())
    {
        Menu_SetStatusBar( &s_multiplayer_menu, "No valid player models found" );
        return;
    }
    Menu_SetStatusBar( &s_multiplayer_menu, NULL );
    M_PushMenu( PlayerConfig_MenuDraw, PlayerConfig_MenuKey );
}

Referenced by M_Init(), and PlayerSetupFunc().

M_Menu_Quit_f()

void M_Menu_Quit_f

(

void

)

Definition at line 3957 of file menu.c.

{
    M_PushMenu (M_Quit_Draw, M_Quit_Key);
}

Referenced by M_Init(), and M_Main_Key().

M_Menu_SaveGame_f()

void M_Menu_SaveGame_f

(

void

)

Definition at line 2204 of file menu.c.

{
    if (!Com_ServerState())
        return;     // not playing a game
 
    SaveGame_MenuInit();
    M_PushMenu( SaveGame_MenuDraw, SaveGame_MenuKey );
    Create_Savestrings ();
}

Referenced by M_Init(), and SaveGameFunc().

M_Menu_StartServer_f()

void M_Menu_StartServer_f

(

void

)

Definition at line 2759 of file menu.c.

{
    StartServer_MenuInit();
    M_PushMenu( StartServer_MenuDraw, StartServer_MenuKey );
}

Referenced by M_Init(), and StartNetworkServerFunc().

M_Menu_Video_f()

void M_Menu_Video_f

(

void

)

Definition at line 1414 of file menu.c.

{
    VID_MenuInit();
    M_PushMenu( VID_MenuDraw, VID_MenuKey );
}

Referenced by M_Init(), and M_Main_Key().

M_PopMenu()

void M_PopMenu

(

void

)

Definition at line 133 of file menu.c.

{
    S_StartLocalSound( menu_out_sound );
    if (m_menudepth < 1)
        Com_Error (ERR_FATAL, "M_PopMenu: depth < 1");
    m_menudepth--;
 
    m_drawfunc = m_layers[m_menudepth].draw;
    m_keyfunc = m_layers[m_menudepth].key;
 
    if (!m_menudepth)
        M_ForceMenuOff ();
}

Referenced by CancelChanges(), Default_MenuKey(), M_Credits_Key(), M_Main_Key(), and M_Quit_Key().

M_Print()

void M_Print	(	int	cx,
		int	cy,
		char *	str
	)

Definition at line 280 of file menu.c.

{
    while (*str)
    {
        M_DrawCharacter (cx, cy, (*str)+128);
        str++;
        cx += 8 * vid_hudscale->value;
    }
}

Referenced by JoinServer_MenuDraw(), and Options_MenuDraw().

M_PrintWhite()

void M_PrintWhite	(	int	cx,
		int	cy,
		char *	str
	)

Definition at line 290 of file menu.c.

{
    while (*str)
    {
        M_DrawCharacter (cx, cy, *str);
        str++;
        cx += 8 * vid_hudscale->value;
    }
}

M_PushMenu()

void M_PushMenu	(	void(*)(void)	draw,
		const char *(*)(int k)	key
	)

Definition at line 89 of file menu.c.

{
    int     i;
 
    if (Cvar_VariableValue ("maxclients") == 1 
        && Com_ServerState ())
        Cvar_Set ("paused", "1");
 
    // if this menu is already present, drop back to that level
    // to avoid stacking menus by hotkeys
    for (i=0 ; i<m_menudepth ; i++)
        if (m_layers[i].draw == draw &&
            m_layers[i].key == key)
        {
            m_menudepth = i;
        }
 
    if (i == m_menudepth)
    {
        if (m_menudepth >= MAX_MENU_DEPTH)
            Com_Error (ERR_FATAL, "M_PushMenu: MAX_MENU_DEPTH");
        m_layers[m_menudepth].draw = m_drawfunc;
        m_layers[m_menudepth].key = m_keyfunc;
        m_menudepth++;
    }
 
    m_drawfunc = draw;
    m_keyfunc = key;
 
    m_entersound = true;
 
    cls.key_dest = key_menu;
}

Referenced by M_Menu_AddressBook_f(), M_Menu_Credits_f(), M_Menu_DMOptions_f(), M_Menu_DownloadOptions_f(), M_Menu_Game_f(), M_Menu_JoinServer_f(), M_Menu_Keys_f(), M_Menu_LoadGame_f(), M_Menu_Main_f(), M_Menu_Multiplayer_f(), M_Menu_Options_f(), M_Menu_PlayerConfig_f(), M_Menu_Quit_f(), M_Menu_SaveGame_f(), M_Menu_StartServer_f(), and M_Menu_Video_f().

M_Quit_Draw()

void M_Quit_Draw

(

void

)

Definition at line 3948 of file menu.c.

{
    int     w, h;
 
    re.DrawGetPicSize (&w, &h, "quit");
    re.DrawPic ( (viddef.width-w)/2, (viddef.height-h)/2, "quit");
}

Referenced by M_Menu_Quit_f().

M_Quit_Key()

const char* M_Quit_Key

(

int

key

)

Definition at line 3923 of file menu.c.

{
    switch (key)
    {
    case K_ESCAPE:
    case 'n':
    case 'N':
        M_PopMenu ();
        break;
 
    case 'Y':
    case 'y':
        cls.key_dest = key_console;
        CL_Quit_f ();
        break;
 
    default:
        break;
    }
 
    return NULL;
 
}

Referenced by M_Menu_Quit_f().

M_UnbindCommand()

static void M_UnbindCommand ( char *  command )

static

Definition at line 650 of file menu.c.

{
    int     j;
    int     l;
    char    *b;
 
    l = (int)strlen(command);
 
    for (j=0 ; j<256 ; j++)
    {
        b = keybindings[j];
        if (!b)
            continue;
        if (!strncmp (b, command, l) )
            Key_SetBinding (j, "");
    }
}

Referenced by KeyBindingFunc(), and Keys_MenuKey().

MediumGameFunc()

static void MediumGameFunc ( void *  data )

static

Definition at line 1930 of file menu.c.

{
    Cvar_ForceSet( "skill", "1" );
    StartGame();
}

Referenced by Game_MenuInit().

ModelCallback()

static void ModelCallback ( void *  unused )

static

Definition at line 3426 of file menu.c.

{
  s_player_skin_box.itemnames = (const char**)s_pmi[s_player_model_box.curvalue].skindisplaynames;
    s_player_skin_box.curvalue = 0;
}

Referenced by PlayerConfig_MenuInit().

MouseSpeedFunc()

static void MouseSpeedFunc ( void *  unused )

static

Definition at line 1089 of file menu.c.

{
    Cvar_SetValue( "sensitivity", s_options_sensitivity_slider.curvalue / 2.0F );
}

Referenced by Options_MenuInit().

Multiplayer_MenuDraw()

static void Multiplayer_MenuDraw ( void  )

static

Definition at line 511 of file menu.c.

{
    M_Banner( "m_banner_multiplayer" );
 
    Menu_AdjustCursor( &s_multiplayer_menu, 1 );
    Menu_Draw( &s_multiplayer_menu );
}

Referenced by M_Menu_Multiplayer_f().

Multiplayer_MenuInit()

void Multiplayer_MenuInit

(

void

)

Definition at line 534 of file menu.c.

{
    s_multiplayer_menu.x = viddef.width * 0.50 - 64 * vid_hudscale->value;
    s_multiplayer_menu.nitems = 0;
 
    s_join_network_server_action.generic.type   = MTYPE_ACTION;
    s_join_network_server_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_join_network_server_action.generic.x      = 0;
    s_join_network_server_action.generic.y      = 0;
    s_join_network_server_action.generic.name   = " join network server";
    s_join_network_server_action.generic.callback = JoinNetworkServerFunc;
 
    s_start_network_server_action.generic.type  = MTYPE_ACTION;
    s_start_network_server_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_start_network_server_action.generic.x     = 0;
    s_start_network_server_action.generic.y     = 10 * vid_hudscale->value;
    s_start_network_server_action.generic.name  = " start network server";
    s_start_network_server_action.generic.callback = StartNetworkServerFunc;
 
    s_player_setup_action.generic.type  = MTYPE_ACTION;
    s_player_setup_action.generic.flags  = QMF_LEFT_JUSTIFY;
    s_player_setup_action.generic.x     = 0;
    s_player_setup_action.generic.y     = 20 * vid_hudscale->value;
    s_player_setup_action.generic.name  = " player setup";
    s_player_setup_action.generic.callback = PlayerSetupFunc;
 
    Menu_AddItem( &s_multiplayer_menu, ( void * ) &s_join_network_server_action );
    Menu_AddItem( &s_multiplayer_menu, ( void * ) &s_start_network_server_action );
    Menu_AddItem( &s_multiplayer_menu, ( void * ) &s_player_setup_action );
 
    Menu_SetStatusBar( &s_multiplayer_menu, NULL );
 
    Menu_Center( &s_multiplayer_menu );
}

Referenced by M_Menu_Multiplayer_f().

Multiplayer_MenuKey()

const char* Multiplayer_MenuKey

(

int

key

)

Definition at line 569 of file menu.c.

{
    return Default_MenuKey( &s_multiplayer_menu, key );
}

Referenced by M_Menu_Multiplayer_f().

NoAltTabFunc()

static void NoAltTabFunc ( void *  unused )

static

Definition at line 1094 of file menu.c.

{
    Cvar_SetValue( "win_noalttab", s_options_noalttab_box.curvalue );
}

NullCursorDraw()

void NullCursorDraw

(

void *

self

)

Definition at line 2282 of file menu.c.

{
}

Options_MenuDraw()

void Options_MenuDraw

(

void

)

Definition at line 1377 of file menu.c.

{
    M_Banner( "m_banner_options" );
    Menu_AdjustCursor( &s_options_menu, 1 );
    Menu_Draw( &s_options_menu );
 
    if (update_sound_quality)
    {
        M_DrawTextBox(8 - 152 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value, 36, 3);
        M_Print(32 - 136 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value + 8 * vid_hudscale->value, "Restarting the sound system. This");
        M_Print(32 - 136 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value + 16 * vid_hudscale->value, "could take up to a minute, so");
        M_Print(32 - 136 * (vid_hudscale->value - 1.f), 120 - 48 * vid_hudscale->value + 24 * vid_hudscale->value, "please be patient.");
 
        CL_Snd_Restart_f();
        update_sound_quality = false;
    }
}

Referenced by M_Menu_Options_f().

Options_MenuInit()

void Options_MenuInit

(

void

)

Definition at line 1207 of file menu.c.

{
    static const char *cd_music_items[] =
    {
        "disabled",
        "enabled",
        0
    };
    static const char *quality_items[] =
    {
        "low", "high", 0
    };
 
    static const char *compatibility_items[] =
    {
        "max compatibility", "max performance", 0
    };
 
    static const char *yesno_names[] =
    {
        "no",
        "yes",
        0
    };
 
    static const char *crosshair_names[] =
    {
        "none",
        "cross",
        "dot",
        "angle",
        0
    };
 
    win_noalttab = Cvar_Get( "win_noalttab", "0", CVAR_ARCHIVE );
 
    /*
    ** configure controls menu and menu items
    */
    s_options_menu.x = viddef.width / 2;
    s_options_menu.y = viddef.height / 2 - 58 * vid_hudscale->value;
    s_options_menu.nitems = 0;
 
    s_options_sfxvolume_slider.generic.type = MTYPE_SLIDER;
    s_options_sfxvolume_slider.generic.x    = 0;
    s_options_sfxvolume_slider.generic.y    = 0;
    s_options_sfxvolume_slider.generic.name = "effects volume";
    s_options_sfxvolume_slider.generic.callback = UpdateVolumeFunc;
    s_options_sfxvolume_slider.minvalue     = 0;
    s_options_sfxvolume_slider.maxvalue     = 10;
    s_options_sfxvolume_slider.curvalue     = Cvar_VariableValue( "s_volume" ) * 10;
 
    s_options_cdvolume_box.generic.type = MTYPE_SPINCONTROL;
    s_options_cdvolume_box.generic.x        = 0;
    s_options_cdvolume_box.generic.y        = 10 * vid_hudscale->value;
    s_options_cdvolume_box.generic.name = "CD music";
    s_options_cdvolume_box.generic.callback = UpdateCDVolumeFunc;
    s_options_cdvolume_box.itemnames        = cd_music_items;
    s_options_cdvolume_box.curvalue         = !Cvar_VariableValue("cd_nocd");
 
    s_options_quality_list.generic.type = MTYPE_SPINCONTROL;
    s_options_quality_list.generic.x        = 0;
    s_options_quality_list.generic.y        = 20 * vid_hudscale->value;
    s_options_quality_list.generic.name     = "sound quality";
    s_options_quality_list.generic.callback = UpdateSoundQualityFunc;
    s_options_quality_list.itemnames        = quality_items;
    s_options_quality_list.curvalue         = !Cvar_VariableValue( "s_loadas8bit" );
 
    s_options_compatibility_list.generic.type   = MTYPE_SPINCONTROL;
    s_options_compatibility_list.generic.x      = 0;
    s_options_compatibility_list.generic.y      = 30 * vid_hudscale->value;
    s_options_compatibility_list.generic.name   = "sound compatibility";
    s_options_compatibility_list.generic.callback = UpdateSoundQualityFunc;
    s_options_compatibility_list.itemnames      = compatibility_items;
    s_options_compatibility_list.curvalue       = Cvar_VariableValue( "s_primary" );
 
    s_options_sensitivity_slider.generic.type   = MTYPE_SLIDER;
    s_options_sensitivity_slider.generic.x      = 0;
    s_options_sensitivity_slider.generic.y      = 50 * vid_hudscale->value;
    s_options_sensitivity_slider.generic.name   = "mouse speed";
    s_options_sensitivity_slider.generic.callback = MouseSpeedFunc;
    s_options_sensitivity_slider.minvalue       = 2;
    s_options_sensitivity_slider.maxvalue       = 22;
 
    s_options_alwaysrun_box.generic.type = MTYPE_SPINCONTROL;
    s_options_alwaysrun_box.generic.x   = 0;
    s_options_alwaysrun_box.generic.y   = 60 * vid_hudscale->value;
    s_options_alwaysrun_box.generic.name    = "always run";
    s_options_alwaysrun_box.generic.callback = AlwaysRunFunc;
    s_options_alwaysrun_box.itemnames = yesno_names;
 
    s_options_invertmouse_box.generic.type = MTYPE_SPINCONTROL;
    s_options_invertmouse_box.generic.x = 0;
    s_options_invertmouse_box.generic.y = 70 * vid_hudscale->value;
    s_options_invertmouse_box.generic.name  = "invert mouse";
    s_options_invertmouse_box.generic.callback = InvertMouseFunc;
    s_options_invertmouse_box.itemnames = yesno_names;
 
    s_options_lookspring_box.generic.type = MTYPE_SPINCONTROL;
    s_options_lookspring_box.generic.x  = 0;
    s_options_lookspring_box.generic.y  = 80 * vid_hudscale->value;
    s_options_lookspring_box.generic.name   = "lookspring";
    s_options_lookspring_box.generic.callback = LookspringFunc;
    s_options_lookspring_box.itemnames = yesno_names;
 
    s_options_lookstrafe_box.generic.type = MTYPE_SPINCONTROL;
    s_options_lookstrafe_box.generic.x  = 0;
    s_options_lookstrafe_box.generic.y  = 90 * vid_hudscale->value;
    s_options_lookstrafe_box.generic.name   = "lookstrafe";
    s_options_lookstrafe_box.generic.callback = LookstrafeFunc;
    s_options_lookstrafe_box.itemnames = yesno_names;
 
    s_options_freelook_box.generic.type = MTYPE_SPINCONTROL;
    s_options_freelook_box.generic.x    = 0;
    s_options_freelook_box.generic.y    = 100 * vid_hudscale->value;
    s_options_freelook_box.generic.name = "free look";
    s_options_freelook_box.generic.callback = FreeLookFunc;
    s_options_freelook_box.itemnames = yesno_names;
 
    s_options_crosshair_box.generic.type = MTYPE_SPINCONTROL;
    s_options_crosshair_box.generic.x   = 0;
    s_options_crosshair_box.generic.y   = 110 * vid_hudscale->value;
    s_options_crosshair_box.generic.name    = "crosshair";
    s_options_crosshair_box.generic.callback = CrosshairFunc;
    s_options_crosshair_box.itemnames = crosshair_names;
 
    s_options_joystick_box.generic.type = MTYPE_SPINCONTROL;
    s_options_joystick_box.generic.x    = 0;
    s_options_joystick_box.generic.y    = 120 * vid_hudscale->value;
    s_options_joystick_box.generic.name = "use joystick";
    s_options_joystick_box.generic.callback = JoystickFunc;
    s_options_joystick_box.itemnames = yesno_names;
 
    s_options_customize_options_action.generic.type = MTYPE_ACTION;
    s_options_customize_options_action.generic.x        = 0;
    s_options_customize_options_action.generic.y        = 140 * vid_hudscale->value;
    s_options_customize_options_action.generic.name = "customize controls";
    s_options_customize_options_action.generic.callback = CustomizeControlsFunc;
 
    s_options_defaults_action.generic.type  = MTYPE_ACTION;
    s_options_defaults_action.generic.x     = 0;
    s_options_defaults_action.generic.y     = 150 * vid_hudscale->value;
    s_options_defaults_action.generic.name  = "reset defaults";
    s_options_defaults_action.generic.callback = ControlsResetDefaultsFunc;
 
    s_options_console_action.generic.type   = MTYPE_ACTION;
    s_options_console_action.generic.x      = 0;
    s_options_console_action.generic.y      = 160 * vid_hudscale->value;
    s_options_console_action.generic.name   = "go to console";
    s_options_console_action.generic.callback = ConsoleFunc;
 
    ControlsSetMenuItemValues();
 
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_sfxvolume_slider );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_cdvolume_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_quality_list );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_compatibility_list );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_sensitivity_slider );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_alwaysrun_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_invertmouse_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_lookspring_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_lookstrafe_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_freelook_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_crosshair_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_joystick_box );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_customize_options_action );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_defaults_action );
    Menu_AddItem( &s_options_menu, ( void * ) &s_options_console_action );
}

Referenced by M_Menu_Options_f().

Options_MenuKey()

const char* Options_MenuKey

(

int

key

)

Definition at line 1395 of file menu.c.

{
    return Default_MenuKey( &s_options_menu, key );
}

Referenced by M_Menu_Options_f().

PlayerConfig_MenuDraw()

void PlayerConfig_MenuDraw

(

void

)

Definition at line 3792 of file menu.c.

{
    extern float CalcFov( float fov_x, float w, float h );
    refdef_t refdef;
    char scratch[MAX_QPATH];
 
    memset( &refdef, 0, sizeof( refdef ) );
 
    refdef.x = viddef.width / 2;
    refdef.y = viddef.height / 2 - 72 * vid_hudscale->value;
    refdef.width = 144 * vid_hudscale->value;
    refdef.height = 168 * vid_hudscale->value;
    refdef.fov_x = 40;
    refdef.fov_y = CalcFov( refdef.fov_x, refdef.width, refdef.height );
    refdef.time = cls.realtime*0.001;
 
    if ( s_pmi[s_player_model_box.curvalue].skindisplaynames )
    {
        static int yaw;
        entity_t entity;
 
        memset( &entity, 0, sizeof( entity ) );
 
        Com_sprintf( scratch, sizeof( scratch ), "players/%s/tris.md2", s_pmi[s_player_model_box.curvalue].directory );
        entity.model = re.RegisterModel( scratch );
        Com_sprintf( scratch, sizeof( scratch ), "players/%s/%s.pcx", s_pmi[s_player_model_box.curvalue].directory, s_pmi[s_player_model_box.curvalue].skindisplaynames[s_player_skin_box.curvalue] );
        entity.skin = re.RegisterSkin( scratch );
        entity.flags = RF_FULLBRIGHT;
        entity.origin[0] = 80;
        entity.origin[1] = 0;
        entity.origin[2] = 0;
        VectorCopy( entity.origin, entity.oldorigin );
        entity.frame = 0;
        entity.oldframe = 0;
        entity.backlerp = 0.0;
        entity.angles[1] = yaw++;
        if ( ++yaw > 360 )
            yaw -= 360;
 
        refdef.areabits = 0;
        refdef.num_entities = 1;
        refdef.entities = &entity;
        refdef.lightstyles = 0;
        refdef.rdflags = RDF_NOWORLDMODEL;
 
        Menu_Draw( &s_player_config_menu );
 
        M_DrawTextBox((refdef.x) * (320.0F / viddef.width) - 8 * vid_hudscale->value, (viddef.height / 2) * (240.0F / viddef.height) - 77 * vid_hudscale->value, refdef.width / (8 * vid_hudscale->value), refdef.height / (8 * vid_hudscale->value));
        refdef.height += 4 * vid_hudscale->value;
 
        re.RenderFrame( &refdef );
 
        Com_sprintf( scratch, sizeof( scratch ), "/players/%s/%s_i.pcx", 
            s_pmi[s_player_model_box.curvalue].directory,
            s_pmi[s_player_model_box.curvalue].skindisplaynames[s_player_skin_box.curvalue] );
        re.DrawPic( s_player_config_menu.x - 40 * vid_hudscale->value, refdef.y, scratch );
    }
}

Referenced by M_Menu_PlayerConfig_f().

PlayerConfig_MenuInit()

qboolean PlayerConfig_MenuInit

(

void

)

Definition at line 3629 of file menu.c.

{
    extern cvar_t *name;
    extern cvar_t *team;
    extern cvar_t *skin;
    char currentdirectory[1024];
    char currentskin[1024];
    int i = 0;
 
    int currentdirectoryindex = 0;
    int currentskinindex = 0;
 
    cvar_t *hand = Cvar_Get( "hand", "0", CVAR_USERINFO | CVAR_ARCHIVE );
 
    static const char *handedness[] = { "right", "left", "center", 0 };
 
    PlayerConfig_ScanDirectories();
 
    if (s_numplayermodels == 0)
        return false;
 
    if ( hand->value < 0 || hand->value > 2 )
        Cvar_SetValue( "hand", 0 );
 
    strcpy( currentdirectory, skin->string );
 
    if ( strchr( currentdirectory, '/' ) )
    {
        strcpy( currentskin, strchr( currentdirectory, '/' ) + 1 );
        *strchr( currentdirectory, '/' ) = 0;
    }
    else if ( strchr( currentdirectory, '\\' ) )
    {
        strcpy( currentskin, strchr( currentdirectory, '\\' ) + 1 );
        *strchr( currentdirectory, '\\' ) = 0;
    }
    else
    {
        strcpy( currentdirectory, "male" );
        strcpy( currentskin, "grunt" );
    }
 
    qsort( s_pmi, s_numplayermodels, sizeof( s_pmi[0] ), pmicmpfnc );
 
    memset( s_pmnames, 0, sizeof( s_pmnames ) );
    for ( i = 0; i < s_numplayermodels; i++ )
    {
        s_pmnames[i] = s_pmi[i].displayname;
        if ( Q_stricmp( s_pmi[i].directory, currentdirectory ) == 0 )
        {
            int j;
 
            currentdirectoryindex = i;
 
            for ( j = 0; j < s_pmi[i].nskins; j++ )
            {
                if ( Q_stricmp( s_pmi[i].skindisplaynames[j], currentskin ) == 0 )
                {
                    currentskinindex = j;
                    break;
                }
            }
        }
    }
 
    s_player_config_menu.x = viddef.width / 2 - 95 * vid_hudscale->value;
    s_player_config_menu.y = viddef.height / 2 - 97 * vid_hudscale->value;
    s_player_config_menu.nitems = 0;
 
    s_player_name_field.generic.type = MTYPE_FIELD;
    s_player_name_field.generic.name = "name";
    s_player_name_field.generic.callback = 0;
    s_player_name_field.generic.x       = 0;
    s_player_name_field.generic.y       = 0;
    s_player_name_field.length  = 20;
    s_player_name_field.visible_length = 20;
    strcpy( s_player_name_field.buffer, name->string );
    s_player_name_field.cursor = (int)strlen( name->string );
 
    s_player_model_title.generic.type = MTYPE_SEPARATOR;
    s_player_model_title.generic.name = "model";
    s_player_model_title.generic.x    = -8 * vid_hudscale->value;
    s_player_model_title.generic.y   = 60 * vid_hudscale->value;
 
    s_player_model_box.generic.type = MTYPE_SPINCONTROL;
    s_player_model_box.generic.x    = -56 * vid_hudscale->value;
    s_player_model_box.generic.y    = 70 * vid_hudscale->value;
    s_player_model_box.generic.callback = ModelCallback;
    s_player_model_box.generic.cursor_offset = -48;
    s_player_model_box.curvalue = currentdirectoryindex;
    s_player_model_box.itemnames = (const char**)s_pmnames;
 
    s_player_skin_title.generic.type = MTYPE_SEPARATOR;
    s_player_skin_title.generic.name = "skin";
    s_player_skin_title.generic.x    = -16 * vid_hudscale->value;
    s_player_skin_title.generic.y    = 84 * vid_hudscale->value;
 
    s_player_skin_box.generic.type = MTYPE_SPINCONTROL;
    s_player_skin_box.generic.x = -56 * vid_hudscale->value;
    s_player_skin_box.generic.y = 94 * vid_hudscale->value;
    s_player_skin_box.generic.name  = 0;
    s_player_skin_box.generic.callback = 0;
    s_player_skin_box.generic.cursor_offset = -48;
    s_player_skin_box.curvalue = currentskinindex;
    s_player_skin_box.itemnames = (const char**)s_pmi[currentdirectoryindex].skindisplaynames;
 
    s_player_hand_title.generic.type = MTYPE_SEPARATOR;
    s_player_hand_title.generic.name = "handedness";
    s_player_hand_title.generic.x    = 32 * vid_hudscale->value;
    s_player_hand_title.generic.y    = 108 * vid_hudscale->value;
 
    s_player_handedness_box.generic.type = MTYPE_SPINCONTROL;
    s_player_handedness_box.generic.x   = -56 * vid_hudscale->value;
    s_player_handedness_box.generic.y   = 118 * vid_hudscale->value;
    s_player_handedness_box.generic.name    = 0;
    s_player_handedness_box.generic.cursor_offset = -48;
    s_player_handedness_box.generic.callback = HandednessCallback;
    s_player_handedness_box.curvalue = Cvar_VariableValue( "hand" );
    s_player_handedness_box.itemnames = handedness;
 
    for (i = 0; i < sizeof(rate_tbl) / sizeof(*rate_tbl) - 1; i++)
        if (Cvar_VariableValue("rate") == rate_tbl[i])
            break;
 
    s_player_rate_title.generic.type = MTYPE_SEPARATOR;
    s_player_rate_title.generic.name = "connect speed";
    s_player_rate_title.generic.x    = 56 * vid_hudscale->value;
    s_player_rate_title.generic.y    = 156 * vid_hudscale->value;
 
    s_player_rate_box.generic.type = MTYPE_SPINCONTROL;
    s_player_rate_box.generic.x = -56 * vid_hudscale->value;
    s_player_rate_box.generic.y = 166 * vid_hudscale->value;
    s_player_rate_box.generic.name  = 0;
    s_player_rate_box.generic.cursor_offset = -48;
    s_player_rate_box.generic.callback = RateCallback;
    s_player_rate_box.curvalue = i;
    s_player_rate_box.itemnames = rate_names;
 
    s_player_download_action.generic.type = MTYPE_ACTION;
    s_player_download_action.generic.name   = "download options";
    s_player_download_action.generic.flags= QMF_LEFT_JUSTIFY;
    s_player_download_action.generic.x  = -24 * vid_hudscale->value;
    s_player_download_action.generic.y  = 186 * vid_hudscale->value;
    s_player_download_action.generic.statusbar = NULL;
    s_player_download_action.generic.callback = DownloadOptionsFunc;
 
    Menu_AddItem( &s_player_config_menu, &s_player_name_field );
    Menu_AddItem( &s_player_config_menu, &s_player_model_title );
    Menu_AddItem( &s_player_config_menu, &s_player_model_box );
    if ( s_player_skin_box.itemnames )
    {
        Menu_AddItem( &s_player_config_menu, &s_player_skin_title );
        Menu_AddItem( &s_player_config_menu, &s_player_skin_box );
    }
    Menu_AddItem( &s_player_config_menu, &s_player_hand_title );
    Menu_AddItem( &s_player_config_menu, &s_player_handedness_box );
    Menu_AddItem( &s_player_config_menu, &s_player_rate_title );
    Menu_AddItem( &s_player_config_menu, &s_player_rate_box );
    Menu_AddItem( &s_player_config_menu, &s_player_download_action );
 
    return true;
}

Referenced by M_Menu_PlayerConfig_f().

PlayerConfig_MenuKey()

const char* PlayerConfig_MenuKey

(

int

key

)

Definition at line 3851 of file menu.c.

{
    int i;
 
    if ( key == K_ESCAPE )
    {
        char scratch[1024];
 
        Cvar_Set( "name", s_player_name_field.buffer );
 
        Com_sprintf( scratch, sizeof( scratch ), "%s/%s", 
            s_pmi[s_player_model_box.curvalue].directory, 
            s_pmi[s_player_model_box.curvalue].skindisplaynames[s_player_skin_box.curvalue] );
 
        Cvar_Set( "skin", scratch );
 
        for ( i = 0; i < s_numplayermodels; i++ )
        {
            int j;
 
            for ( j = 0; j < s_pmi[i].nskins; j++ )
            {
                if ( s_pmi[i].skindisplaynames[j] )
                    free( s_pmi[i].skindisplaynames[j] );
                s_pmi[i].skindisplaynames[j] = 0;
            }
            free( s_pmi[i].skindisplaynames );
            s_pmi[i].skindisplaynames = 0;
            s_pmi[i].nskins = 0;
        }
    }
    return Default_MenuKey( &s_player_config_menu, key );
}

Referenced by M_Menu_PlayerConfig_f().

PlayerConfig_ScanDirectories()

static qboolean PlayerConfig_ScanDirectories ( void  )

static

Definition at line 3465 of file menu.c.

{
    char findname[1024];
    char scratch[1024];
    int ndirs = 0, npms = 0;
    char **dirnames;
    char *path = NULL;
    int i;
 
    extern char **FS_ListFiles( char *, int *, unsigned, unsigned );
 
    s_numplayermodels = 0;
 
    /*
    ** get a list of directories
    */
    do 
    {
        path = FS_NextPath( path );
        Com_sprintf( findname, sizeof(findname), "%s/players/*.*", path );
 
        if ( ( dirnames = FS_ListFiles( findname, &ndirs, SFF_SUBDIR, 0 ) ) != 0 )
            break;
    } while ( path );
 
    if ( !dirnames )
        return false;
 
    /*
    ** go through the subdirectories
    */
    npms = ndirs;
    if ( npms > MAX_PLAYERMODELS )
        npms = MAX_PLAYERMODELS;
 
    for ( i = 0; i < npms; i++ )
    {
        int k, s;
        char *a, *b, *c;
        char **pcxnames;
        char **skinnames;
        int npcxfiles;
        int nskins = 0;
 
        if ( dirnames[i] == 0 )
            continue;
 
        // verify the existence of tris.md2
        strcpy( scratch, dirnames[i] );
        strcat( scratch, "/tris.md2" );
        if ( !Sys_FindFirst( scratch, 0, SFF_SUBDIR | SFF_HIDDEN | SFF_SYSTEM ) )
        {
            free( dirnames[i] );
            dirnames[i] = 0;
            Sys_FindClose();
            continue;
        }
        Sys_FindClose();
 
        // verify the existence of at least one pcx skin
        strcpy( scratch, dirnames[i] );
        strcat( scratch, "/*.pcx" );
        pcxnames = FS_ListFiles( scratch, &npcxfiles, 0, SFF_SUBDIR | SFF_HIDDEN | SFF_SYSTEM );
 
        if ( !pcxnames )
        {
            free( dirnames[i] );
            dirnames[i] = 0;
            continue;
        }
 
        // count valid skins, which consist of a skin with a matching "_i" icon
        for ( k = 0; k < npcxfiles-1; k++ )
        {
            if ( !strstr( pcxnames[k], "_i.pcx" ) )
            {
                if ( IconOfSkinExists( pcxnames[k], pcxnames, npcxfiles - 1 ) )
                {
                    nskins++;
                }
            }
        }
        if ( !nskins )
            continue;
 
        skinnames = malloc( sizeof( char * ) * ( nskins + 1 ) );
        memset( skinnames, 0, sizeof( char * ) * ( nskins + 1 ) );
 
        // copy the valid skins
        for ( s = 0, k = 0; k < npcxfiles-1; k++ )
        {
            char *a, *b, *c;
 
            if ( !strstr( pcxnames[k], "_i.pcx" ) )
            {
                if ( IconOfSkinExists( pcxnames[k], pcxnames, npcxfiles - 1 ) )
                {
                    a = strrchr( pcxnames[k], '/' );
                    b = strrchr( pcxnames[k], '\\' );
 
                    if ( a > b )
                        c = a;
                    else
                        c = b;
 
                    strcpy( scratch, c + 1 );
 
                    if ( strrchr( scratch, '.' ) )
                        *strrchr( scratch, '.' ) = 0;
 
                    skinnames[s] = strdup( scratch );
                    s++;
                }
            }
        }
 
        // at this point we have a valid player model
        s_pmi[s_numplayermodels].nskins = nskins;
        s_pmi[s_numplayermodels].skindisplaynames = skinnames;
 
        // make short name for the model
        a = strrchr( dirnames[i], '/' );
        b = strrchr( dirnames[i], '\\' );
 
        if ( a > b )
            c = a;
        else
            c = b;
 
        strncpy( s_pmi[s_numplayermodels].displayname, c + 1, MAX_DISPLAYNAME-1 );
        strcpy( s_pmi[s_numplayermodels].directory, c + 1 );
 
        FreeFileList( pcxnames, npcxfiles );
 
        s_numplayermodels++;
    }
    if ( dirnames )
        FreeFileList( dirnames, ndirs );
 
    return true;
}

Referenced by PlayerConfig_MenuInit().

PlayerSetupFunc()

static void PlayerSetupFunc ( void *  unused )

static

Definition at line 519 of file menu.c.

{
    M_Menu_PlayerConfig_f();
}

Referenced by Multiplayer_MenuInit().

pmicmpfnc()

static int pmicmpfnc ( const void *  _a, const void *  _b  )

static

Definition at line 3607 of file menu.c.

{
    const playermodelinfo_s *a = ( const playermodelinfo_s * ) _a;
    const playermodelinfo_s *b = ( const playermodelinfo_s * ) _b;
 
    /*
    ** sort by male, female, then alphabetical
    */
    if ( strcmp( a->directory, "male" ) == 0 )
        return -1;
    else if ( strcmp( b->directory, "male" ) == 0 )
        return 1;
 
    if ( strcmp( a->directory, "female" ) == 0 )
        return -1;
    else if ( strcmp( b->directory, "female" ) == 0 )
        return 1;
 
    return strcmp( a->directory, b->directory );
}

Referenced by PlayerConfig_MenuInit().

RateCallback()

static void RateCallback ( void *  unused )

static

Definition at line 3420 of file menu.c.

{
    if (s_player_rate_box.curvalue != sizeof(rate_tbl) / sizeof(*rate_tbl) - 1)
        Cvar_SetValue( "rate", rate_tbl[s_player_rate_box.curvalue] );
}

Referenced by PlayerConfig_MenuInit().

RulesChangeFunc()

void RulesChangeFunc

(

void *

self

)

Definition at line 2411 of file menu.c.

{
    // DM
    if (s_rules_box.curvalue == 0)
    {
        s_maxclients_field.generic.statusbar = NULL;
        s_startserver_dmoptions_action.generic.statusbar = NULL;
    }
    else if(s_rules_box.curvalue == 1)      // coop             // PGM
    {
        s_maxclients_field.generic.statusbar = "4 maximum for cooperative";
        if (atoi(s_maxclients_field.buffer) > 4)
            strcpy( s_maxclients_field.buffer, "4" );
        s_startserver_dmoptions_action.generic.statusbar = "N/A for cooperative";
    }
//=====
//PGM
    // ROGUE GAMES
    else if(Developer_searchpath(2) == 2)
    {
        if (s_rules_box.curvalue == 2)          // tag  
        {
            s_maxclients_field.generic.statusbar = NULL;
            s_startserver_dmoptions_action.generic.statusbar = NULL;
        }
/*
        else if(s_rules_box.curvalue == 3)      // deathball
        {
            s_maxclients_field.generic.statusbar = NULL;
            s_startserver_dmoptions_action.generic.statusbar = NULL;
        }
*/
    }
//PGM
//=====
}

Referenced by StartServer_MenuInit().

SaveGame_MenuDraw()

void SaveGame_MenuDraw

(

void

)

Definition at line 2159 of file menu.c.

{
    M_Banner( "m_banner_save_game" );
    Menu_AdjustCursor( &s_savegame_menu, 1 );
    Menu_Draw( &s_savegame_menu );
}

Referenced by M_Menu_SaveGame_f().

SaveGame_MenuInit()

void SaveGame_MenuInit

(

void

)

Definition at line 2166 of file menu.c.

{
    int i;
 
    s_savegame_menu.x = viddef.width / 2 - 120 * vid_hudscale->value;
    s_savegame_menu.y = viddef.height / 2 - 58 * vid_hudscale->value;
    s_savegame_menu.nitems = 0;
 
    Create_Savestrings();
 
    // don't include the autosave slot
    for ( i = 0; i < MAX_SAVEGAMES-1; i++ )
    {
        s_savegame_actions[i].generic.name = m_savestrings[i+1];
        s_savegame_actions[i].generic.localdata[0] = i+1;
        s_savegame_actions[i].generic.flags = QMF_LEFT_JUSTIFY;
        s_savegame_actions[i].generic.callback = SaveGameCallback;
 
        s_savegame_actions[i].generic.x = 0;
        s_savegame_actions[i].generic.y = ( i ) * 10 * vid_hudscale->value;
 
        s_savegame_actions[i].generic.type = MTYPE_ACTION;
 
        Menu_AddItem( &s_savegame_menu, &s_savegame_actions[i] );
    }
}

Referenced by M_Menu_SaveGame_f().

SaveGame_MenuKey()

const char* SaveGame_MenuKey

(

int

key

)

Definition at line 2193 of file menu.c.

{
    if ( key == K_ENTER || key == K_ESCAPE )
    {
        s_loadgame_menu.cursor = s_savegame_menu.cursor - 1;
        if ( s_loadgame_menu.cursor < 0 )
            s_loadgame_menu.cursor = 0;
    }
    return Default_MenuKey( &s_savegame_menu, key );
}

Referenced by M_Menu_SaveGame_f().

SaveGameCallback()

void SaveGameCallback

(

void *

self

)

Definition at line 2151 of file menu.c.

{
    menuaction_s *a = ( menuaction_s * ) self;
 
    Cbuf_AddText (va("save save%i\n", a->generic.localdata[0] ));
    M_ForceMenuOff ();
}

Referenced by SaveGame_MenuInit().

SaveGameFunc()

static void SaveGameFunc ( void *  unused )

static

Definition at line 1947 of file menu.c.

{
    M_Menu_SaveGame_f();
}

Referenced by Game_MenuInit().

SearchLocalGames()

void SearchLocalGames

(

void

)

Definition at line 2286 of file menu.c.

{
    int     i;
 
    m_num_servers = 0;
    for (i=0 ; i<MAX_LOCAL_SERVERS ; i++)
        strcpy (local_server_names[i], NO_SERVER_STRING);
 
    search_local_games = true;
}

Referenced by JoinServer_MenuInit(), and SearchLocalGamesFunc().

SearchLocalGamesFunc()

void SearchLocalGamesFunc

(

void *

self

)

Definition at line 2297 of file menu.c.

{
    SearchLocalGames();
}

Referenced by JoinServer_MenuInit().

StartGame()

static void StartGame ( void  )

static

Definition at line 1910 of file menu.c.

{
    // disable updates and start the cinematic going
    cl.servercount = -1;
    M_ForceMenuOff ();
    Cvar_SetValue( "deathmatch", 0 );
    Cvar_SetValue( "coop", 0 );
 
    Cvar_SetValue( "gamerules", 0 );        //PGM
 
    Cbuf_AddText ("loading ; killserver ; wait ; newgame\n");
    cls.key_dest = key_game;
}

Referenced by EasyGameFunc(), HardGameFunc(), and MediumGameFunc().

StartNetworkServerFunc()

static void StartNetworkServerFunc ( void *  unused )

static

Definition at line 529 of file menu.c.

{
    M_Menu_StartServer_f ();
}

Referenced by Multiplayer_MenuInit().

StartServer_MenuDraw()

void StartServer_MenuDraw

(

void

)

Definition at line 2735 of file menu.c.

{
    Menu_Draw( &s_startserver_menu );
}

Referenced by M_Menu_StartServer_f().

StartServer_MenuInit()

void StartServer_MenuInit

(

void

)

Definition at line 2530 of file menu.c.

{
    static const char *dm_coop_names[] =
    {
        "deathmatch",
        "cooperative",
        0
    };
//=======
//PGM
    static const char *dm_coop_names_rogue[] =
    {
        "deathmatch",
        "cooperative",
        "tag",
//      "deathball",
        0
    };
//PGM
//=======
    char *buffer;
    char  mapsname[1024];
    char *s;
    int length;
    int i;
    FILE *fp;
 
    /*
    ** load the list of map names
    */
    Com_sprintf( mapsname, sizeof( mapsname ), "%s/maps.lst", FS_Gamedir() );
    if ( ( fp = fopen( mapsname, "rb" ) ) == 0 )
    {
        if ( ( length = FS_LoadFile( "maps.lst", ( void ** ) &buffer ) ) == -1 )
            Com_Error( ERR_DROP, "couldn't find maps.lst\n" );
    }
    else
    {
#ifdef _WIN32
        length = filelength( fileno( fp  ) );
#else
        fseek(fp, 0, SEEK_END);
        length = ftell(fp);
        fseek(fp, 0, SEEK_SET);
#endif
        buffer = malloc( length );
        fread( buffer, length, 1, fp );
    }
 
    s = buffer;
 
    i = 0;
    while ( i < length )
    {
        if ( s[i] == '\r' )
            nummaps++;
        i++;
    }
 
    if ( nummaps == 0 )
        Com_Error( ERR_DROP, "no maps in maps.lst\n" );
 
    mapnames = malloc( sizeof( char * ) * ( nummaps + 1 ) );
    memset( mapnames, 0, sizeof( char * ) * ( nummaps + 1 ) );
 
    s = buffer;
 
    for ( i = 0; i < nummaps; i++ )
    {
    char  shortname[MAX_TOKEN_CHARS];
    char  longname[MAX_TOKEN_CHARS];
        char  scratch[200];
        int     j, l;
 
        strcpy( shortname, COM_Parse( &s ) );
        l = (int)strlen(shortname);
        for (j=0 ; j<l ; j++)
            shortname[j] = toupper(shortname[j]);
        strcpy( longname, COM_Parse( &s ) );
        Com_sprintf( scratch, sizeof( scratch ), "%s\n%s", longname, shortname );
 
        mapnames[i] = malloc( strlen( scratch ) + 1 );
        strcpy( mapnames[i], scratch );
    }
    mapnames[nummaps] = 0;
 
    if ( fp != 0 )
    {
        fp = 0;
        free( buffer );
    }
    else
    {
        FS_FreeFile( buffer );
    }
 
    /*
    ** initialize the menu stuff
    */
    s_startserver_menu.x = viddef.width * 0.50;
    s_startserver_menu.nitems = 0;
 
    s_startmap_list.generic.type = MTYPE_SPINCONTROL;
    s_startmap_list.generic.x   = 0;
    s_startmap_list.generic.y   = 0;
    s_startmap_list.generic.name    = "initial map";
    s_startmap_list.itemnames = (const char**)mapnames;
 
    s_rules_box.generic.type = MTYPE_SPINCONTROL;
    s_rules_box.generic.x   = 0;
    s_rules_box.generic.y   = 20 * vid_hudscale->value;
    s_rules_box.generic.name    = "rules";
    
//PGM - rogue games only available with rogue DLL.
    if(Developer_searchpath(2) == 2)
        s_rules_box.itemnames = dm_coop_names_rogue;
    else
        s_rules_box.itemnames = dm_coop_names;
//PGM
 
    if (Cvar_VariableValue("coop"))
        s_rules_box.curvalue = 1;
    else
        s_rules_box.curvalue = 0;
    s_rules_box.generic.callback = RulesChangeFunc;
 
    s_timelimit_field.generic.type = MTYPE_FIELD;
    s_timelimit_field.generic.name = "time limit";
    s_timelimit_field.generic.flags = QMF_NUMBERSONLY;
    s_timelimit_field.generic.x = 0;
    s_timelimit_field.generic.y = 36 * vid_hudscale->value;
    s_timelimit_field.generic.statusbar = "0 = no limit";
    s_timelimit_field.length = 3;
    s_timelimit_field.visible_length = 3;
    strcpy( s_timelimit_field.buffer, Cvar_VariableString("timelimit") );
 
    s_fraglimit_field.generic.type = MTYPE_FIELD;
    s_fraglimit_field.generic.name = "frag limit";
    s_fraglimit_field.generic.flags = QMF_NUMBERSONLY;
    s_fraglimit_field.generic.x = 0;
    s_fraglimit_field.generic.y = 54 * vid_hudscale->value;
    s_fraglimit_field.generic.statusbar = "0 = no limit";
    s_fraglimit_field.length = 3;
    s_fraglimit_field.visible_length = 3;
    strcpy( s_fraglimit_field.buffer, Cvar_VariableString("fraglimit") );
 
    /*
    ** maxclients determines the maximum number of players that can join
    ** the game.  If maxclients is only "1" then we should default the menu
    ** option to 8 players, otherwise use whatever its current value is. 
    ** Clamping will be done when the server is actually started.
    */
    s_maxclients_field.generic.type = MTYPE_FIELD;
    s_maxclients_field.generic.name = "max players";
    s_maxclients_field.generic.flags = QMF_NUMBERSONLY;
    s_maxclients_field.generic.x    = 0;
    s_maxclients_field.generic.y    = 72 * vid_hudscale->value;
    s_maxclients_field.generic.statusbar = NULL;
    s_maxclients_field.length = 3;
    s_maxclients_field.visible_length = 3;
    if ( Cvar_VariableValue( "maxclients" ) == 1 )
        strcpy( s_maxclients_field.buffer, "8" );
    else 
        strcpy( s_maxclients_field.buffer, Cvar_VariableString("maxclients") );
 
    s_hostname_field.generic.type = MTYPE_FIELD;
    s_hostname_field.generic.name = "hostname";
    s_hostname_field.generic.flags = 0;
    s_hostname_field.generic.x  = 0;
    s_hostname_field.generic.y  = 90 * vid_hudscale->value;
    s_hostname_field.generic.statusbar = NULL;
    s_hostname_field.length = 12;
    s_hostname_field.visible_length = 12;
    strcpy( s_hostname_field.buffer, Cvar_VariableString("hostname") );
 
    s_startserver_dmoptions_action.generic.type = MTYPE_ACTION;
    s_startserver_dmoptions_action.generic.name = " deathmatch flags";
    s_startserver_dmoptions_action.generic.flags= QMF_LEFT_JUSTIFY;
    s_startserver_dmoptions_action.generic.x    = 24 * vid_hudscale->value;
    s_startserver_dmoptions_action.generic.y    = 108 * vid_hudscale->value;
    s_startserver_dmoptions_action.generic.statusbar = NULL;
    s_startserver_dmoptions_action.generic.callback = DMOptionsFunc;
 
    s_startserver_start_action.generic.type = MTYPE_ACTION;
    s_startserver_start_action.generic.name = " begin";
    s_startserver_start_action.generic.flags= QMF_LEFT_JUSTIFY;
    s_startserver_start_action.generic.x    = 24 * vid_hudscale->value;
    s_startserver_start_action.generic.y    = 128 * vid_hudscale->value;
    s_startserver_start_action.generic.callback = StartServerActionFunc;
 
    Menu_AddItem( &s_startserver_menu, &s_startmap_list );
    Menu_AddItem( &s_startserver_menu, &s_rules_box );
    Menu_AddItem( &s_startserver_menu, &s_timelimit_field );
    Menu_AddItem( &s_startserver_menu, &s_fraglimit_field );
    Menu_AddItem( &s_startserver_menu, &s_maxclients_field );
    Menu_AddItem( &s_startserver_menu, &s_hostname_field );
    Menu_AddItem( &s_startserver_menu, &s_startserver_dmoptions_action );
    Menu_AddItem( &s_startserver_menu, &s_startserver_start_action );
 
    Menu_Center( &s_startserver_menu );
 
    // call this now to set proper inital state
    RulesChangeFunc ( NULL );
}

Referenced by M_Menu_StartServer_f().

StartServer_MenuKey()

const char* StartServer_MenuKey

(

int

key

)

Definition at line 2740 of file menu.c.

{
    if ( key == K_ESCAPE )
    {
        if ( mapnames )
        {
            int i;
 
            for ( i = 0; i < nummaps; i++ )
                free( mapnames[i] );
            free( mapnames );
        }
        mapnames = 0;
        nummaps = 0;
    }
 
    return Default_MenuKey( &s_startserver_menu, key );
}

Referenced by M_Menu_StartServer_f().

StartServerActionFunc()

void StartServerActionFunc

(

void *

self

)

Definition at line 2448 of file menu.c.

{
    char    startmap[1024];
    int     timelimit;
    int     fraglimit;
    int     maxclients;
    char    *spot;
 
    strcpy( startmap, strchr( mapnames[s_startmap_list.curvalue], '\n' ) + 1 );
 
    maxclients  = atoi( s_maxclients_field.buffer );
    timelimit   = atoi( s_timelimit_field.buffer );
    fraglimit   = atoi( s_fraglimit_field.buffer );
 
    Cvar_SetValue( "maxclients", ClampCvar( 0, maxclients, maxclients ) );
    Cvar_SetValue ("timelimit", ClampCvar( 0, timelimit, timelimit ) );
    Cvar_SetValue ("fraglimit", ClampCvar( 0, fraglimit, fraglimit ) );
    Cvar_Set("hostname", s_hostname_field.buffer );
//  Cvar_SetValue ("deathmatch", !s_rules_box.curvalue );
//  Cvar_SetValue ("coop", s_rules_box.curvalue );
 
//PGM
    if((s_rules_box.curvalue < 2) || (Developer_searchpath(2) != 2))
    {
        Cvar_SetValue ("deathmatch", !s_rules_box.curvalue );
        Cvar_SetValue ("coop", s_rules_box.curvalue );
        Cvar_SetValue ("gamerules", 0 );
    }
    else
    {
        Cvar_SetValue ("deathmatch", 1 );   // deathmatch is always true for rogue games, right?
        Cvar_SetValue ("coop", 0 );         // FIXME - this might need to depend on which game we're running
        Cvar_SetValue ("gamerules", s_rules_box.curvalue );
    }
//PGM
 
    spot = NULL;
    if (s_rules_box.curvalue == 1)      // PGM
    {
        if(Q_stricmp(startmap, "bunk1") == 0)
            spot = "start";
        else if(Q_stricmp(startmap, "mintro") == 0)
            spot = "start";
        else if(Q_stricmp(startmap, "fact1") == 0)
            spot = "start";
        else if(Q_stricmp(startmap, "power1") == 0)
            spot = "pstart";
        else if(Q_stricmp(startmap, "biggun") == 0)
            spot = "bstart";
        else if(Q_stricmp(startmap, "hangar1") == 0)
            spot = "unitstart";
        else if(Q_stricmp(startmap, "city1") == 0)
            spot = "unitstart";
        else if(Q_stricmp(startmap, "boss1") == 0)
            spot = "bosstart";
    }
 
    if (spot)
    {
        if (Com_ServerState())
            Cbuf_AddText ("disconnect\n");
        Cbuf_AddText (va("gamemap \"*%s$%s\"\n", startmap, spot));
    }
    else
    {
        Cbuf_AddText (va("map %s\n", startmap));
    }
 
    M_ForceMenuOff ();
 
    if (mapnames)
    {
        int i;
 
        for (i = 0; i < nummaps; i++)
            free(mapnames[i]);
        free(mapnames);
    }
    mapnames = 0;
    nummaps = 0;
}

Referenced by StartServer_MenuInit().

UpdateCDVolumeFunc()

static void UpdateCDVolumeFunc ( void *  unused )

static

Definition at line 1164 of file menu.c.

{
    Cvar_SetValue( "cd_nocd", !s_options_cdvolume_box.curvalue );
}

Referenced by Options_MenuInit().

UpdateSoundQualityFunc()

static void UpdateSoundQualityFunc ( void *  unused )

static

Definition at line 1189 of file menu.c.

{
    if ( s_options_quality_list.curvalue )
    {
        Cvar_SetValue( "s_khz", 22 );
        Cvar_SetValue( "s_loadas8bit", false );
    }
    else
    {
        Cvar_SetValue( "s_khz", 11 );
        Cvar_SetValue( "s_loadas8bit", true );
    }
    
    Cvar_SetValue( "s_primary", s_options_compatibility_list.curvalue );
 
    update_sound_quality = true;
}

Referenced by Options_MenuInit().

UpdateVolumeFunc()

static void UpdateVolumeFunc ( void *  unused )

static

Definition at line 1159 of file menu.c.

{
    Cvar_SetValue( "s_volume", s_options_sfxvolume_slider.curvalue / 10 );
}

Referenced by Options_MenuInit().

Variable Documentation

bind_grab

int bind_grab

static

Definition at line 620 of file menu.c.

Referenced by KeyBindingFunc(), KeyCursorDrawFunc(), and Keys_MenuKey().

bindnames

char* bindnames[][2]

Definition at line 587 of file menu.c.

Referenced by DrawKeyBindingFunc(), KeyBindingFunc(), Keys_MenuInit(), and Keys_MenuKey().

credits

const char** credits

static

Definition at line 1428 of file menu.c.

Referenced by M_Credits_MenuDraw(), and M_Menu_Credits_f().

credits_start_time

int credits_start_time

static

Definition at line 1427 of file menu.c.

Referenced by M_Credits_MenuDraw(), and M_Menu_Credits_f().

creditsBuffer

char* creditsBuffer

static

Definition at line 1430 of file menu.c.

Referenced by M_Credits_Key(), and M_Menu_Credits_f().

creditsIndex

char* creditsIndex[256]

static

Definition at line 1429 of file menu.c.

Referenced by M_Menu_Credits_f().

dmoptions_statusbar

char dmoptions_statusbar[128]

static

Definition at line 2772 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

idcredits

const char* idcredits[]

static

Definition at line 1431 of file menu.c.

Referenced by M_Menu_Credits_f().

in_joystick

cvar_t* in_joystick

Definition at line 56 of file in_win.c.

Referenced by ControlsSetMenuItemValues(), IN_Init(), and IN_JoyMove().

keys_cursor

int keys_cursor

Definition at line 619 of file menu.c.

local_server_names

char local_server_names[MAX_LOCAL_SERVERS][80]

static

Definition at line 2234 of file menu.c.

Referenced by JoinServer_MenuInit(), JoinServerFunc(), M_AddToServerList(), and SearchLocalGames().

local_server_netadr

netadr_t local_server_netadr[MAX_LOCAL_SERVERS]

static

Definition at line 2237 of file menu.c.

Referenced by JoinServerFunc(), and M_AddToServerList().

m_drawfunc

void(* m_drawfunc) (void)

Definition at line 63 of file menu.c.

Referenced by M_Draw(), M_ForceMenuOff(), M_PopMenu(), and M_PushMenu().

m_entersound

qboolean m_entersound

Definition at line 60 of file menu.c.

Referenced by M_Draw(), M_Main_Key(), and M_PushMenu().

m_game_cursor

int m_game_cursor

static

Definition at line 1899 of file menu.c.

Referenced by M_Menu_Game_f().

m_keyfunc

const char*(* m_keyfunc) (int key)

Definition at line 64 of file menu.c.

Referenced by M_ForceMenuOff(), M_Keydown(), M_PopMenu(), and M_PushMenu().

m_layers

menulayer_t m_layers[MAX_MENU_DEPTH]

Definition at line 78 of file menu.c.

Referenced by M_PopMenu(), and M_PushMenu().

m_main_cursor

int m_main_cursor

static

Definition at line 30 of file menu.c.

Referenced by M_Main_Draw(), and M_Main_Key().

m_menudepth

int m_menudepth

Definition at line 79 of file menu.c.

Referenced by M_ForceMenuOff(), M_PopMenu(), and M_PushMenu().

m_num_servers

int m_num_servers

Definition at line 2230 of file menu.c.

Referenced by JoinServerFunc(), M_AddToServerList(), and SearchLocalGames().

m_savestrings

char m_savestrings[MAX_SAVEGAMES][32]

Definition at line 2052 of file menu.c.

Referenced by Create_Savestrings(), LoadGame_MenuInit(), and SaveGame_MenuInit().

m_savevalid

qboolean m_savevalid[MAX_SAVEGAMES]

Definition at line 2053 of file menu.c.

Referenced by Create_Savestrings(), and LoadGameCallback().

mapnames

char** mapnames

static

Definition at line 2392 of file menu.c.

Referenced by StartServer_MenuInit(), StartServer_MenuKey(), and StartServerActionFunc().

menu_in_sound

char* menu_in_sound = "misc/menu1.wav"

static

Definition at line 37 of file menu.c.

Referenced by Keys_MenuKey(), and M_Draw().

menu_move_sound

char* menu_move_sound = "misc/menu2.wav"

static

Definition at line 38 of file menu.c.

Referenced by Default_MenuKey(), and M_Main_Key().

menu_out_sound

char* menu_out_sound = "misc/menu3.wav"

static

Definition at line 39 of file menu.c.

Referenced by Default_MenuKey(), Keys_MenuKey(), M_Credits_Key(), and M_PopMenu().

nummaps

int nummaps

static

Definition at line 2393 of file menu.c.

Referenced by R_BuildLightMap(), StartServer_MenuInit(), StartServer_MenuKey(), and StartServerActionFunc().

rate_names

const char* rate_names[]

static

Initial value:

= { "28.8 Modem", "33.6 Modem", "Single ISDN",
    "Dual ISDN/Cable", "T1/LAN", "User defined", 0 }

Definition at line 3407 of file menu.c.

Referenced by PlayerConfig_MenuInit().

rate_tbl

int rate_tbl[] = { 2500, 3200, 5000, 10000, 25000, 0 }

static

Definition at line 3406 of file menu.c.

Referenced by PlayerConfig_MenuInit(), and RateCallback().

roguecredits

const char* roguecredits[]

static

Definition at line 1663 of file menu.c.

Referenced by M_Menu_Credits_f().

s_addressbook_fields

menufield_s s_addressbook_fields[NUM_ADDRESSBOOK_ENTRIES]

static

Definition at line 3309 of file menu.c.

Referenced by AddressBook_MenuInit(), and AddressBook_MenuKey().

s_addressbook_menu

menuframework_s s_addressbook_menu

static

Definition at line 3308 of file menu.c.

Referenced by AddressBook_MenuDraw(), AddressBook_MenuInit(), and AddressBook_MenuKey().

s_allow_download_box

menulist_s s_allow_download_box

static

Definition at line 3178 of file menu.c.

Referenced by DownloadCallback(), and DownloadOptions_MenuInit().

s_allow_download_maps_box

menulist_s s_allow_download_maps_box

static

Definition at line 3179 of file menu.c.

Referenced by DownloadCallback(), and DownloadOptions_MenuInit().

s_allow_download_models_box

menulist_s s_allow_download_models_box

static

Definition at line 3180 of file menu.c.

Referenced by DownloadCallback(), and DownloadOptions_MenuInit().

s_allow_download_players_box

menulist_s s_allow_download_players_box

static

Definition at line 3181 of file menu.c.

Referenced by DownloadCallback(), and DownloadOptions_MenuInit().

s_allow_download_sounds_box

menulist_s s_allow_download_sounds_box

static

Definition at line 3182 of file menu.c.

Referenced by DownloadCallback(), and DownloadOptions_MenuInit().

s_allow_exit_box

menulist_s s_allow_exit_box

static

Definition at line 2787 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_armor_box

menulist_s s_armor_box

static

Definition at line 2786 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_blankline

menuseparator_s s_blankline

static

Definition at line 1908 of file menu.c.

Referenced by Game_MenuInit().

s_credits_action

menuaction_s s_credits_action

static

Definition at line 1907 of file menu.c.

Referenced by Game_MenuInit().

s_dmoptions_menu

menuframework_s s_dmoptions_menu

static

Definition at line 2774 of file menu.c.

Referenced by DMOptions_MenuDraw(), DMOptions_MenuInit(), and DMOptions_MenuKey().

s_download_title

menuseparator_s s_download_title

static

Definition at line 3177 of file menu.c.

Referenced by DownloadOptions_MenuInit().

s_downloadoptions_menu

menuframework_s s_downloadoptions_menu

static

Definition at line 3175 of file menu.c.

Referenced by DownloadOptions_MenuDraw(), DownloadOptions_MenuInit(), and DownloadOptions_MenuKey().

s_easy_game_action

menuaction_s s_easy_game_action

static

Definition at line 1902 of file menu.c.

Referenced by Game_MenuInit().

s_falls_box

menulist_s s_falls_box

static

Definition at line 2777 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_fixed_fov_box

menulist_s s_fixed_fov_box

static

Definition at line 2789 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_force_respawn_box

menulist_s s_force_respawn_box

static

Definition at line 2785 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_fraglimit_field

menufield_s s_fraglimit_field

static

Definition at line 2398 of file menu.c.

Referenced by StartServer_MenuInit(), and StartServerActionFunc().

s_friendlyfire_box

menulist_s s_friendlyfire_box

static

Definition at line 2776 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_game_menu

menuframework_s s_game_menu

static

Definition at line 1901 of file menu.c.

Referenced by Game_MenuDraw(), Game_MenuInit(), and Game_MenuKey().

s_hard_game_action

menuaction_s s_hard_game_action

static

Definition at line 1904 of file menu.c.

Referenced by Game_MenuInit().

s_health_box

menulist_s s_health_box

static

Definition at line 2781 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_hostname_field

menufield_s s_hostname_field

static

Definition at line 2400 of file menu.c.

Referenced by StartServer_MenuInit(), and StartServerActionFunc().

s_infinite_ammo_box

menulist_s s_infinite_ammo_box

static

Definition at line 2788 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_instant_powerups_box

menulist_s s_instant_powerups_box

static

Definition at line 2779 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_join_network_server_action

menuaction_s s_join_network_server_action

static

Definition at line 507 of file menu.c.

Referenced by Multiplayer_MenuInit().

s_joinserver_address_book_action

menuaction_s s_joinserver_address_book_action

static

Definition at line 2227 of file menu.c.

Referenced by JoinServer_MenuInit().

s_joinserver_menu

menuframework_s s_joinserver_menu

static

Definition at line 2224 of file menu.c.

Referenced by JoinServer_MenuDraw(), JoinServer_MenuInit(), and JoinServer_MenuKey().

s_joinserver_search_action

menuaction_s s_joinserver_search_action

static

Definition at line 2226 of file menu.c.

Referenced by JoinServer_MenuInit().

s_joinserver_server_actions

menuaction_s s_joinserver_server_actions[MAX_LOCAL_SERVERS]

static

Definition at line 2228 of file menu.c.

Referenced by JoinServer_MenuInit(), and JoinServerFunc().

s_joinserver_server_title

menuseparator_s s_joinserver_server_title

static

Definition at line 2225 of file menu.c.

Referenced by JoinServer_MenuInit().

s_keys_attack_action

menuaction_s s_keys_attack_action

static

Definition at line 623 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_backpedal_action

menuaction_s s_keys_backpedal_action

static

Definition at line 628 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_center_view_action

menuaction_s s_keys_center_view_action

static

Definition at line 637 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_change_weapon_action

menuaction_s s_keys_change_weapon_action

static

Definition at line 624 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_change_weapon_last_action

menuaction_s s_keys_change_weapon_last_action

static

Definition at line 626 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_change_weapon_prev_action

menuaction_s s_keys_change_weapon_prev_action

static

Definition at line 625 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_help_computer_action

menuaction_s s_keys_help_computer_action

static

Definition at line 648 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_inv_drop_action

menuaction_s s_keys_inv_drop_action

static

Definition at line 644 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_inv_next_action

menuaction_s s_keys_inv_next_action

static

Definition at line 646 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_inv_prev_action

menuaction_s s_keys_inv_prev_action

static

Definition at line 645 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_inv_use_action

menuaction_s s_keys_inv_use_action

static

Definition at line 643 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_inventory_action

menuaction_s s_keys_inventory_action

static

Definition at line 642 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_keyboard_look_action

menuaction_s s_keys_keyboard_look_action

static

Definition at line 639 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_look_down_action

menuaction_s s_keys_look_down_action

static

Definition at line 636 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_look_up_action

menuaction_s s_keys_look_up_action

static

Definition at line 635 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_menu

menuframework_s s_keys_menu

static

Definition at line 622 of file menu.c.

Referenced by KeyBindingFunc(), Keys_MenuDraw(), Keys_MenuInit(), and Keys_MenuKey().

s_keys_mouse_look_action

menuaction_s s_keys_mouse_look_action

static

Definition at line 638 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_move_down_action

menuaction_s s_keys_move_down_action

static

Definition at line 641 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_move_up_action

menuaction_s s_keys_move_up_action

static

Definition at line 640 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_run_action

menuaction_s s_keys_run_action

static

Definition at line 631 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_sidestep_action

menuaction_s s_keys_sidestep_action

static

Definition at line 634 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_step_left_action

menuaction_s s_keys_step_left_action

static

Definition at line 632 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_step_right_action

menuaction_s s_keys_step_right_action

static

Definition at line 633 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_turn_left_action

menuaction_s s_keys_turn_left_action

static

Definition at line 629 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_turn_right_action

menuaction_s s_keys_turn_right_action

static

Definition at line 630 of file menu.c.

Referenced by Keys_MenuInit().

s_keys_walk_forward_action

menuaction_s s_keys_walk_forward_action

static

Definition at line 627 of file menu.c.

Referenced by Keys_MenuInit().

s_load_game_action

menuaction_s s_load_game_action

static

Definition at line 1905 of file menu.c.

Referenced by Game_MenuInit().

s_loadgame_actions

menuaction_s s_loadgame_actions[MAX_SAVEGAMES]

static

Definition at line 2050 of file menu.c.

Referenced by LoadGame_MenuInit().

s_loadgame_menu

menuframework_s s_loadgame_menu

static

Definition at line 2049 of file menu.c.

Referenced by LoadGame_MenuDraw(), LoadGame_MenuInit(), LoadGame_MenuKey(), and SaveGame_MenuKey().

s_maxclients_field

menufield_s s_maxclients_field

static

Definition at line 2399 of file menu.c.

Referenced by RulesChangeFunc(), StartServer_MenuInit(), and StartServerActionFunc().

s_medium_game_action

menuaction_s s_medium_game_action

static

Definition at line 1903 of file menu.c.

Referenced by Game_MenuInit().

s_multiplayer_menu

menuframework_s s_multiplayer_menu

static

Definition at line 506 of file menu.c.

Referenced by M_Menu_PlayerConfig_f(), Multiplayer_MenuDraw(), Multiplayer_MenuInit(), and Multiplayer_MenuKey().

s_no_mines_box

menulist_s s_no_mines_box

static

Definition at line 2793 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_no_nukes_box

menulist_s s_no_nukes_box

static

Definition at line 2794 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_no_spheres_box

menulist_s s_no_spheres_box

static

Definition at line 2796 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_numplayermodels

int s_numplayermodels

static

Definition at line 3404 of file menu.c.

Referenced by PlayerConfig_MenuInit(), PlayerConfig_MenuKey(), and PlayerConfig_ScanDirectories().

s_options_alwaysrun_box

menulist_s s_options_alwaysrun_box

static

Definition at line 1052 of file menu.c.

Referenced by AlwaysRunFunc(), ControlsSetMenuItemValues(), and Options_MenuInit().

s_options_cdvolume_box

menulist_s s_options_cdvolume_box

static

Definition at line 1059 of file menu.c.

Referenced by ControlsSetMenuItemValues(), Options_MenuInit(), and UpdateCDVolumeFunc().

s_options_compatibility_list

menulist_s s_options_compatibility_list

static

Definition at line 1061 of file menu.c.

Referenced by Options_MenuInit(), and UpdateSoundQualityFunc().

s_options_console_action

menulist_s s_options_console_action

static

Definition at line 1062 of file menu.c.

Referenced by Options_MenuInit().

s_options_crosshair_box

menulist_s s_options_crosshair_box

static

Definition at line 1056 of file menu.c.

Referenced by ControlsSetMenuItemValues(), CrosshairFunc(), and Options_MenuInit().

s_options_customize_options_action

menuaction_s s_options_customize_options_action

static

Definition at line 1048 of file menu.c.

Referenced by Options_MenuInit().

s_options_defaults_action

menuaction_s s_options_defaults_action

static

Definition at line 1047 of file menu.c.

Referenced by Options_MenuInit().

s_options_freelook_box

menulist_s s_options_freelook_box

static

Definition at line 1050 of file menu.c.

Referenced by ControlsSetMenuItemValues(), FreeLookFunc(), and Options_MenuInit().

s_options_invertmouse_box

menulist_s s_options_invertmouse_box

static

Definition at line 1053 of file menu.c.

Referenced by ControlsSetMenuItemValues(), and Options_MenuInit().

s_options_joystick_box

menulist_s s_options_joystick_box

static

Definition at line 1058 of file menu.c.

Referenced by ControlsSetMenuItemValues(), JoystickFunc(), and Options_MenuInit().

s_options_lookspring_box

menulist_s s_options_lookspring_box

static

Definition at line 1054 of file menu.c.

Referenced by ControlsSetMenuItemValues(), and Options_MenuInit().

s_options_lookstrafe_box

menulist_s s_options_lookstrafe_box

static

Definition at line 1055 of file menu.c.

Referenced by ControlsSetMenuItemValues(), and Options_MenuInit().

s_options_menu

menuframework_s s_options_menu

static

Definition at line 1046 of file menu.c.

Referenced by Options_MenuDraw(), Options_MenuInit(), and Options_MenuKey().

s_options_noalttab_box

menulist_s s_options_noalttab_box

static

Definition at line 1051 of file menu.c.

Referenced by ControlsSetMenuItemValues(), and NoAltTabFunc().

s_options_quality_list

menulist_s s_options_quality_list

static

Definition at line 1060 of file menu.c.

Referenced by ControlsSetMenuItemValues(), Options_MenuInit(), and UpdateSoundQualityFunc().

s_options_sensitivity_slider

menuslider_s s_options_sensitivity_slider

static

Definition at line 1049 of file menu.c.

Referenced by ControlsSetMenuItemValues(), MouseSpeedFunc(), and Options_MenuInit().

s_options_sfxvolume_slider

menuslider_s s_options_sfxvolume_slider

static

Definition at line 1057 of file menu.c.

Referenced by ControlsSetMenuItemValues(), Options_MenuInit(), and UpdateVolumeFunc().

s_player_config_menu

menuframework_s s_player_config_menu

static

Definition at line 3379 of file menu.c.

Referenced by PlayerConfig_MenuDraw(), PlayerConfig_MenuInit(), and PlayerConfig_MenuKey().

s_player_download_action

menuaction_s s_player_download_action

static

Definition at line 3389 of file menu.c.

Referenced by PlayerConfig_MenuInit().

s_player_hand_title

menuseparator_s s_player_hand_title

static

Definition at line 3387 of file menu.c.

Referenced by PlayerConfig_MenuInit().

s_player_handedness_box

menulist_s s_player_handedness_box

static

Definition at line 3383 of file menu.c.

Referenced by HandednessCallback(), and PlayerConfig_MenuInit().

s_player_model_box

menulist_s s_player_model_box

static

Definition at line 3381 of file menu.c.

Referenced by ModelCallback(), PlayerConfig_MenuDraw(), PlayerConfig_MenuInit(), and PlayerConfig_MenuKey().

s_player_model_title

menuseparator_s s_player_model_title

static

Definition at line 3386 of file menu.c.

Referenced by PlayerConfig_MenuInit().

s_player_name_field

menufield_s s_player_name_field

static

Definition at line 3380 of file menu.c.

Referenced by PlayerConfig_MenuInit(), and PlayerConfig_MenuKey().

s_player_rate_box

menulist_s s_player_rate_box

static

Definition at line 3384 of file menu.c.

Referenced by PlayerConfig_MenuInit(), and RateCallback().

s_player_rate_title

menuseparator_s s_player_rate_title

static

Definition at line 3388 of file menu.c.

Referenced by PlayerConfig_MenuInit().

s_player_setup_action

menuaction_s s_player_setup_action

static

Definition at line 509 of file menu.c.

Referenced by Multiplayer_MenuInit().

s_player_skin_box

menulist_s s_player_skin_box

static

Definition at line 3382 of file menu.c.

Referenced by ModelCallback(), PlayerConfig_MenuDraw(), PlayerConfig_MenuInit(), and PlayerConfig_MenuKey().

s_player_skin_title

menuseparator_s s_player_skin_title

static

Definition at line 3385 of file menu.c.

Referenced by PlayerConfig_MenuInit().

s_pmi

playermodelinfo_s s_pmi[MAX_PLAYERMODELS]

static

Definition at line 3402 of file menu.c.

Referenced by ModelCallback(), PlayerConfig_MenuDraw(), PlayerConfig_MenuInit(), PlayerConfig_MenuKey(), and PlayerConfig_ScanDirectories().

s_pmnames

char* s_pmnames[MAX_PLAYERMODELS]

static

Definition at line 3403 of file menu.c.

Referenced by PlayerConfig_MenuInit().

s_powerups_box

menulist_s s_powerups_box

static

Definition at line 2780 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_quad_drop_box

menulist_s s_quad_drop_box

static

Definition at line 2790 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_rules_box

menulist_s s_rules_box

static

Definition at line 2402 of file menu.c.

Referenced by DMOptionsFunc(), RulesChangeFunc(), StartServer_MenuInit(), and StartServerActionFunc().

s_samelevel_box

menulist_s s_samelevel_box

static

Definition at line 2784 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_save_game_action

menuaction_s s_save_game_action

static

Definition at line 1906 of file menu.c.

Referenced by Game_MenuInit().

s_savegame_actions

menuaction_s s_savegame_actions[MAX_SAVEGAMES]

static

Definition at line 2149 of file menu.c.

Referenced by SaveGame_MenuInit().

s_savegame_menu

static menuframework_s s_savegame_menu

static

Definition at line 2047 of file menu.c.

Referenced by LoadGame_MenuKey(), SaveGame_MenuDraw(), SaveGame_MenuInit(), and SaveGame_MenuKey().

s_spawn_farthest_box

menulist_s s_spawn_farthest_box

static

Definition at line 2782 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_stack_double_box

menulist_s s_stack_double_box

static

Definition at line 2795 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_start_network_server_action

menuaction_s s_start_network_server_action

static

Definition at line 508 of file menu.c.

Referenced by Multiplayer_MenuInit().

s_startmap_list

menulist_s s_startmap_list

static

Definition at line 2401 of file menu.c.

Referenced by StartServer_MenuInit(), and StartServerActionFunc().

s_startserver_dmoptions_action

menuaction_s s_startserver_dmoptions_action

static

Definition at line 2396 of file menu.c.

Referenced by RulesChangeFunc(), and StartServer_MenuInit().

s_startserver_menu

menuframework_s s_startserver_menu

static

Definition at line 2391 of file menu.c.

Referenced by StartServer_MenuDraw(), StartServer_MenuInit(), and StartServer_MenuKey().

s_startserver_start_action

menuaction_s s_startserver_start_action

static

Definition at line 2395 of file menu.c.

Referenced by StartServer_MenuInit().

s_teamplay_box

menulist_s s_teamplay_box

static

Definition at line 2783 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

s_timelimit_field

menufield_s s_timelimit_field

static

Definition at line 2397 of file menu.c.

Referenced by StartServer_MenuInit(), and StartServerActionFunc().

s_weapons_stay_box

menulist_s s_weapons_stay_box

static

Definition at line 2778 of file menu.c.

Referenced by DMFlagCallback(), and DMOptions_MenuInit().

search_local_games

qboolean search_local_games = false

static

Definition at line 33 of file menu.c.

Referenced by JoinServer_MenuDraw(), and SearchLocalGames().

update_sound_quality

qboolean update_sound_quality = false

static

Definition at line 32 of file menu.c.

Referenced by Options_MenuDraw(), and UpdateSoundQualityFunc().

vid_hudscale

cvar_t* vid_hudscale

Definition at line 48 of file vid_dll.c.

Referenced by AddressBook_MenuInit(), DMOptions_MenuInit(), DownloadOptions_MenuInit(), DrawKeyBindingFunc(), Game_MenuInit(), JoinServer_MenuDraw(), JoinServer_MenuInit(), KeyCursorDrawFunc(), Keys_MenuInit(), LoadGame_MenuInit(), M_Banner(), M_Credits_MenuDraw(), M_DrawTextBox(), M_Main_Draw(), M_Print(), M_PrintWhite(), Multiplayer_MenuInit(), Options_MenuDraw(), Options_MenuInit(), PlayerConfig_MenuDraw(), PlayerConfig_MenuInit(), SaveGame_MenuInit(), and StartServer_MenuInit().

win_noalttab

cvar_t* win_noalttab

static

Definition at line 1043 of file menu.c.

Referenced by ControlsSetMenuItemValues(), and Options_MenuInit().

xatcredits

const char* xatcredits[]

static

Definition at line 1522 of file menu.c.

Referenced by M_Menu_Credits_f().