thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Refactor cvar definitions completely, move everything to cvars.cpp

Browse source 
- No need to call CV_RegisterVar
- Cvar definitions live in only one file, easier to locate
- Organized into sections -- netvars, cheats, etc.
- Use builder pattern to initialize cvars
- Still need to extern if you want to read the cvar value
This commit is contained in:
James R 2023-08-25 06:14:34 -07:00
parent 6a3d298d00
commit 6c0b042eed
51 changed files with 1681 additions and 1602 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/CMakeLists.txt
View file

@ -24,6 +24,7 @@ add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32
am_map.c
command.c
console.c
cvars.cpp
font.c
hu_stuff.c
i_time.c

19
src/command.c
View file

@ -60,7 +60,6 @@ static void COM_Choose_f(void);
static void COM_ChooseWeighted_f(void);
static void COM_Reset_f(void);
static void CV_EnforceExecVersion(void);
static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr);
static boolean CV_Command(void);
@ -81,15 +80,6 @@ CV_PossibleValue_t CV_Unsigned[] = {{0, "MIN"}, {999999999, "MAX"}, {0, NULL}};
CV_PossibleValue_t CV_Natural[] = {{1, "MIN"}, {999999999, "MAX"}, {0, NULL}};
CV_PossibleValue_t CV_TrueFalse[] = {{0, "False"}, {1, "True"}, {0, NULL}};
// Cheats
#ifdef DEVELOP
#define VALUE "On"
#else
#define VALUE "Off"
#endif
consvar_t cv_cheats = CVAR_INIT ("cheats", VALUE, CV_NETVAR|CV_CALL|CV_NOINIT, CV_OnOff, CV_CheatsChanged);
#undef VALUE
// SRB2kart
CV_PossibleValue_t kartspeed_cons_t[] = {
{KARTSPEED_AUTO, "Auto"},
@ -119,7 +109,6 @@ CV_PossibleValue_t kartvoices_cons_t[] = {{0, "Never"}, {1, "Tasteful"}, {2, "Me
// Also set CV_HIDDEN during runtime, after config is loaded
static boolean execversion_enabled = false;
consvar_t cv_execversion = CVAR_INIT ("execversion","1",CV_CALL,CV_Unsigned, CV_EnforceExecVersion);
// for default joyaxis detection
#if 0
@ -369,7 +358,10 @@ void COM_Init(void)
VS_Alloc(&com_text, COM_BUF_SIZE);
// cheats is a special cvar, so register it ASAP
CV_RegisterVar(&cv_cheats);
{
extern struct CVarList *cvlist_command;
CV_RegisterList(cvlist_command);
}
// add standard commands
COM_AddCommand("alias", COM_Alias_f);
@ -2335,7 +2327,8 @@ void CV_ToggleExecVersion(boolean enable)
execversion_enabled = enable;
}
static void CV_EnforceExecVersion(void)
void CV_EnforceExecVersion(void);
void CV_EnforceExecVersion(void)
{
if (!execversion_enabled)
CV_StealthSetValue(&cv_execversion, EXECVERSION);

43
src/command.h
View file

@ -162,11 +162,50 @@ struct consvar_t //NULL, NULL, 0, NULL, NULL |, 0, NULL, NULL, 0, 0, NULL
// used only with CV_NETVAR
char changed; // has variable been changed by the user? 0 = no, 1 = yes
consvar_t *next;
#ifdef __cplusplus
struct Builder;
consvar_t& operator=(Builder&);
consvar_t& operator=(Builder&& builder) { return *this = builder; }
consvar_t(Builder& builder) { *this = builder; }
consvar_t(Builder&& builder) : consvar_t(builder) {}
explicit consvar_t() { memset(this, 0, sizeof(consvar_t)); } // all fields MUST be initialized to zero!!
// Since copy constructors needed to be defined, consvar_t
// is no longer an aggregate and cannot be initialized
// using brace initialization, like it can in C. The
// following constructor matches CVAR_INIT.
// TODO: remove this along with CVAR_INIT macro
consvar_t(
const char* const name_,
const char* const defaultvalue_,
INT32 const flags_,
CV_PossibleValue_t* const PossibleValue_,
void (*const func_)(void)
) :
consvar_t{}
{
name = name_;
defaultvalue = defaultvalue_;
flags = flags_;
PossibleValue = PossibleValue_;
func = func_;
}
#endif
};
struct CVarList;
// TODO: remove this macro completely and only use consvar_t::Builder
/* name, defaultvalue, flags, PossibleValue, func */
#ifdef __cplusplus
#define CVAR_INIT consvar_t
#else
#define CVAR_INIT( ... ) \
{ __VA_ARGS__, 0, NULL, NULL, {0, {NULL}}, 0U, (char)0, NULL }
#endif
extern CV_PossibleValue_t CV_OnOff[];
extern CV_PossibleValue_t CV_YesNo[];
@ -179,6 +218,7 @@ extern CV_PossibleValue_t CV_TrueFalse[];
extern CV_PossibleValue_t kartspeed_cons_t[], dummykartspeed_cons_t[], gpdifficulty_cons_t[];
extern CV_PossibleValue_t kartvoices_cons_t[];
extern consvar_t cv_cheats;
extern consvar_t cv_execversion;
void CV_InitFilterVar(void);
@ -187,6 +227,9 @@ void CV_ToggleExecVersion(boolean enable);
// register a variable for use at the console
void CV_RegisterVar(consvar_t *variable);
// register groups of variables
void CV_RegisterList(struct CVarList *list);
// returns a console variable by name
consvar_t *CV_FindVar(const char *name);

54
src/console.c
View file

@ -70,7 +70,7 @@ static INT32 con_curlines; // vid lines currently used by console
INT32 con_clipviewtop; // (useless)
static UINT8 con_hudlines; // number of console heads up message lines
static UINT8 con_hudlines; // number of console heads up message lines
static UINT32 con_hudtime[MAXHUDLINES]; // remaining time of display for hud msg lines
INT32 con_clearlines; // top screen lines to refresh when view reduced
@ -108,9 +108,6 @@ static void CON_RecalcSize(void);
static void CON_ChangeHeight(void);
static void CON_DrawBackpic(void);
static void CONS_height_Change(void);
static void CONS_hudlines_Change(void);
static void CONS_backcolor_Change(void);
//======================================================================
// CONSOLE VARS AND COMMANDS
@ -123,42 +120,15 @@ static void CONS_backcolor_Change(void);
static char con_buffer[CON_BUFFERSIZE];
// how many seconds the hud messages lasts on the screen
// CV_Unsigned can overflow when multiplied by TICRATE later, so let's use a 3-year limit instead
static CV_PossibleValue_t hudtime_cons_t[] = {{0, "MIN"}, {99999999, "MAX"}, {0, NULL}};
static consvar_t cons_hudtime = CVAR_INIT ("con_hudtime", "5", CV_SAVE, hudtime_cons_t, NULL);
// number of lines displayed on the HUD
static CV_PossibleValue_t hudlines_cons_t[] = {{0, "MIN"}, {MAXHUDLINES, "MAX"}, {0, NULL}};
static consvar_t cons_hudlines = CVAR_INIT ("con_hudlines", "5", CV_CALL|CV_SAVE, hudlines_cons_t, CONS_hudlines_Change);
// number of lines console move per frame
// (con_speed needs a limit, apparently)
static CV_PossibleValue_t speed_cons_t[] = {{0, "MIN"}, {64, "MAX"}, {0, NULL}};
static consvar_t cons_speed = CVAR_INIT ("con_speed", "8", CV_SAVE, speed_cons_t, NULL);
// percentage of screen height to use for console
static consvar_t cons_height = CVAR_INIT ("con_height", "50", CV_CALL|CV_SAVE, CV_Unsigned, CONS_height_Change);
static CV_PossibleValue_t backpic_cons_t[] = {{0, "translucent"}, {1, "picture"}, {0, NULL}};
// whether to use console background picture, or translucent mode
static consvar_t cons_backpic = CVAR_INIT ("con_backpic", "translucent", CV_SAVE, backpic_cons_t, NULL);
static CV_PossibleValue_t backcolor_cons_t[] = {{0, "White"}, {1, "Black"}, {2, "Sepia"},
{3, "Brown"}, {4, "Pink"}, {5, "Red"},
{6, "Orange"}, {7, "Gold"}, {8, "Yellow"},
{9, "Peridot"}, {10,"Green"}, {11,"Aquamarine"},
{12,"Cyan"}, {13,"Steel"}, {14,"Blue"},
{15,"Purple"}, {16,"Magenta"}, {17,"Lavender"},
{18,"Rose"},
{0, NULL}};
consvar_t cons_backcolor = CVAR_INIT ("con_backcolor", "Black", CV_CALL|CV_SAVE, backcolor_cons_t, CONS_backcolor_Change);
CV_PossibleValue_t hudlines_cons_t[] = {{0, "MIN"}, {MAXHUDLINES, "MAX"}, {0, NULL}};
static void CON_Print(char *msg);
// Change the console height on demand
//
static void CONS_height_Change(void)
void CONS_height_Change(void);
void CONS_height_Change(void)
{
Lock_state();
@ -170,7 +140,8 @@ static void CONS_height_Change(void)
//
//
static void CONS_hudlines_Change(void)
void CONS_hudlines_Change(void);
void CONS_hudlines_Change(void)
{
INT32 i;
@ -334,7 +305,8 @@ void CON_SetupBackColormap(void)
CON_SetupBackColormapEx(1, true); // default to gray
}
static void CONS_backcolor_Change(void)
void CONS_backcolor_Change(void);
void CONS_backcolor_Change(void)
{
CON_SetupBackColormapEx(cons_backcolor.value, false);
}
@ -460,12 +432,10 @@ void CON_Init(void)
Unlock_state();
CV_RegisterVar(&cons_hudtime);
CV_RegisterVar(&cons_hudlines);
CV_RegisterVar(&cons_speed);
CV_RegisterVar(&cons_height);
CV_RegisterVar(&cons_backpic);
CV_RegisterVar(&cons_backcolor);
{
extern struct CVarList *cvlist_console;
CV_RegisterList(cvlist_console);
}
COM_AddCommand("bind", CONS_Bind_f);
}
else

2
src/console.h
View file

@ -68,7 +68,7 @@ extern INT32 con_clearlines; // lines of top of screen to refresh
extern boolean con_hudupdate; // hud messages have changed, need refresh
extern UINT32 con_scalefactor; // console text scale factor
extern consvar_t cons_backcolor;
extern consvar_t cons_hudtime, cons_hudlines, cons_speed, cons_height, cons_backpic, cons_backcolor;
extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *orangemap,\
*skymap, *goldmap, *lavendermap, *aquamap, *magentamap, *pinkmap, *brownmap, *tanmap;

1380
src/cvars.cpp Normal file
View file

File diff suppressed because it is too large Load diff

73
src/d_clisrv.c
View file

@ -122,8 +122,6 @@ static tic_t reference_lag;
static UINT8 spike_time;
static tic_t lowest_lag;
boolean server_lagless;
static CV_PossibleValue_t mindelay_cons_t[] = {{0, "MIN"}, {30, "MAX"}, {0, NULL}};
consvar_t cv_mindelay = CVAR_INIT ("mindelay", "2", CV_SAVE, mindelay_cons_t, NULL);
SINT8 nodetoplayer[MAXNETNODES];
SINT8 nodetoplayer2[MAXNETNODES]; // say the numplayer for this node if any (splitscreen)
@ -182,20 +180,6 @@ uint8_t priorKeys[MAXPLAYERS][PUBKEYLENGTH]; // Make a note of keys before consu
boolean serverisfull = false; //lets us be aware if the server was full after we check files, but before downloading, so we can ask if the user still wants to download or not
tic_t firstconnectattempttime = 0;
consvar_t cv_allowguests = CVAR_INIT ("allowguests", "On", CV_SAVE, CV_OnOff, NULL);
#ifdef DEVELOP
consvar_t cv_badjoin = CVAR_INIT ("badjoin", "0", 0, CV_Unsigned, NULL);
consvar_t cv_badtraffic = CVAR_INIT ("badtraffic", "0", 0, CV_Unsigned, NULL);
consvar_t cv_badresponse = CVAR_INIT ("badresponse", "0", 0, CV_Unsigned, NULL);
consvar_t cv_noresponse = CVAR_INIT ("noresponse", "0", 0, CV_Unsigned, NULL);
consvar_t cv_nochallenge = CVAR_INIT ("nochallenge", "0", 0, CV_Unsigned, NULL);
consvar_t cv_badresults = CVAR_INIT ("badresults", "0", 0, CV_Unsigned, NULL);
consvar_t cv_noresults = CVAR_INIT ("noresults", "0", 0, CV_Unsigned, NULL);
consvar_t cv_badtime = CVAR_INIT ("badtime", "0", 0, CV_Unsigned, NULL);
consvar_t cv_badip = CVAR_INIT ("badip", "0", 0, CV_Unsigned, NULL);
#endif
// engine
// Must be a power of two
@ -219,17 +203,6 @@ ticcmd_t netcmds[BACKUPTICS][MAXPLAYERS];
static textcmdtic_t *textcmds[TEXTCMD_HASH_SIZE] = {NULL};
consvar_t cv_showjoinaddress = CVAR_INIT ("showjoinaddress", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
static CV_PossibleValue_t playbackspeed_cons_t[] = {{1, "MIN"}, {10, "MAX"}, {0, NULL}};
consvar_t cv_playbackspeed = CVAR_INIT ("playbackspeed", "1", 0, playbackspeed_cons_t, NULL);
consvar_t cv_httpsource = CVAR_INIT ("http_source", "", CV_SAVE, NULL, NULL);
consvar_t cv_kicktime = CVAR_INIT ("kicktime", "20", CV_SAVE, CV_Unsigned, NULL);
consvar_t cv_gamestochat = CVAR_INIT ("gamestochat", "0", CV_SAVE, CV_Unsigned, NULL);
static tic_t stop_spamming[MAXPLAYERS];
// Generate a message for an authenticating client to sign, with some guarantees about who we are.
@ -1393,10 +1366,11 @@ static void SV_SendSaveGame(INT32 node, boolean resending)
#ifdef DUMPCONSISTENCY
#define TMPSAVENAME "badmath.sav"
static consvar_t cv_dumpconsistency = CVAR_INIT ("dumpconsistency", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
static void SV_SavedGame(void)
{
extern consvar_t *cv_dumpconsistency;
size_t length;
savebuffer_t save = {0};
char tmpsave[256];
@ -3622,46 +3596,12 @@ static void Command_ResendGamestate(void)
}
}
static CV_PossibleValue_t netticbuffer_cons_t[] = {{0, "MIN"}, {3, "MAX"}, {0, NULL}};
consvar_t cv_netticbuffer = CVAR_INIT ("netticbuffer", "1", CV_SAVE, netticbuffer_cons_t, NULL);
static void Joinable_OnChange(void);
consvar_t cv_allownewplayer = CVAR_INIT ("allowjoin", "On", CV_SAVE|CV_CALL, CV_OnOff, Joinable_OnChange);
#ifdef VANILLAJOINNEXTROUND
consvar_t cv_joinnextround = CVAR_INIT ("joinnextround", "Off", CV_NETVAR, CV_OnOff, NULL); /// \todo not done
#endif
static CV_PossibleValue_t maxplayers_cons_t[] = {{2, "MIN"}, {MAXPLAYERS, "MAX"}, {0, NULL}};
consvar_t cv_maxconnections = CVAR_INIT ("maxconnections", "16", CV_SAVE|CV_CALL, maxplayers_cons_t, Joinable_OnChange);
static CV_PossibleValue_t joindelay_cons_t[] = {{1, "MIN"}, {3600, "MAX"}, {0, "Off"}, {0, NULL}};
consvar_t cv_joindelay = CVAR_INIT ("joindelay", "10", CV_SAVE|CV_NETVAR, joindelay_cons_t, NULL);
// Here for dedicated servers
static CV_PossibleValue_t discordinvites_cons_t[] = {{0, "Admins Only"}, {1, "Everyone"}, {0, NULL}};
consvar_t cv_discordinvites = CVAR_INIT ("discordinvites", "Everyone", CV_SAVE|CV_CALL, discordinvites_cons_t, Joinable_OnChange);
static CV_PossibleValue_t resynchattempts_cons_t[] = {{1, "MIN"}, {20, "MAX"}, {0, "No"}, {0, NULL}};
consvar_t cv_resynchattempts = CVAR_INIT ("resynchattempts", "2", CV_SAVE|CV_NETVAR, resynchattempts_cons_t, NULL);
consvar_t cv_blamecfail = CVAR_INIT ("blamecfail", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
// max file size to send to a player (in kilobytes)
static CV_PossibleValue_t maxsend_cons_t[] = {{0, "MIN"}, {51200, "MAX"}, {0, NULL}};
consvar_t cv_maxsend = CVAR_INIT ("maxsend", "51200", CV_SAVE|CV_NETVAR, maxsend_cons_t, NULL);
consvar_t cv_noticedownload = CVAR_INIT ("noticedownload", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
// Speed of file downloading (in packets per tic)
static CV_PossibleValue_t downloadspeed_cons_t[] = {{1, "MIN"}, {300, "MAX"}, {0, NULL}};
consvar_t cv_downloadspeed = CVAR_INIT ("downloadspeed", "32", CV_SAVE|CV_NETVAR, downloadspeed_cons_t, NULL);
static void Got_AddPlayer(UINT8 **p, INT32 playernum);
static void Got_RemovePlayer(UINT8 **p, INT32 playernum);
static void Got_AddBot(UINT8 **p, INT32 playernum);
static void Joinable_OnChange(void)
void Joinable_OnChange(void);
void Joinable_OnChange(void)
{
UINT8 buf[3];
UINT8 *p = buf;
@ -3710,7 +3650,10 @@ void D_ClientServerInit(void)
RegisterNetXCmd(XD_REMOVEPLAYER, Got_RemovePlayer);
RegisterNetXCmd(XD_ADDBOT, Got_AddBot);
#ifdef DUMPCONSISTENCY
CV_RegisterVar(&cv_dumpconsistency);
{
extern struct CVarList *cvlist_dumpconsistency;
CV_RegisterList(cvlist_dumpconsistency);
}
#endif
D_LoadBan(false);

706
src/d_netcmd.c
View file

File diff suppressed because it is too large Load diff

4
src/discord.c
View file

@ -37,10 +37,6 @@
// length of IP strings
#define IP_SIZE 21
consvar_t cv_discordrp = CVAR_INIT ("discordrp", "On", CV_SAVE|CV_CALL, CV_OnOff, DRPC_UpdatePresence);
consvar_t cv_discordstreamer = CVAR_INIT ("discordstreamer", "Off", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_discordasks = CVAR_INIT ("discordasks", "Yes", CV_SAVE|CV_CALL, CV_YesNo, DRPC_UpdatePresence);
struct discordInfo_s discordInfo;
discordRequest_t *discordRequestList = NULL;

5
src/doomdef.h
View file

@ -745,11 +745,6 @@ extern int
/// Render flats on walls
#define WALLFLATS
// Volume scale is 0-100 in new mixer. 100 is treated as -0dB or 100% gain. No more weirdness to work around SDL_mixer
// problems
#define MAX_VOLUME 100
// Crypto/RRID primitives
#define PUBKEYLENGTH 32 // Enforced by Monocypher EdDSA
#define PRIVKEYLENGTH 64 // Enforced by Monocypher EdDSA

10
src/filesrch.c
View file

@ -308,16 +308,6 @@ closedir (DIR * dirp)
}
#endif
static CV_PossibleValue_t addons_md5_cons_t[] = {{0, "Name"}, {1, "Contents"}, {0, NULL}};
consvar_t cv_addons_md5 = CVAR_INIT ("addons_md5", "Name", CV_SAVE, addons_md5_cons_t, NULL);
consvar_t cv_addons_showall = CVAR_INIT ("addons_showall", "No", CV_SAVE, CV_YesNo, NULL);
consvar_t cv_addons_search_case = CVAR_INIT ("addons_search_case", "No", CV_SAVE, CV_YesNo, NULL);
static CV_PossibleValue_t addons_search_type_cons_t[] = {{0, "Start"}, {1, "Anywhere"}, {0, NULL}};
consvar_t cv_addons_search_type = CVAR_INIT ("addons_search_type", "Anywhere", CV_SAVE, addons_search_type_cons_t, NULL);
char menupath[1024];
size_t menupathindex[menudepth];
size_t menudepthleft = menudepth;

11
src/g_demo.c
View file

@ -56,17 +56,6 @@
#include "k_follower.h"
#include "k_vote.h"
#ifdef TESTERS
static CV_PossibleValue_t recordmultiplayerdemos_cons_t[] = {{2, "Auto Save"}, {0, NULL}};
consvar_t cv_recordmultiplayerdemos = CVAR_INIT ("netdemo_record", "Auto Save", CV_SAVE, recordmultiplayerdemos_cons_t, NULL);
#else
static CV_PossibleValue_t recordmultiplayerdemos_cons_t[] = {{0, "Disabled"}, {1, "Manual Save"}, {2, "Auto Save"}, {0, NULL}};
consvar_t cv_recordmultiplayerdemos = CVAR_INIT ("netdemo_record", "Manual Save", CV_SAVE, recordmultiplayerdemos_cons_t, NULL);
#endif
static CV_PossibleValue_t netdemosyncquality_cons_t[] = {{1, "MIN"}, {35, "MAX"}, {0, NULL}};
consvar_t cv_netdemosyncquality = CVAR_INIT ("netdemo_syncquality", "1", CV_SAVE, netdemosyncquality_cons_t, NULL);
boolean nodrawers; // for comparative timing purposes
boolean noblit; // for comparative timing purposes
tic_t demostarttime; // for comparative timing purposes

133
src/g_game.c
View file

@ -325,115 +325,6 @@ boolean precache = true; // if true, load all graphics at start
UINT16 prevmap, nextmap;
static void weaponPrefChange(void);
static void weaponPrefChange2(void);
static void weaponPrefChange3(void);
static void weaponPrefChange4(void);
static void rumble_off_handle(void);
static void rumble_off_handle2(void);
static void rumble_off_handle3(void);
static void rumble_off_handle4(void);
// don't mind me putting these here, I was lazy to figure out where else I could put those without blowing up the compiler.
// chat timer thingy
static CV_PossibleValue_t chattime_cons_t[] = {{5, "MIN"}, {999, "MAX"}, {0, NULL}};
consvar_t cv_chattime = CVAR_INIT ("chattime", "8", CV_SAVE, chattime_cons_t, NULL);
// chatwidth
static CV_PossibleValue_t chatwidth_cons_t[] = {{64, "MIN"}, {150, "MAX"}, {0, NULL}};
consvar_t cv_chatwidth = CVAR_INIT ("chatwidth", "150", CV_SAVE, chatwidth_cons_t, NULL);
// chatheight
static CV_PossibleValue_t chatheight_cons_t[] = {{6, "MIN"}, {22, "MAX"}, {0, NULL}};
consvar_t cv_chatheight = CVAR_INIT ("chatheight", "8", CV_SAVE, chatheight_cons_t, NULL);
// chat notifications (do you want to hear beeps? I'd understand if you didn't.)
consvar_t cv_chatnotifications = CVAR_INIT ("chatnotifications", "On", CV_SAVE, CV_OnOff, NULL);
// chat spam protection (why would you want to disable that???)
consvar_t cv_chatspamprotection = CVAR_INIT ("chatspamprotection", "On", CV_SAVE, CV_OnOff, NULL);
// minichat text background
consvar_t cv_chatbacktint = CVAR_INIT ("chatbacktint", "On", CV_SAVE, CV_OnOff, NULL);
// old shit console chat. (mostly exists for stuff like terminal, not because I cared if anyone liked the old chat.)
static CV_PossibleValue_t consolechat_cons_t[] = {{0, "Window"}, {1, "Console"}, {2, "Window (Hidden)"}, {0, NULL}};
consvar_t cv_consolechat = CVAR_INIT ("chatmode", "Window", CV_SAVE, consolechat_cons_t, NULL);
// Shout settings
// The relevant ones are CV_NETVAR because too lazy to send them any other way
consvar_t cv_shoutname = CVAR_INIT ("shout_name", "SERVER", CV_NETVAR, NULL, NULL);
static CV_PossibleValue_t shoutcolor_cons_t[] =
{
{-1, "Player color"},
{0, "White"},
{1, "Yellow"},
{2, "Purple"},
{3, "Green"},
{4, "Blue"},
{5, "Red"},
{6, "Gray"},
{7, "Orange"},
{8, "Sky-blue"},
{9, "Gold"},
{10, "Lavender"},
{11, "Aqua-green"},
{12, "Magenta"},
{13, "Pink"},
{14, "Brown"},
{15, "Tan"},
{0, NULL}
};
consvar_t cv_shoutcolor = CVAR_INIT ("shout_color", "Red", CV_NETVAR, shoutcolor_cons_t, NULL);
// If on and you're an admin, your messages will automatically become shouts.
consvar_t cv_autoshout = CVAR_INIT ("autoshout", "Off", CV_NETVAR, CV_OnOff, NULL);
// Pause game upon window losing focus
consvar_t cv_pauseifunfocused = CVAR_INIT ("pauseifunfocused", "Yes", CV_SAVE, CV_YesNo, NULL);
// Display song credits
consvar_t cv_songcredits = CVAR_INIT ("songcredits", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_kickstartaccel[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("kickstartaccel", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange),
CVAR_INIT ("kickstartaccel2", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange2),
CVAR_INIT ("kickstartaccel3", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange3),
CVAR_INIT ("kickstartaccel4", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange4)
};
consvar_t cv_autoroulette[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("autoroulette", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange),
CVAR_INIT ("autoroulette2", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange2),
CVAR_INIT ("autoroulette3", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange3),
CVAR_INIT ("autoroulette4", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange4)
};
consvar_t cv_shrinkme[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("shrinkme", "Off", CV_CALL, CV_OnOff, weaponPrefChange),
CVAR_INIT ("shrinkme2", "Off", CV_CALL, CV_OnOff, weaponPrefChange2),
CVAR_INIT ("shrinkme3", "Off", CV_CALL, CV_OnOff, weaponPrefChange3),
CVAR_INIT ("shrinkme4", "Off", CV_CALL, CV_OnOff, weaponPrefChange4)
};
static CV_PossibleValue_t zerotoone_cons_t[] = {{0, "MIN"}, {FRACUNIT, "MAX"}, {0, NULL}};
consvar_t cv_deadzone[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("deadzone", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL),
CVAR_INIT ("deadzone2", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL),
CVAR_INIT ("deadzone3", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL),
CVAR_INIT ("deadzone4", "0.25", CV_FLOAT|CV_SAVE, zerotoone_cons_t, NULL)
};
consvar_t cv_rumble[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("rumble", "On", CV_SAVE|CV_CALL, CV_OnOff, rumble_off_handle),
CVAR_INIT ("rumble2", "On", CV_SAVE|CV_CALL, CV_OnOff, rumble_off_handle2),
CVAR_INIT ("rumble3", "On", CV_SAVE|CV_CALL, CV_OnOff, rumble_off_handle3),
CVAR_INIT ("rumble4", "On", CV_SAVE|CV_CALL, CV_OnOff, rumble_off_handle4)
};
// now automatically allocated in D_RegisterClientCommands
// so that it doesn't have to be updated depending on the value of MAXPLAYERS
char player_names[MAXPLAYERS][MAXPLAYERNAME+1];
@ -1107,49 +998,57 @@ ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
return dest;
}
static void weaponPrefChange(void)
void weaponPrefChange(void);
void weaponPrefChange(void)
{
if (Playing())
WeaponPref_Send(0);
}
static void weaponPrefChange2(void)
void weaponPrefChange2(void);
void weaponPrefChange2(void)
{
if (Playing())
WeaponPref_Send(1);
}
static void weaponPrefChange3(void)
void weaponPrefChange3(void);
void weaponPrefChange3(void)
{
if (Playing())
WeaponPref_Send(2);
}
static void weaponPrefChange4(void)
void weaponPrefChange4(void);
void weaponPrefChange4(void)
{
if (Playing())
WeaponPref_Send(3);
}
static void rumble_off_handle(void)
void rumble_off_handle(void);
void rumble_off_handle(void)
{
if (cv_rumble[0].value == 0)
G_ResetPlayerDeviceRumble(0);
}
static void rumble_off_handle2(void)
void rumble_off_handle2(void);
void rumble_off_handle2(void)
{
if (cv_rumble[1].value == 0)
G_ResetPlayerDeviceRumble(1);
}
static void rumble_off_handle3(void)
void rumble_off_handle3(void);
void rumble_off_handle3(void)
{
if (cv_rumble[2].value == 0)
G_ResetPlayerDeviceRumble(2);
}
static void rumble_off_handle4(void)
void rumble_off_handle4(void);
void rumble_off_handle4(void)
{
if (cv_rumble[3].value == 0)
G_ResetPlayerDeviceRumble(3);

3
src/g_input.c
View file

@ -23,9 +23,6 @@
#include "v_video.h" // V_GetColor for assigning gamepad indictaor colors
#include "z_zone.h"
static CV_PossibleValue_t onecontrolperkey_cons_t[] = {{1, "One"}, {2, "Several"}, {0, NULL}};
consvar_t cv_controlperkey = CVAR_INIT ("controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL);
// current state of the keys
// FRACUNIT for fully pressed, 0 for not pressed
INT32 gamekeydown[MAXDEVICES][NUMINPUTS];

78
src/hardware/hw_main.c
View file

@ -5910,59 +5910,26 @@ void HWR_LoadLevel(void)
// 3D ENGINE COMMANDS
// ==========================================================================
static CV_PossibleValue_t glshaders_cons_t[] = {{HWD_SHADEROPTION_OFF, "Off"}, {HWD_SHADEROPTION_ON, "On"}, {HWD_SHADEROPTION_NOCUSTOM, "Ignore custom shaders"}, {0, NULL}};
#ifdef BAD_MODEL_OPTIONS
static CV_PossibleValue_t glmodelinterpolation_cons_t[] = {{0, "Off"}, {1, "Sometimes"}, {2, "Always"}, {0, NULL}};
#endif
static CV_PossibleValue_t glshearing_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Third-person"}, {0, NULL}};
CV_PossibleValue_t glshaders_cons_t[] = {{HWD_SHADEROPTION_OFF, "Off"}, {HWD_SHADEROPTION_ON, "On"}, {HWD_SHADEROPTION_NOCUSTOM, "Ignore custom shaders"}, {0, NULL}};
static void CV_glfiltermode_OnChange(void);
static void CV_glanisotropic_OnChange(void);
static CV_PossibleValue_t glfiltermode_cons_t[]= {{HWD_SET_TEXTUREFILTER_POINTSAMPLED, "Nearest"},
CV_PossibleValue_t glfiltermode_cons_t[]= {{HWD_SET_TEXTUREFILTER_POINTSAMPLED, "Nearest"},
{HWD_SET_TEXTUREFILTER_BILINEAR, "Bilinear"}, {HWD_SET_TEXTUREFILTER_TRILINEAR, "Trilinear"},
{HWD_SET_TEXTUREFILTER_MIXED1, "Linear_Nearest"},
{HWD_SET_TEXTUREFILTER_MIXED2, "Nearest_Linear"},
{HWD_SET_TEXTUREFILTER_MIXED3, "Nearest_Mipmap"},
{0, NULL}};
CV_PossibleValue_t glanisotropicmode_cons_t[] = {{1, "MIN"}, {16, "MAX"}, {0, NULL}};
consvar_t cv_glshaders = CVAR_INIT ("gr_shaders", "On", CV_SAVE, glshaders_cons_t, NULL);
consvar_t cv_glallowshaders = CVAR_INIT ("gr_allowclientshaders", "On", CV_NETVAR, CV_OnOff, NULL);
consvar_t cv_fovchange = CVAR_INIT ("gr_fovchange", "Off", CV_SAVE, CV_OnOff, NULL);
#ifdef ALAM_LIGHTING
consvar_t cv_gldynamiclighting = CVAR_INIT ("gr_dynamiclighting", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_glstaticlighting = CVAR_INIT ("gr_staticlighting", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_glcoronas = CVAR_INIT ("gr_coronas", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_glcoronasize = CVAR_INIT ("gr_coronasize", "1", CV_SAVE|CV_FLOAT, 0, NULL);
#endif
consvar_t cv_glmodels = CVAR_INIT ("gr_models", "Off", CV_SAVE, CV_OnOff, NULL);
#ifdef BAD_MODEL_OPTIONS
consvar_t cv_glmodelinterpolation = CVAR_INIT ("gr_modelinterpolation", "Sometimes", CV_SAVE, glmodelinterpolation_cons_t, NULL);
consvar_t cv_glmodellighting = CVAR_INIT ("gr_modellighting", "Off", CV_SAVE, CV_OnOff, NULL);
#endif
consvar_t cv_glshearing = CVAR_INIT ("gr_shearing", "Off", CV_SAVE, glshearing_cons_t, NULL);
consvar_t cv_glspritebillboarding = CVAR_INIT ("gr_spritebillboarding", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_glskydome = CVAR_INIT ("gr_skydome", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_glfiltermode = CVAR_INIT ("gr_filtermode", "Nearest", CV_SAVE|CV_CALL, glfiltermode_cons_t, CV_glfiltermode_OnChange);
consvar_t cv_glanisotropicmode = CVAR_INIT ("gr_anisotropicmode", "1", CV_CALL, glanisotropicmode_cons_t, CV_glanisotropic_OnChange);
consvar_t cv_glsolvetjoin = CVAR_INIT ("gr_solvetjoin", "On", 0, CV_OnOff, NULL);
consvar_t cv_glbatching = CVAR_INIT ("gr_batching", "On", 0, CV_OnOff, NULL);
static void CV_glfiltermode_OnChange(void)
void CV_glfiltermode_OnChange(void);
void CV_glfiltermode_OnChange(void)
{
if (rendermode == render_opengl)
HWD.pfnSetSpecialState(HWD_SET_TEXTUREFILTERMODE, cv_glfiltermode.value);
}
static void CV_glanisotropic_OnChange(void)
void CV_glanisotropic_OnChange(void);
void CV_glanisotropic_OnChange(void)
{
if (rendermode == render_opengl)
HWD.pfnSetSpecialState(HWD_SET_TEXTUREANISOTROPICMODE, cv_glanisotropicmode.value);
@ -5971,33 +5938,10 @@ static void CV_glanisotropic_OnChange(void)
//added by Hurdler: console varibale that are saved
void HWR_AddCommands(void)
{
CV_RegisterVar(&cv_fovchange);
#ifdef ALAM_LIGHTING
CV_RegisterVar(&cv_glstaticlighting);
CV_RegisterVar(&cv_gldynamiclighting);
CV_RegisterVar(&cv_glcoronasize);
CV_RegisterVar(&cv_glcoronas);
#endif
#ifdef BAD_MODEL_OPTIONS
CV_RegisterVar(&cv_glmodellighting);
CV_RegisterVar(&cv_glmodelinterpolation);
#endif
CV_RegisterVar(&cv_glmodels);
CV_RegisterVar(&cv_glskydome);
CV_RegisterVar(&cv_glspritebillboarding);
CV_RegisterVar(&cv_glshearing);
CV_RegisterVar(&cv_glshaders);
CV_RegisterVar(&cv_glallowshaders);
CV_RegisterVar(&cv_glanisotropicmode);
CV_RegisterVar(&cv_glfiltermode);
CV_RegisterVar(&cv_glsolvetjoin);
CV_RegisterVar(&cv_glbatching);
{
extern struct CVarList *cvlist_opengl;
CV_RegisterList(cvlist_opengl);
}
}
void HWR_AddSessionCommands(void)

24
src/http-mserv.c
View file

@ -35,26 +35,6 @@ Documentation available here.
#define Blame( ... ) \
CONS_Printf("\x85" __VA_ARGS__)
static void MasterServer_Debug_OnChange (void);
consvar_t cv_masterserver_timeout = CVAR_INIT
(
"masterserver_timeout", "5", CV_SAVE, CV_Unsigned,
NULL
);
consvar_t cv_masterserver_debug = CVAR_INIT
(
"masterserver_debug", "Off", CV_SAVE|CV_CALL, CV_OnOff,
MasterServer_Debug_OnChange
);
consvar_t cv_masterserver_token = CVAR_INIT
(
"masterserver_token", "", CV_SAVE, NULL,
NULL
);
#define HMS_QUERY_VERSION "?v=2.2"
#ifdef MASTERSERVER
@ -561,8 +541,8 @@ HMS_set_api (char *api)
#endif/*MASTERSERVER*/
static void
MasterServer_Debug_OnChange (void)
void MasterServer_Debug_OnChange (void);
void MasterServer_Debug_OnChange (void)
{
#ifdef MASTERSERVER
/* TODO: change to 'latest-log.txt' for log files revision. */

8
src/i_time.c
View file

@ -23,9 +23,6 @@
timestate_t g_time;
static CV_PossibleValue_t timescale_cons_t[] = {{FRACUNIT/20, "MIN"}, {20*FRACUNIT, "MAX"}, {0, NULL}};
consvar_t cv_timescale = CVAR_INIT ("timescale", "1.0", CV_NETVAR|CV_CHEAT|CV_FLOAT, timescale_cons_t, NULL);
static precise_t enterprecise, oldenterprecise;
static fixed_t entertic, oldentertics;
static double tictimer;
@ -50,7 +47,10 @@ void I_InitializeTime(void)
oldenterprecise = 0;
tictimer = 0.0;
CV_RegisterVar(&cv_timescale);
{
extern struct CVarList *cvlist_timer;
CV_RegisterList(cvlist_timer);
}
// I_StartupTimer is preserved for potential subsystems that need to setup
// timing information for I_GetPreciseTime and sleeping

4
src/k_bot.c
View file

@ -38,10 +38,6 @@
#include "discord.h" // DRPC_UpdatePresence
#include "i_net.h" // doomcom
#ifdef DEVELOP
consvar_t cv_botcontrol = CVAR_INIT ("botcontrol", "On", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL);
#endif
/*--------------------------------------------------
void K_SetBot(UINT8 playerNum, UINT8 skinnum, UINT8 difficulty, botStyle_e style)

51
src/k_kart.c
View file

@ -351,57 +351,6 @@ angle_t K_ReflectAngle(angle_t yourangle, angle_t theirangle, fixed_t yourspeed,
return (angle_t)angoffset;
}
//{ SRB2kart Net Variables
void K_RegisterKartStuff(void)
{
INT32 i;
for (i = 0; i < NUMKARTRESULTS-1; i++)
{
CV_RegisterVar(&cv_items[i]);
}
CV_RegisterVar(&cv_kartspeed);
CV_RegisterVar(&cv_kartbumpers);
CV_RegisterVar(&cv_kartfrantic);
CV_RegisterVar(&cv_kartencore);
CV_RegisterVar(&cv_kartspeedometer);
CV_RegisterVar(&cv_kartvoices);
CV_RegisterVar(&cv_karthorns);
CV_RegisterVar(&cv_kartbot);
CV_RegisterVar(&cv_karteliminatelast);
CV_RegisterVar(&cv_thunderdome);
CV_RegisterVar(&cv_kartusepwrlv);
CV_RegisterVar(&cv_votetime);
CV_RegisterVar(&cv_botscanvote);
CV_RegisterVar(&cv_kartdebugitem);
CV_RegisterVar(&cv_kartdebugamount);
CV_RegisterVar(&cv_kartdebugdistribution);
CV_RegisterVar(&cv_kartdebughuddrop);
CV_RegisterVar(&cv_kartdebugwaypoints);
CV_RegisterVar(&cv_kartdebugbots);
CV_RegisterVar(&cv_kartdebugstart);
CV_RegisterVar(&cv_kartdebugnodes);
CV_RegisterVar(&cv_kartdebugcolorize);
CV_RegisterVar(&cv_kartdebugdirector);
CV_RegisterVar(&cv_debugrank);
CV_RegisterVar(&cv_spbtest);
CV_RegisterVar(&cv_capsuletest);
CV_RegisterVar(&cv_battletest);
CV_RegisterVar(&cv_debugencorevote);
CV_RegisterVar(&cv_reducevfx);
#ifdef DEVELOP
CV_RegisterVar(&cv_kartencoremap);
#endif
}
//}
boolean K_IsPlayerLosing(player_t *player)
{
INT32 winningpos = 1;

2
src/k_kart.h
View file

@ -51,8 +51,6 @@ Make sure this matches the actual number of states
angle_t K_ReflectAngle(angle_t angle, angle_t against, fixed_t maxspeed, fixed_t yourspeed);
void K_RegisterKartStuff(void);
boolean K_IsDuelItem(mobjtype_t type);
boolean K_DuelItemAlwaysSpawns(mapthing_t *mt);

3
src/k_menu.h
View file

@ -419,6 +419,7 @@ extern menuitem_t PAUSE_Main[];
extern menu_t PAUSE_MainDef;
extern menu_t PAUSE_KickHandlerDef;
extern menu_t PAUSE_CheatsDef;
// EXTRAS
extern menuitem_t MISC_Manual[];
@ -602,7 +603,7 @@ extern struct menutransition_s {
extern boolean menuwipe;
extern consvar_t cv_showfocuslost;
extern consvar_t cv_chooseskin, cv_serversort, cv_menujam_update;
extern consvar_t cv_chooseskin, cv_serversort, cv_menujam_update, cv_menujam;
extern consvar_t cv_autorecord;
void M_SetMenuDelay(UINT8 i);

63
src/k_menufunc.c
View file

@ -57,39 +57,15 @@ static boolean noFurtherInput = false;
// CONSOLE VARIABLES AND THEIR POSSIBLE VALUES GO HERE.
// ==========================================================================
// Consvar onchange functions
static void Dummystaff_OnChange(void);
consvar_t cv_showfocuslost = CVAR_INIT ("showfocuslost", "Yes", CV_SAVE, CV_YesNo, NULL);
consvar_t cv_menujam_update = CVAR_INIT ("menujam_update", "Off", CV_SAVE, CV_OnOff, NULL);
static CV_PossibleValue_t menujam_cons_t[] = {{0, "menu"}, {1, "menu2"}, {2, "menu3"}, {0, NULL}};
static consvar_t cv_menujam = CVAR_INIT ("menujam", "menu", CV_SAVE, menujam_cons_t, NULL);
// first time memory
consvar_t cv_tutorialprompt = CVAR_INIT ("tutorialprompt", "On", CV_SAVE, CV_OnOff, NULL);
//Console variables used solely in the menu system.
//todo: add a way to use non-console variables in the menu
// or make these consvars legitimate like color or skin.
static CV_PossibleValue_t dummyteam_cons_t[] = {{0, "Spectator"}, {1, "Red"}, {2, "Blue"}, {0, NULL}};
static CV_PossibleValue_t dummyspectate_cons_t[] = {{0, "Spectator"}, {1, "Playing"}, {0, NULL}};
static CV_PossibleValue_t dummyscramble_cons_t[] = {{0, "Random"}, {1, "Points"}, {0, NULL}};
static CV_PossibleValue_t dummystaff_cons_t[] = {{0, "MIN"}, {MAXSTAFF-1, "MAX"}, {0, NULL}};
static consvar_t cv_dummyteam = CVAR_INIT ("dummyteam", "Spectator", CV_HIDDEN, dummyteam_cons_t, NULL);
//static cv_dummyspectate = CVAR_INITconsvar_t ("dummyspectate", "Spectator", CV_HIDDEN, dummyspectate_cons_t, NULL);
static consvar_t cv_dummyscramble = CVAR_INIT ("dummyscramble", "Random", CV_HIDDEN, dummyscramble_cons_t, NULL);
consvar_t cv_dummystaff = CVAR_INIT ("dummystaff", "0", CV_HIDDEN|CV_CALL, dummystaff_cons_t, Dummystaff_OnChange);
consvar_t cv_dummyspectate = CVAR_INIT ("dummyspectate", "Spectator", CV_HIDDEN, dummyspectate_cons_t, NULL);
CV_PossibleValue_t dummystaff_cons_t[] = {{0, "MIN"}, {MAXSTAFF-1, "MAX"}, {0, NULL}};
// ==========================================================================
// CVAR ONCHANGE EVENTS GO HERE
// ==========================================================================
// (there's only a couple anyway)
static void Dummystaff_OnChange(void)
void Dummystaff_OnChange(void);
void Dummystaff_OnChange(void)
{
if (mapheaderinfo[levellist.choosemap] == NULL || mapheaderinfo[levellist.choosemap]->ghostCount <= 0)
return;
@ -1190,44 +1166,11 @@ void M_Init(void)
#if 0
CV_RegisterVar(&cv_nextmap);
#endif
CV_RegisterVar(&cv_chooseskin);
CV_RegisterVar(&cv_autorecord);
// don't lose your position in the jam cycle
CV_RegisterVar(&cv_menujam_update);
CV_RegisterVar(&cv_menujam);
CV_RegisterVar(&cv_serversort);
if (dedicated)
return;
//COM_AddCommand("manual", Command_Manual_f);
// Menu hacks
CV_RegisterVar(&cv_dummymenuplayer);
CV_RegisterVar(&cv_dummyteam);
CV_RegisterVar(&cv_dummyspectate);
CV_RegisterVar(&cv_dummyscramble);
CV_RegisterVar(&cv_dummystaff);
CV_RegisterVar(&cv_dummyip);
CV_RegisterVar(&cv_dummyprofilename);
CV_RegisterVar(&cv_dummyprofileplayername);
CV_RegisterVar(&cv_dummyprofilekickstart);
CV_RegisterVar(&cv_dummyprofileautoroulette);
CV_RegisterVar(&cv_dummyprofilerumble);
CV_RegisterVar(&cv_dummygpdifficulty);
CV_RegisterVar(&cv_dummykartspeed);
CV_RegisterVar(&cv_dummygpencore);
CV_RegisterVar(&cv_dummymatchbots);
CV_RegisterVar(&cv_dummyspbattack);
CV_RegisterVar(&cv_dummyaddonsearch);
CV_RegisterVar(&cv_dummyextraspassword);
M_UpdateMenuBGImage(true);
}

3
src/k_profiles.c
View file

@ -21,6 +21,9 @@
#include "monocypher/monocypher.h"
#include "stun.h"
#include "k_color.h"
#include "command.h"
CV_PossibleValue_t lastprofile_cons_t[] = {{-1, "MIN"}, {MAXPROFILES, "MAX"}, {0, NULL}};
// List of all the profiles.
static profile_t *profilesList[MAXPROFILES+1]; // +1 because we're gonna add a default "GUEST' profile.

2
src/k_pwrlv.c
View file

@ -34,8 +34,6 @@ UINT8 spectateGriefed = 0;
SINT8 speedscramble = -1;
SINT8 encorescramble = -1;
consvar_t cv_debugencorevote = CVAR_INIT ("debugencorevote", "Off", CV_CHEAT|CV_NETVAR, CV_OnOff, NULL);
SINT8 K_UsingPowerLevels(void)
{
if (!cv_kartusepwrlv.value)

18
src/k_zvote.c
View file

@ -25,13 +25,10 @@
#include "r_fps.h"
#include "byteptr.h"
static CV_PossibleValue_t modulate_cons_t[] = {{0, "MIN"}, {FRACUNIT, "MAX"}, {0, NULL}};
static consvar_t cv_zvote_quorum = CVAR_INIT ("zvote_quorum", "0.6", CV_SAVE|CV_NETVAR|CV_FLOAT, modulate_cons_t, NULL);
static consvar_t cv_zvote_spectators = CVAR_INIT ("zvote_spectator_votes", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
static consvar_t cv_zvote_length = CVAR_INIT ("zvote_length", "20", CV_SAVE|CV_NETVAR, CV_Unsigned, NULL);
static consvar_t cv_zvote_delay = CVAR_INIT ("zvote_delay", "20", CV_SAVE|CV_NETVAR, CV_Unsigned, NULL);
extern consvar_t cv_zvote_quorum;
extern consvar_t cv_zvote_spectators;
extern consvar_t cv_zvote_length;
extern consvar_t cv_zvote_delay;
midVote_t g_midVote = {0};
@ -324,13 +321,6 @@ void K_RegisterMidVoteCVars(void)
{
INT32 i = INT32_MAX;
CV_RegisterVar(&cv_zvote_quorum);
CV_RegisterVar(&cv_zvote_spectators);
CV_RegisterVar(&cv_zvote_length);
CV_RegisterVar(&cv_zvote_delay);
for (i = 0; i < MVT__MAX; i++)
{
CV_RegisterVar(&g_midVoteTypeDefs[i].cv_allowed);

11
src/m_anigif.c
View file

@ -29,17 +29,6 @@
// GIFs are always little-endian
#include "byteptr.h"
CV_PossibleValue_t gif_dynamicdelay_cons_t[] = {
{0, "Off"},
{1, "On"},
{2, "Accurate, experimental"},
{0, NULL}};
consvar_t cv_gif_optimize = CVAR_INIT ("gif_optimize", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_gif_downscale = CVAR_INIT ("gif_downscale", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_gif_dynamicdelay = CVAR_INIT ("gif_dynamicdelay", "On", CV_SAVE, gif_dynamicdelay_cons_t, NULL);
consvar_t cv_gif_localcolortable = CVAR_INIT ("gif_localcolortable", "On", CV_SAVE, CV_OnOff, NULL);
#ifdef HAVE_ANIGIF
static boolean gif_optimize = false; // So nobody can do something dumb
static boolean gif_downscale = false; // like changing cvars mid output

27
src/m_avrecorder.cpp
View file

@ -53,6 +53,10 @@ enum : int32_t
}; // namespace Res
}; // namespace
extern "C" {
CV_PossibleValue_t movie_resolution_cons_t[] = {
{Res::kGame, "Native"},
{Res::kBase, "Small"},
@ -62,33 +66,12 @@ CV_PossibleValue_t movie_resolution_cons_t[] = {
{Res::kCustom, "Custom"},
{0, NULL}};
CV_PossibleValue_t movie_limit_cons_t[] = {{1, "MIN"}, {INT32_MAX, "MAX"}, {0, "Unlimited"}, {0, NULL}};
}; // namespace
consvar_t cv_movie_resolution = CVAR_INIT("movie_resolution", "Medium", CV_SAVE, movie_resolution_cons_t, NULL);
consvar_t cv_movie_custom_resolution = CVAR_INIT("movie_custom_resolution", "640x400", CV_SAVE, NULL, NULL);
consvar_t cv_movie_fps = CVAR_INIT("movie_fps", "60", CV_SAVE, CV_Natural, NULL);
consvar_t cv_movie_showfps = CVAR_INIT("movie_showfps", "Yes", CV_SAVE, CV_YesNo, NULL);
consvar_t cv_movie_sound = CVAR_INIT("movie_sound", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_movie_duration = CVAR_INIT("movie_duration", "Unlimited", CV_SAVE | CV_FLOAT, movie_limit_cons_t, NULL);
consvar_t cv_movie_size = CVAR_INIT("movie_size", "25.0", CV_SAVE | CV_FLOAT, movie_limit_cons_t, NULL);
}; // extern "C"
std::shared_ptr<AVRecorder> g_av_recorder;
void M_AVRecorder_AddCommands(void)
{
CV_RegisterVar(&cv_movie_custom_resolution);
CV_RegisterVar(&cv_movie_duration);
CV_RegisterVar(&cv_movie_fps);
CV_RegisterVar(&cv_movie_resolution);
CV_RegisterVar(&cv_movie_showfps);
CV_RegisterVar(&cv_movie_size);
CV_RegisterVar(&cv_movie_sound);
srb2::media::Options::register_all();
}

12
src/m_cheat.c
View file

@ -499,9 +499,6 @@ struct debugFlagNames_s const debug_flag_names[] =
{NULL, 0}
};
static CV_PossibleValue_t devmode_screen_t[] = {{1, "MIN"}, {4, "MAX"}, {0, NULL}};
consvar_t cv_devmode_screen = CVAR_INIT ("devmode_screen", "1", CV_CHEAT, devmode_screen_t, NULL);
void Command_Devmode_f(void)
{
size_t argc = 0;
@ -646,15 +643,6 @@ void Command_RespawnAt_f(void)
//
// OBJECTPLACE (and related variables)
//
static CV_PossibleValue_t op_mapthing_t[] = {{0, "MIN"}, {4095, "MAX"}, {0, NULL}};
static CV_PossibleValue_t op_speed_t[] = {{1, "MIN"}, {128, "MAX"}, {0, NULL}};
static CV_PossibleValue_t op_flags_t[] = {{0, "MIN"}, {15, "MAX"}, {0, NULL}};
static CV_PossibleValue_t op_hoopflags_t[] = {{0, "MIN"}, {15, "MAX"}, {0, NULL}};
consvar_t cv_mapthingnum = CVAR_INIT ("op_mapthingnum", "0", CV_NOTINNET, op_mapthing_t, NULL);
consvar_t cv_speed = CVAR_INIT ("op_speed", "16", CV_NOTINNET, op_speed_t, NULL);
consvar_t cv_opflags = CVAR_INIT ("op_flags", "0", CV_NOTINNET, op_flags_t, NULL);
consvar_t cv_ophoopflags = CVAR_INIT ("op_hoopflags", "4", CV_NOTINNET, op_hoopflags_t, NULL);
boolean objectplacing = false;
mobjtype_t op_currentthing = 0; // For the object placement mode

39
src/m_misc.cpp
View file

@ -112,18 +112,15 @@ typedef off_t off64_t;
#endif
#endif
consvar_t cv_screenshot_colorprofile = CVAR_INIT ("screenshot_colorprofile", "Yes", CV_SAVE, CV_YesNo, NULL);
CV_PossibleValue_t lossless_recorder_cons_t[] = {{MM_GIF, "GIF"}, {MM_APNG, "aPNG"}, {MM_SCREENSHOT, "Screenshots"}, {0, NULL}};
static CV_PossibleValue_t lossless_recorder_cons_t[] = {{MM_GIF, "GIF"}, {MM_APNG, "aPNG"}, {MM_SCREENSHOT, "Screenshots"}, {0, NULL}};
consvar_t cv_lossless_recorder = CVAR_INIT ("lossless_recorder", "GIF", CV_SAVE, lossless_recorder_cons_t, NULL);
static CV_PossibleValue_t zlib_mem_level_t[] = {
CV_PossibleValue_t zlib_mem_level_t[] = {
{1, "(Min Memory) 1"},
{2, "2"}, {3, "3"}, {4, "4"}, {5, "5"}, {6, "6"}, {7, "7"},
{8, "(Optimal) 8"}, //libpng Default
{9, "(Max Memory) 9"}, {0, NULL}};
static CV_PossibleValue_t zlib_level_t[] = {
CV_PossibleValue_t zlib_level_t[] = {
{0, "No Compression"}, //Z_NO_COMPRESSION
{1, "(Fastest) 1"}, //Z_BEST_SPEED
{2, "2"}, {3, "3"}, {4, "4"}, {5, "5"},
@ -132,7 +129,7 @@ static CV_PossibleValue_t zlib_level_t[] = {
{9, "(Maximum) 9"}, //Z_BEST_COMPRESSION
{0, NULL}};
static CV_PossibleValue_t zlib_strategy_t[] = {
CV_PossibleValue_t zlib_strategy_t[] = {
{0, "Normal"}, //Z_DEFAULT_STRATEGY
{1, "Filtered"}, //Z_FILTERED
{2, "Huffman Only"}, //Z_HUFFMAN_ONLY
@ -140,7 +137,7 @@ static CV_PossibleValue_t zlib_strategy_t[] = {
{4, "Fixed"}, //Z_FIXED
{0, NULL}};
static CV_PossibleValue_t zlib_window_bits_t[] = {
CV_PossibleValue_t zlib_window_bits_t[] = {
#ifdef WBITS_8_OK
{8, "256"},
#endif
@ -148,27 +145,6 @@ static CV_PossibleValue_t zlib_window_bits_t[] = {
{14, "16k"}, {15, "32k"},
{0, NULL}};
static CV_PossibleValue_t apng_delay_t[] = {
{1, "1x"},
{2, "1/2x"},
{3, "1/3x"},
{4, "1/4x"},
{0, NULL}};
// zlib memory usage is as follows:
// (1 << (zlib_window_bits+2)) + (1 << (zlib_level+9))
consvar_t cv_zlib_memory = CVAR_INIT ("png_memory_level", "7", CV_SAVE, zlib_mem_level_t, NULL);
consvar_t cv_zlib_level = CVAR_INIT ("png_compress_level", "(Optimal) 6", CV_SAVE, zlib_level_t, NULL);
consvar_t cv_zlib_strategy = CVAR_INIT ("png_strategy", "Normal", CV_SAVE, zlib_strategy_t, NULL);
consvar_t cv_zlib_window_bits = CVAR_INIT ("png_window_size", "32k", CV_SAVE, zlib_window_bits_t, NULL);
consvar_t cv_zlib_memorya = CVAR_INIT ("apng_memory_level", "(Max Memory) 9", CV_SAVE, zlib_mem_level_t, NULL);
consvar_t cv_zlib_levela = CVAR_INIT ("apng_compress_level", "4", CV_SAVE, zlib_level_t, NULL);
consvar_t cv_zlib_strategya = CVAR_INIT ("apng_strategy", "RLE", CV_SAVE, zlib_strategy_t, NULL);
consvar_t cv_zlib_window_bitsa = CVAR_INIT ("apng_window_size", "32k", CV_SAVE, zlib_window_bits_t, NULL);
consvar_t cv_apng_delay = CVAR_INIT ("apng_speed", "1x", CV_SAVE, apng_delay_t, NULL);
consvar_t cv_apng_downscale = CVAR_INIT ("apng_downscale", "On", CV_SAVE, CV_OnOff, NULL);
#ifdef USE_APNG
static boolean apng_downscale = false; // So nobody can do something dumb like changing cvars mid output
#endif
@ -657,7 +633,10 @@ void M_FirstLoadConfig(void)
}
// register execversion here before we load any configs
CV_RegisterVar(&cv_execversion);
{
extern struct CVarList *cvlist_execversion;
CV_RegisterList(cvlist_execversion);
}
// temporarily reset execversion to default
// we shouldn't need to do this, but JUST in case...

2
src/menus/extras-1.c
View file

@ -69,8 +69,6 @@ menu_t EXTRAS_MainDef = {
struct extrasmenu_s extrasmenu;
consvar_t cv_dummyextraspassword = CVAR_INIT ("dummyextraspassword", "", CV_HIDDEN, NULL, NULL);
void M_InitExtras(INT32 choice)
{
// Addons

6
src/menus/extras-addons.c
View file

@ -35,9 +35,6 @@ menu_t MISC_AddonsDef = {
// Addons menu: (Merely copypasted, original code by toaster)
static void M_UpdateAddonsSearch(void);
consvar_t cv_dummyaddonsearch = CVAR_INIT ("dummyaddonsearch", "", CV_HIDDEN|CV_CALL|CV_NOINIT, NULL, M_UpdateAddonsSearch);
void M_Addons(INT32 choice)
{
const char *pathname = ".";
@ -175,7 +172,8 @@ static void M_AddonExec(INT32 ch)
}
}
static void M_UpdateAddonsSearch(void)
void M_UpdateAddonsSearch(void);
void M_UpdateAddonsSearch(void)
{
menusearch[0] = strlen(cv_dummyaddonsearch.string);
strlcpy(menusearch+1, cv_dummyaddonsearch.string, MAXSTRINGLENGTH);

6
src/menus/options-profiles-1.c
View file

@ -27,12 +27,6 @@ menu_t OPTIONS_ProfilesDef = {
NULL,
};
consvar_t cv_dummyprofilename = CVAR_INIT ("dummyprofilename", "", CV_HIDDEN, NULL, NULL);
consvar_t cv_dummyprofileplayername = CVAR_INIT ("dummyprofileplayername", "", CV_HIDDEN, NULL, NULL);
consvar_t cv_dummyprofilekickstart = CVAR_INIT ("dummyprofilekickstart", "Off", CV_HIDDEN, CV_OnOff, NULL);
consvar_t cv_dummyprofileautoroulette = CVAR_INIT ("dummyprofileautoroulette", "Off", CV_HIDDEN, CV_OnOff, NULL);
consvar_t cv_dummyprofilerumble = CVAR_INIT ("dummyprofilerumble", "On", CV_HIDDEN, CV_OnOff, NULL);
void M_ProfileSelectInit(INT32 choice)
{
(void)choice;

10
src/menus/play-char-select.c
View file

@ -33,12 +33,7 @@ menu_t PLAY_CharSelectDef = {
M_CharacterSelectHandler
};
static CV_PossibleValue_t skins_cons_t[MAXSKINS+1] = {{1, DEFAULTSKIN}};
consvar_t cv_chooseskin = CVAR_INIT ("chooseskin", DEFAULTSKIN, CV_HIDDEN, skins_cons_t, NULL);
static void Splitplayers_OnChange(void);
CV_PossibleValue_t splitplayers_cons_t[] = {{1, "One"}, {2, "Two"}, {3, "Three"}, {4, "Four"}, {0, NULL}};
consvar_t cv_splitplayers = CVAR_INIT ("splitplayers", "One", CV_CALL, splitplayers_cons_t, Splitplayers_OnChange);
CV_PossibleValue_t skins_cons_t[MAXSKINS+1] = {{1, DEFAULTSKIN}};
// Character Select!
// @TODO: Splitscreen handling when profiles are added into the game. ...I probably won't be the one to handle this however. -Lat'
@ -1418,7 +1413,8 @@ boolean M_CharacterSelectQuit(void)
return true;
}
static void Splitplayers_OnChange(void)
void Splitplayers_OnChange(void);
void Splitplayers_OnChange(void)
{
#if 0
if (cv_splitplayers.value < setupm_pselect)

23
src/menus/play-local-race-difficulty.c
View file

@ -49,29 +49,6 @@ menu_t PLAY_RaceDifficultyDef = {
NULL
};
consvar_t cv_dummygpdifficulty = CVAR_INIT ("dummygpdifficulty", "Normal", CV_HIDDEN, gpdifficulty_cons_t, NULL);
consvar_t cv_dummykartspeed = CVAR_INIT ("dummykartspeed", "Normal", CV_HIDDEN, dummykartspeed_cons_t, NULL);
consvar_t cv_dummygpencore = CVAR_INIT ("dummygpencore", "Off", CV_HIDDEN, CV_OnOff, NULL);
static CV_PossibleValue_t dummymatchbots_cons_t[] = {
{0, "Off"},
{1, "Lv.1"},
{2, "Lv.2"},
{3, "Lv.3"},
{4, "Lv.4"},
{5, "Lv.5"},
{6, "Lv.6"},
{7, "Lv.7"},
{8, "Lv.8"},
{9, "Lv.9"},
{10, "Lv.10"},
{11, "Lv.11"},
{12, "Lv.12"},
{13, "Lv.MAX"},
{0, NULL}
};
consvar_t cv_dummymatchbots = CVAR_INIT ("dummymatchbots", "Off", CV_HIDDEN, dummymatchbots_cons_t, NULL);
void M_SetupDifficultyOptions(INT32 choice)
{
PLAY_RaceDifficulty[drace_gpdifficulty].status = IT_DISABLED;

17
src/menus/play-local-race-time-attack.c
View file

@ -11,13 +11,12 @@
#include "../z_zone.h" // Z_StrDup/Z_Free
#include "../m_cond.h"
static void CV_SPBAttackChanged(void)
void CV_SPBAttackChanged(void);
void CV_SPBAttackChanged(void)
{
G_UpdateTimeStickerMedals(levellist.choosemap, false);
}
consvar_t cv_dummyspbattack = CVAR_INIT ("dummyspbattack", "Off", CV_HIDDEN|CV_CALL, CV_OnOff, CV_SPBAttackChanged);
struct timeattackmenu_s timeattackmenu;
void M_TimeAttackTick(void)
@ -211,18 +210,6 @@ menu_t PLAY_TAGhostsDef = {
NULL
};
// autorecord demos for time attack
consvar_t cv_autorecord = CVAR_INIT ("autorecord", "Yes", 0, CV_YesNo, NULL);
CV_PossibleValue_t ghost_cons_t[] = {{0, "Hide"}, {1, "Show Character"}, {2, "Show All"}, {0, NULL}};
CV_PossibleValue_t ghost2_cons_t[] = {{0, "Hide"}, {1, "Show"}, {0, NULL}};
consvar_t cv_ghost_besttime = CVAR_INIT ("ghost_besttime", "Show All", CV_SAVE, ghost_cons_t, NULL);
consvar_t cv_ghost_bestlap = CVAR_INIT ("ghost_bestlap", "Show All", CV_SAVE, ghost_cons_t, NULL);
consvar_t cv_ghost_last = CVAR_INIT ("ghost_last", "Show All", CV_SAVE, ghost_cons_t, NULL);
consvar_t cv_ghost_guest = CVAR_INIT ("ghost_guest", "Show", CV_SAVE, ghost2_cons_t, NULL);
consvar_t cv_ghost_staff = CVAR_INIT ("ghost_staff", "Show", CV_SAVE, ghost2_cons_t, NULL);
// time attack stuff...
void M_PrepareTimeAttack(INT32 choice)
{

2
src/menus/play-online-join-ip.c
View file

@ -48,8 +48,6 @@ menu_t PLAY_MP_JoinIPDef = {
M_JoinIPInputs
};
consvar_t cv_dummyip = CVAR_INIT ("dummyip", "", CV_HIDDEN, NULL, NULL);
void M_MPJoinIPInit(INT32 choice)
{

11
src/menus/play-online-server-browser.c
View file

@ -39,17 +39,6 @@ menu_t PLAY_MP_ServerBrowserDef = {
M_ServerBrowserInputs
};
static CV_PossibleValue_t serversort_cons_t[] = {
{0,"Ping"},
{1,"AVG. Power Level"},
{2,"Most Players"},
{3,"Least Players"},
{4,"Max Player Slots"},
{5,"Gametype"},
{0,NULL}
};
consvar_t cv_serversort = CVAR_INIT ("serversort", "Ping", CV_CALL, serversort_cons_t, M_SortServerList);
// for server fetch threads...
M_waiting_mode_t m_waiting_mode = M_NOT_WAITING;

10
src/menus/transient/pause-game.c
View file

@ -88,16 +88,10 @@ menu_t PAUSE_MainDef = {
M_PauseInputs
};
static void Dummymenuplayer_OnChange(void);
static CV_PossibleValue_t dummymenuplayer_cons_t[] = {{0, "NOPE"}, {1, "P1"}, {2, "P2"}, {3, "P3"}, {4, "P4"}, {0, NULL}};
//static consvar_t cv_dummymenuplayer = CVAR_INIT ("dummymenuplayer", "P1", CV_HIDDEN|CV_CALL, dummymenuplayer_cons_t, Dummymenuplayer_OnChange);
consvar_t cv_dummymenuplayer = CVAR_INIT ("dummymenuplayer", "P1", CV_HIDDEN|CV_CALL, dummymenuplayer_cons_t, Dummymenuplayer_OnChange);
struct pausemenu_s pausemenu;
static void Dummymenuplayer_OnChange(void)
void Dummymenuplayer_OnChange(void);
void Dummymenuplayer_OnChange(void)
{
if (cv_dummymenuplayer.value < 1)
CV_StealthSetValue(&cv_dummymenuplayer, splitscreen+1);

45
src/mserv.c
View file

@ -55,28 +55,7 @@ static void Command_Listserv_f(void);
#endif/*MASTERSERVER*/
static void Update_parameters (void);
static void MasterServer_OnChange(void);
static void Advertise_OnChange(void);
static void RendezvousServer_OnChange(void);
static CV_PossibleValue_t masterserver_update_rate_cons_t[] = {
{2, "MIN"},
{60, "MAX"},
{0, NULL}
};
consvar_t cv_masterserver = CVAR_INIT ("masterserver", "https://ms.kartkrew.org/ms/api", CV_SAVE|CV_CALL, NULL, MasterServer_OnChange);
consvar_t cv_rendezvousserver = CVAR_INIT ("holepunchserver", "relay.kartkrew.org", CV_SAVE|CV_CALL, NULL, RendezvousServer_OnChange);
consvar_t cv_servername = CVAR_INIT ("servername", "Ring Racers server", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Update_parameters);
consvar_t cv_server_contact = CVAR_INIT ("server_contact", "", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Update_parameters);
consvar_t cv_masterserver_update_rate = CVAR_INIT ("masterserver_update_rate", "15", CV_SAVE|CV_CALL|CV_NOINIT, masterserver_update_rate_cons_t, MasterClient_Ticker);
consvar_t cv_advertise = CVAR_INIT ("advertise", "No", CV_NETVAR|CV_CALL|CV_NOINIT, CV_YesNo, Advertise_OnChange);
void Update_parameters (void);
#if defined (MASTERSERVER) && defined (HAVE_THREADS)
int ms_QueryId;
@ -95,15 +74,6 @@ UINT16 current_port = 0;
*/
void AddMServCommands(void)
{
CV_RegisterVar(&cv_masterserver);
CV_RegisterVar(&cv_masterserver_update_rate);
CV_RegisterVar(&cv_masterserver_timeout);
CV_RegisterVar(&cv_masterserver_debug);
CV_RegisterVar(&cv_masterserver_token);
CV_RegisterVar(&cv_advertise);
CV_RegisterVar(&cv_rendezvousserver);
CV_RegisterVar(&cv_servername);
CV_RegisterVar(&cv_server_contact);
#ifdef MASTERSERVER
COM_AddCommand("listserv", Command_Listserv_f);
COM_AddCommand("masterserver_update", Update_parameters); // allows people to updates manually in case you were delisted by accident
@ -483,7 +453,7 @@ Set_api (const char *api)
#endif/*MASTERSERVER*/
static void
void
Update_parameters (void)
{
#ifdef MASTERSERVER
@ -509,7 +479,8 @@ Update_parameters (void)
#endif/*MASTERSERVER*/
}
static void MasterServer_OnChange(void)
void MasterServer_OnChange(void);
void MasterServer_OnChange(void)
{
#ifdef MASTERSERVER
UnregisterServer();
@ -521,8 +492,8 @@ static void MasterServer_OnChange(void)
#endif/*MASTERSERVER*/
}
static void
Advertise_OnChange(void)
void Advertise_OnChange(void);
void Advertise_OnChange(void)
{
int different;
@ -553,8 +524,8 @@ Advertise_OnChange(void)
}
#ifdef DEVELOP
static void
RendezvousServer_OnChange (void)
void RendezvousServer_OnChange (void);
void RendezvousServer_OnChange (void)
{
consvar_t *cvar = &cv_rendezvousserver;

3
src/p_mobj.c
View file

@ -51,9 +51,6 @@
#include "m_easing.h"
#include "k_podium.h"
static CV_PossibleValue_t CV_BobSpeed[] = {{0, "MIN"}, {4*FRACUNIT, "MAX"}, {0, NULL}};
consvar_t cv_movebob = CVAR_INIT ("movebob", "1.0", CV_FLOAT|CV_SAVE, CV_BobSpeed, NULL);
actioncache_t actioncachehead;
static mobj_t *overlaycap = NULL;

52
src/p_user.c
View file

@ -2856,7 +2856,8 @@ static void P_DeathThink(player_t *player)
camera_t camera[MAXSPLITSCREENPLAYERS]; // Four cameras, three for splitscreen
static void CV_CamRotate_OnChange(void)
void CV_CamRotate_OnChange(void);
void CV_CamRotate_OnChange(void)
{
if (cv_cam_rotate[0].value < 0)
CV_SetValue(&cv_cam_rotate[0], cv_cam_rotate[0].value + 360);
@ -2864,7 +2865,8 @@ static void CV_CamRotate_OnChange(void)
CV_SetValue(&cv_cam_rotate[0], cv_cam_rotate[0].value % 360);
}
static void CV_CamRotate2_OnChange(void)
void CV_CamRotate2_OnChange(void);
void CV_CamRotate2_OnChange(void)
{
if (cv_cam_rotate[1].value < 0)
CV_SetValue(&cv_cam_rotate[1], cv_cam_rotate[1].value + 360);
@ -2872,7 +2874,8 @@ static void CV_CamRotate2_OnChange(void)
CV_SetValue(&cv_cam_rotate[1], cv_cam_rotate[1].value % 360);
}
static void CV_CamRotate3_OnChange(void)
void CV_CamRotate3_OnChange(void);
void CV_CamRotate3_OnChange(void)
{
if (cv_cam_rotate[2].value < 0)
CV_SetValue(&cv_cam_rotate[2], cv_cam_rotate[2].value + 360);
@ -2880,7 +2883,8 @@ static void CV_CamRotate3_OnChange(void)
CV_SetValue(&cv_cam_rotate[2], cv_cam_rotate[2].value % 360);
}
static void CV_CamRotate4_OnChange(void)
void CV_CamRotate4_OnChange(void);
void CV_CamRotate4_OnChange(void)
{
if (cv_cam_rotate[3].value < 0)
CV_SetValue(&cv_cam_rotate[3], cv_cam_rotate[3].value + 360);
@ -2888,46 +2892,6 @@ static void CV_CamRotate4_OnChange(void)
CV_SetValue(&cv_cam_rotate[3], cv_cam_rotate[3].value % 360);
}
static CV_PossibleValue_t CV_CamSpeed[] = {{0, "MIN"}, {1*FRACUNIT, "MAX"}, {0, NULL}};
static CV_PossibleValue_t CV_CamRotate[] = {{-720, "MIN"}, {720, "MAX"}, {0, NULL}};
consvar_t cv_cam_dist[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("cam_dist", "190", CV_FLOAT|CV_SAVE, NULL, NULL),
CVAR_INIT ("cam2_dist", "190", CV_FLOAT|CV_SAVE, NULL, NULL),
CVAR_INIT ("cam3_dist", "190", CV_FLOAT|CV_SAVE, NULL, NULL),
CVAR_INIT ("cam4_dist", "190", CV_FLOAT|CV_SAVE, NULL, NULL)
};
consvar_t cv_cam_height[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("cam_height", "95", CV_FLOAT|CV_SAVE, NULL, NULL),
CVAR_INIT ("cam2_height", "95", CV_FLOAT|CV_SAVE, NULL, NULL),
CVAR_INIT ("cam3_height", "95", CV_FLOAT|CV_SAVE, NULL, NULL),
CVAR_INIT ("cam4_height", "95", CV_FLOAT|CV_SAVE, NULL, NULL)
};
consvar_t cv_cam_still[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("cam_still", "Off", 0, CV_OnOff, NULL),
CVAR_INIT ("cam2_still", "Off", 0, CV_OnOff, NULL),
CVAR_INIT ("cam3_still", "Off", 0, CV_OnOff, NULL),
CVAR_INIT ("cam4_still", "Off", 0, CV_OnOff, NULL)
};
consvar_t cv_cam_speed[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("cam_speed", "0.4", CV_FLOAT|CV_SAVE, CV_CamSpeed, NULL),
CVAR_INIT ("cam2_speed", "0.4", CV_FLOAT|CV_SAVE, CV_CamSpeed, NULL),
CVAR_INIT ("cam3_speed", "0.4", CV_FLOAT|CV_SAVE, CV_CamSpeed, NULL),
CVAR_INIT ("cam4_speed", "0.4", CV_FLOAT|CV_SAVE, CV_CamSpeed, NULL)
};
consvar_t cv_cam_rotate[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("cam_rotate", "0", CV_CALL|CV_NOINIT, CV_CamRotate, CV_CamRotate_OnChange),
CVAR_INIT ("cam2_rotate", "0", CV_CALL|CV_NOINIT, CV_CamRotate, CV_CamRotate2_OnChange),
CVAR_INIT ("cam3_rotate", "0", CV_CALL|CV_NOINIT, CV_CamRotate, CV_CamRotate3_OnChange),
CVAR_INIT ("cam4_rotate", "0", CV_CALL|CV_NOINIT, CV_CamRotate, CV_CamRotate4_OnChange)
};
consvar_t cv_tilting = CVAR_INIT ("tilting", "On", CV_SAVE, CV_OnOff, NULL);
fixed_t t_cam_dist[MAXSPLITSCREENPLAYERS] = {-42,-42,-42,-42};
fixed_t t_cam_height[MAXSPLITSCREENPLAYERS] = {-42,-42,-42,-42};
fixed_t t_cam_rotate[MAXSPLITSCREENPLAYERS] = {-42,-42,-42,-42};

4
src/r_bbox.c
View file

@ -26,7 +26,7 @@ enum {
RENDERHITBOX_RINGS,
};
static CV_PossibleValue_t renderhitbox_cons_t[] = {
CV_PossibleValue_t renderhitbox_cons_t[] = {
{RENDERHITBOX_OFF, "Off"},
{RENDERHITBOX_TANGIBLE, "Tangible"},
{RENDERHITBOX_ALL, "All"},
@ -34,8 +34,6 @@ static CV_PossibleValue_t renderhitbox_cons_t[] = {
{RENDERHITBOX_RINGS, "Rings"},
{0}};
consvar_t cv_renderhitbox = CVAR_INIT ("renderhitbox", "Off", CV_CHEAT, renderhitbox_cons_t, NULL);
struct bbox_col {
INT32 x;
INT32 y;

13
src/r_debug.cpp
View file

@ -22,19 +22,6 @@
using namespace srb2::r_debug;
namespace
{
CV_PossibleValue_t contrast_cons_t[] = {{-FRACUNIT, "MIN"}, {FRACUNIT, "MAX"}, {}};
}; // namespace
consvar_t cv_debugrender_contrast =
CVAR_INIT("debugrender_contrast", "0.0", CV_CHEAT | CV_FLOAT, contrast_cons_t, nullptr);
consvar_t cv_debugrender_spriteclip = CVAR_INIT("debugrender_spriteclip", "Off", CV_CHEAT, CV_OnOff, nullptr);
consvar_t cv_debugrender_portal = CVAR_INIT("debugrender_portal", "Off", CV_CHEAT, CV_OnOff, nullptr);
UINT32 debugrender_highlight;
void R_CheckDebugHighlight(debugrender_highlight_t k)

14
src/r_fps.c
View file

@ -23,20 +23,6 @@
#include "z_zone.h"
#include "console.h" // con_startup_loadprogress
static CV_PossibleValue_t fpscap_cons_t[] = {
#ifdef DEVELOP
// Lower values are actually pretty useful for debugging interp problems!
{1, "MIN"},
#else
{TICRATE, "MIN"},
#endif
{300, "MAX"},
{-1, "Unlimited"},
{0, "Match refresh rate"},
{0, NULL}
};
consvar_t cv_fpscap = CVAR_INIT ("fpscap", "Match refresh rate", CV_SAVE, fpscap_cons_t, NULL);
UINT32 R_GetFramerateCap(void)
{
if (rendermode == render_none)

117
src/r_main.c
View file

@ -129,61 +129,6 @@ int ps_numpolyobjects = 0;
struct RenderStats g_renderstats;
static CV_PossibleValue_t drawdist_cons_t[] = {
/*{256, "256"},*/ {512, "512"}, {768, "768"},
{1024, "1024"}, {1536, "1536"}, {2048, "2048"},
{3072, "3072"}, {4096, "4096"}, {6144, "6144"},
{8192, "8192"}, {0, "Infinite"}, {0, NULL}};
static CV_PossibleValue_t drawdist_precip_cons_t[] = {
{256, "256"}, {512, "512"}, {768, "768"},
{1024, "1024"}, {1536, "1536"}, {2048, "2048"},
{0, "None"}, {0, NULL}};
static CV_PossibleValue_t fov_cons_t[] = {{60*FRACUNIT, "MIN"}, {179*FRACUNIT, "MAX"}, {0, NULL}};
static CV_PossibleValue_t translucenthud_cons_t[] = {{0, "MIN"}, {10, "MAX"}, {0, NULL}};
static CV_PossibleValue_t maxportals_cons_t[] = {{0, "MIN"}, {12, "MAX"}, {0, NULL}}; // lmao rendering 32 portals, you're a card
static CV_PossibleValue_t homremoval_cons_t[] = {{0, "No"}, {1, "Yes"}, {2, "Flash"}, {0, NULL}};
static void Fov_OnChange(void);
static void ChaseCam_OnChange(void);
static void ChaseCam2_OnChange(void);
static void ChaseCam3_OnChange(void);
static void ChaseCam4_OnChange(void);
consvar_t cv_chasecam[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("chasecam", "On", CV_CALL, CV_OnOff, ChaseCam_OnChange),
CVAR_INIT ("chasecam2", "On", CV_CALL, CV_OnOff, ChaseCam2_OnChange),
CVAR_INIT ("chasecam3", "On", CV_CALL, CV_OnOff, ChaseCam3_OnChange),
CVAR_INIT ("chasecam4", "On", CV_CALL, CV_OnOff, ChaseCam4_OnChange)
};
consvar_t cv_shadow = CVAR_INIT ("shadow", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_skybox = CVAR_INIT ("skybox", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_ffloorclip = CVAR_INIT ("ffloorclip", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_allowmlook = CVAR_INIT ("allowmlook", "Yes", CV_NETVAR, CV_YesNo, NULL);
consvar_t cv_showhud = CVAR_INIT ("showhud", "Yes", CV_CALL, CV_YesNo, R_SetViewSize);
consvar_t cv_translucenthud = CVAR_INIT ("translucenthud", "10", CV_SAVE, translucenthud_cons_t, NULL);
consvar_t cv_drawdist = CVAR_INIT ("drawdist", "8192", CV_SAVE, drawdist_cons_t, NULL);
consvar_t cv_drawdist_precip = CVAR_INIT ("drawdist_precip", "1024", CV_SAVE, drawdist_precip_cons_t, NULL);
consvar_t cv_fov[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("fov", "90", CV_FLOAT|CV_CALL, fov_cons_t, Fov_OnChange),
CVAR_INIT ("fov2", "90", CV_FLOAT|CV_CALL, fov_cons_t, Fov_OnChange),
CVAR_INIT ("fov3", "90", CV_FLOAT|CV_CALL, fov_cons_t, Fov_OnChange),
CVAR_INIT ("fov4", "90", CV_FLOAT|CV_CALL, fov_cons_t, Fov_OnChange)
};
// Okay, whoever said homremoval causes a performance hit should be shot.
consvar_t cv_homremoval = CVAR_INIT ("homremoval", "Yes", CV_SAVE, homremoval_cons_t, NULL);
consvar_t cv_maxportals = CVAR_INIT ("maxportals", "2", CV_SAVE, maxportals_cons_t, NULL);
consvar_t cv_drawpickups = CVAR_INIT ("drawpickups", "Yes", CV_CHEAT, CV_YesNo, NULL);
consvar_t cv_debugfinishline = CVAR_INIT ("debugfinishline", "Off", CV_CHEAT, CV_OnOff, NULL);
void SplitScreen_OnChange(void)
{
UINT8 i;
@ -235,27 +180,32 @@ void SplitScreen_OnChange(void)
}
}
}
static void Fov_OnChange(void)
void Fov_OnChange(void);
void Fov_OnChange(void)
{
R_SetViewSize();
}
static void ChaseCam_OnChange(void)
void ChaseCam_OnChange(void);
void ChaseCam_OnChange(void)
{
;
}
static void ChaseCam2_OnChange(void)
void ChaseCam2_OnChange(void);
void ChaseCam2_OnChange(void)
{
;
}
static void ChaseCam3_OnChange(void)
void ChaseCam3_OnChange(void);
void ChaseCam3_OnChange(void)
{
;
}
static void ChaseCam4_OnChange(void)
void ChaseCam4_OnChange(void);
void ChaseCam4_OnChange(void)
{
;
}
@ -1687,58 +1637,11 @@ void R_RenderPlayerView(void)
void R_RegisterEngineStuff(void)
{
UINT8 i;
CV_RegisterVar(&cv_gravity);
CV_RegisterVar(&cv_allowmlook);
CV_RegisterVar(&cv_homremoval);
#ifdef SCRAMBLE_REMOVED
CV_RegisterVar(&cv_scrambleremoved);
#endif
// Enough for dedicated server
if (dedicated)
return;
CV_RegisterVar(&cv_drawdist);
CV_RegisterVar(&cv_drawdist_precip);
CV_RegisterVar(&cv_shadow);
CV_RegisterVar(&cv_skybox);
CV_RegisterVar(&cv_ffloorclip);
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
CV_RegisterVar(&cv_fov[i]);
CV_RegisterVar(&cv_chasecam[i]);
CV_RegisterVar(&cv_cam_dist[i]);
CV_RegisterVar(&cv_cam_still[i]);
CV_RegisterVar(&cv_cam_height[i]);
CV_RegisterVar(&cv_cam_speed[i]);
CV_RegisterVar(&cv_cam_rotate[i]);
}
CV_RegisterVar(&cv_tilting);
CV_RegisterVar(&cv_showhud);
CV_RegisterVar(&cv_translucenthud);
CV_RegisterVar(&cv_maxportals);
CV_RegisterVar(&cv_movebob);
// Frame interpolation/uncapped
CV_RegisterVar(&cv_fpscap);
CV_RegisterVar(&cv_drawpickups);
CV_RegisterVar(&cv_debugfinishline);
// debugging
CV_RegisterVar(&cv_debugrender_contrast);
CV_RegisterVar(&cv_debugrender_spriteclip);
CV_RegisterVar(&cv_debugrender_portal);
COM_AddCommand("debugrender_highlight", Command_Debugrender_highlight);
}

59
src/s_sound.c
View file

@ -44,53 +44,20 @@
static boolean S_AdjustSoundParams(const mobj_t *listener, const mobj_t *source, INT32 *vol, INT32 *sep, INT32 *pitch, sfxinfo_t *sfxinfo);
#endif
CV_PossibleValue_t soundvolume_cons_t[] = {{0, "MIN"}, {MAX_VOLUME, "MAX"}, {0, NULL}};
static void SetChannelsNum(void);
static void Command_Tunes_f(void);
static void Command_RestartAudio_f(void);
static void Command_PlaySound(void);
static void Got_PlaySound(UINT8 **p, INT32 playernum);
static void Command_MusicDef_f(void);
// Sound system toggles
static void GameSounds_OnChange(void);
static void GameDigiMusic_OnChange(void);
static void PlayMusicIfUnfocused_OnChange(void);
static void PlaySoundIfUnfocused_OnChange(void);
// stereo reverse
consvar_t stereoreverse = CVAR_INIT ("stereoreverse", "Off", CV_SAVE, CV_OnOff, NULL);
// if true, all sounds are loaded at game startup
static consvar_t precachesound = CVAR_INIT ("precachesound", "Off", CV_SAVE, CV_OnOff, NULL);
// actual general (maximum) sound & music volume, saved into the config
consvar_t cv_soundvolume = CVAR_INIT ("soundvolume", "80", CV_SAVE, soundvolume_cons_t, NULL);
consvar_t cv_digmusicvolume = CVAR_INIT ("musicvolume", "80", CV_SAVE, soundvolume_cons_t, NULL);
// number of channels available
consvar_t cv_numChannels = CVAR_INIT ("snd_channels", "64", CV_SAVE|CV_CALL, CV_Unsigned, SetChannelsNum);
consvar_t surround = CVAR_INIT ("surround", "Off", CV_SAVE, CV_OnOff, NULL);
static void Captioning_OnChange(void)
void Captioning_OnChange(void);
void Captioning_OnChange(void)
{
S_ResetCaptions();
if (cv_closedcaptioning.value)
S_StartSound(NULL, sfx_menu1);
}
consvar_t cv_closedcaptioning = CVAR_INIT ("closedcaptioning", "Off", CV_SAVE|CV_CALL, CV_OnOff, Captioning_OnChange);
// Sound system toggles, saved into the config
consvar_t cv_gamedigimusic = CVAR_INIT ("music", "On", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, GameDigiMusic_OnChange);
consvar_t cv_gamesounds = CVAR_INIT ("sounds", "On", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, GameSounds_OnChange);
// Window focus sound sytem toggles
consvar_t cv_playmusicifunfocused = CVAR_INIT ("playmusicifunfocused", "No", CV_SAVE|CV_CALL|CV_NOINIT, CV_YesNo, PlayMusicIfUnfocused_OnChange);
consvar_t cv_playsoundifunfocused = CVAR_INIT ("playsoundsifunfocused", "No", CV_SAVE|CV_CALL|CV_NOINIT, CV_YesNo, PlaySoundIfUnfocused_OnChange);
#define S_MAX_VOLUME 127
// when to clip out sounds
@ -223,15 +190,6 @@ void S_RegisterSoundStuff(void)
return;
}
CV_RegisterVar(&stereoreverse);
CV_RegisterVar(&precachesound);
CV_RegisterVar(&surround);
CV_RegisterVar(&cv_playsoundifunfocused);
CV_RegisterVar(&cv_playmusicifunfocused);
CV_RegisterVar(&cv_gamesounds);
CV_RegisterVar(&cv_gamedigimusic);
COM_AddCommand("tunes", Command_Tunes_f);
COM_AddCommand("restartaudio", Command_RestartAudio_f);
COM_AddCommand("playsound", Command_PlaySound);
@ -239,7 +197,8 @@ void S_RegisterSoundStuff(void)
COM_AddCommand("musicdef", Command_MusicDef_f);
}
static void SetChannelsNum(void)
void SetChannelsNum(void);
void SetChannelsNum(void)
{
// Allocating the internal channels for mixing
// (the maximum number of sounds rendered
@ -1273,6 +1232,8 @@ void S_StartSoundName(void *mo, const char *soundname)
//
void S_InitSfxChannels(INT32 sfxVolume)
{
extern consvar_t precachesound;
INT32 i;
if (dedicated)
@ -2421,6 +2382,7 @@ static void Command_MusicDef_f(void)
}
}
void GameSounds_OnChange(void);
void GameSounds_OnChange(void)
{
if (M_CheckParm("-nosound") || M_CheckParm("-noaudio"))
@ -2440,6 +2402,7 @@ void GameSounds_OnChange(void)
}
}
void GameDigiMusic_OnChange(void);
void GameDigiMusic_OnChange(void)
{
if (M_CheckParm("-nomusic") || M_CheckParm("-noaudio"))
@ -2460,7 +2423,8 @@ void GameDigiMusic_OnChange(void)
}
}
static void PlayMusicIfUnfocused_OnChange(void)
void PlayMusicIfUnfocused_OnChange(void);
void PlayMusicIfUnfocused_OnChange(void)
{
if (window_notinfocus)
{
@ -2471,7 +2435,8 @@ static void PlayMusicIfUnfocused_OnChange(void)
}
}
static void PlaySoundIfUnfocused_OnChange(void)
void PlaySoundIfUnfocused_OnChange(void);
void PlaySoundIfUnfocused_OnChange(void)
{
if (!cv_gamesounds.value)
return;

2
src/s_sound.h
View file

@ -44,8 +44,6 @@ extern consvar_t cv_gamesounds;
extern consvar_t cv_playmusicifunfocused;
extern consvar_t cv_playsoundifunfocused;
extern CV_PossibleValue_t soundvolume_cons_t[];
typedef enum
{
SF_TOTALLYSINGLE = 1, // Only play one of these sounds at a time...GLOBALLY

26
src/screen.c
View file

@ -73,19 +73,6 @@ viddef_t vid;
INT32 setmodeneeded; //video mode change needed if > 0 (the mode number to set + 1)
UINT8 setrenderneeded = 0;
//added : 03-02-98: default screen mode, as loaded/saved in config
consvar_t cv_scr_width = CVAR_INIT ("scr_width", "640", CV_SAVE, CV_Unsigned, NULL);
consvar_t cv_scr_height = CVAR_INIT ("scr_height", "400", CV_SAVE, CV_Unsigned, NULL);
static CV_PossibleValue_t scr_depth_cons_t[] = {{8, "8 bits"}, {16, "16 bits"}, {24, "24 bits"}, {32, "32 bits"}, {0, NULL}};
consvar_t cv_scr_depth = CVAR_INIT ("scr_depth", "16 bits", CV_SAVE, scr_depth_cons_t, NULL);
consvar_t cv_renderview = CVAR_INIT ("renderview", "On", 0, CV_OnOff, NULL);
consvar_t cv_vhseffect = CVAR_INIT ("vhspause", "On", CV_SAVE, CV_OnOff, NULL);
static CV_PossibleValue_t shittyscreen_cons_t[] = {{0, "Okay"}, {1, "Shitty"}, {2, "Extra Shitty"}, {0, NULL}};
consvar_t cv_shittyscreen = CVAR_INIT ("televisionsignal", "Okay", CV_NOSHOWHELP, shittyscreen_cons_t, NULL);
CV_PossibleValue_t cv_renderer_t[] = {
{1, "Software"},
#ifdef HWRENDER
@ -94,12 +81,6 @@ CV_PossibleValue_t cv_renderer_t[] = {
{0, NULL}
};
consvar_t cv_renderer = CVAR_INIT ("renderer", "Software", CV_SAVE|CV_NOLUA|CV_CALL, cv_renderer_t, SCR_ChangeRenderer);
static void SCR_ChangeFullscreen(void);
consvar_t cv_fullscreen = CVAR_INIT ("fullscreen", "Yes", CV_SAVE|CV_CALL, CV_YesNo, SCR_ChangeFullscreen);
// =========================================================================
// SCREEN VARIABLES
// =========================================================================
@ -394,8 +375,10 @@ void SCR_Startup(void)
V_Init();
V_Recalc();
CV_RegisterVar(&cv_ticrate);
CV_RegisterVar(&cv_constextsize);
{
extern struct CVarList *cvlist_screen;
CV_RegisterList(cvlist_screen);
}
V_SetPalette(0);
}
@ -489,6 +472,7 @@ void SCR_SetDefaultMode(void)
}
// Change fullscreen on/off according to cv_fullscreen
void SCR_ChangeFullscreen(void);
void SCR_ChangeFullscreen(void)
{
#ifdef DIRECTFULLSCREEN

11
src/sdl/i_video.cpp
View file

@ -113,10 +113,6 @@ static char vidModeName[33][32]; // allow 33 different modes
rendermode_t rendermode = render_soft;
rendermode_t chosenrendermode = render_none; // set by command line arguments
// synchronize page flipping with screen refresh
consvar_t cv_vidwait = CVAR_INIT ("vid_wait", "Off", CV_SAVE, CV_OnOff, NULL);
static consvar_t cv_alwaysgrabmouse = CVAR_INIT ("alwaysgrabmouse", "Off", CV_SAVE, CV_OnOff, NULL);
UINT8 graphics_started = 0; // Is used in console.c and screen.c
// To disable fullscreen at startup; is set in VID_PrepareModeList
@ -332,6 +328,7 @@ static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
static boolean IgnoreMouse(void)
{
extern consvar_t cv_alwaysgrabmouse;
if (cv_alwaysgrabmouse.value)
return false;
if (menuactive)
@ -1604,8 +1601,10 @@ void I_StartupGraphics(void)
COM_AddCommand ("vid_info", VID_Command_Info_f);
COM_AddCommand ("vid_modelist", VID_Command_ModeList_f);
COM_AddCommand ("vid_mode", VID_Command_Mode_f);
CV_RegisterVar (&cv_vidwait);
CV_RegisterVar (&cv_alwaysgrabmouse);
{
extern CVarList *cvlist_graphics_driver;
CV_RegisterList(cvlist_graphics_driver);
}
disable_mouse = static_cast<SDL_bool>(M_CheckParm("-nomouse"));
disable_fullscreen = M_CheckParm("-win") ? SDL_TRUE : SDL_FALSE;

6
src/stun.cpp
View file

@ -29,12 +29,6 @@
#include "i_net.h"
#include "stun.h"
/* https://gist.github.com/zziuni/3741933 */
/* I can only trust google to keep their shit up :y */
consvar_t cv_stunserver = CVAR_INIT (
"stunserver", "stun.l.google.com:19302", CV_SAVE, NULL, NULL
);
static std::vector<stun_callback_t> stun_callbacks;
/* 18.4 STUN UDP and TCP Port Numbers */

53
src/v_video.cpp
View file

@ -52,48 +52,13 @@ UINT8 *screens[5];
// screens[3] = fade screen start
// screens[4] = fade screen end, postimage tempoarary buffer
consvar_t cv_ticrate = CVAR_INIT ("showfps", "No", CV_SAVE, CV_YesNo, NULL);
static void CV_palette_OnChange(void);
static CV_PossibleValue_t gamma_cons_t[] = {{-15, "MIN"}, {5, "MAX"}, {0, NULL}};
consvar_t cv_globalgamma = CVAR_INIT ("gamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
static CV_PossibleValue_t saturation_cons_t[] = {{0, "MIN"}, {10, "MAX"}, {0, NULL}};
consvar_t cv_globalsaturation = CVAR_INIT ("saturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
#define huecoloursteps 4
static CV_PossibleValue_t hue_cons_t[] = {{0, "MIN"}, {(huecoloursteps*6)-1, "MAX"}, {0, NULL}};
consvar_t cv_rhue = CVAR_INIT ("rhue", "0", CV_SAVE|CV_CALL, hue_cons_t, CV_palette_OnChange);
consvar_t cv_yhue = CVAR_INIT ("yhue", "4", CV_SAVE|CV_CALL, hue_cons_t, CV_palette_OnChange);
consvar_t cv_ghue = CVAR_INIT ("ghue", "8", CV_SAVE|CV_CALL, hue_cons_t, CV_palette_OnChange);
consvar_t cv_chue = CVAR_INIT ("chue", "12", CV_SAVE|CV_CALL, hue_cons_t, CV_palette_OnChange);
consvar_t cv_bhue = CVAR_INIT ("bhue", "16", CV_SAVE|CV_CALL, hue_cons_t, CV_palette_OnChange);
consvar_t cv_mhue = CVAR_INIT ("mhue", "20", CV_SAVE|CV_CALL, hue_cons_t, CV_palette_OnChange);
CV_PossibleValue_t hue_cons_t[] = {{0, "MIN"}, {(huecoloursteps*6)-1, "MAX"}, {0, NULL}};
consvar_t cv_rgamma = CVAR_INIT ("rgamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
consvar_t cv_ygamma = CVAR_INIT ("ygamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
consvar_t cv_ggamma = CVAR_INIT ("ggamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
consvar_t cv_cgamma = CVAR_INIT ("cgamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
consvar_t cv_bgamma = CVAR_INIT ("bgamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
consvar_t cv_mgamma = CVAR_INIT ("mgamma", "0", CV_SAVE|CV_CALL, gamma_cons_t, CV_palette_OnChange);
consvar_t cv_rsaturation = CVAR_INIT ("rsaturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
consvar_t cv_ysaturation = CVAR_INIT ("ysaturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
consvar_t cv_gsaturation = CVAR_INIT ("gsaturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
consvar_t cv_csaturation = CVAR_INIT ("csaturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
consvar_t cv_bsaturation = CVAR_INIT ("bsaturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
consvar_t cv_msaturation = CVAR_INIT ("msaturation", "10", CV_SAVE|CV_CALL, saturation_cons_t, CV_palette_OnChange);
static CV_PossibleValue_t constextsize_cons_t[] = {
CV_PossibleValue_t constextsize_cons_t[] = {
{V_NOSCALEPATCH, "Small"}, {V_SMALLSCALEPATCH, "Medium"}, {V_MEDSCALEPATCH, "Large"}, {0, "Huge"},
{0, NULL}};
static void CV_constextsize_OnChange(void);
consvar_t cv_constextsize = CVAR_INIT ("con_textsize", "Medium", CV_SAVE|CV_CALL, constextsize_cons_t, CV_constextsize_OnChange);
consvar_t cv_palette = CVAR_INIT ("palette", "", CV_CHEAT|CV_CALL|CV_NOINIT, NULL, CV_palette_OnChange);
consvar_t cv_palettenum = CVAR_INIT ("palettenum", "0", CV_CHEAT|CV_CALL|CV_NOINIT, CV_Unsigned, CV_palette_OnChange);
// local copy of the palette for V_GetColor()
RGBA_t *pLocalPalette = NULL;
@ -483,7 +448,10 @@ void V_SetPaletteLump(const char *pal)
V_SetPalette(0);
}
static void CV_palette_OnChange(void)
extern "C" {
void CV_palette_OnChange(void);
void CV_palette_OnChange(void)
{
if (con_startup_loadprogress < LOADED_CONFIG)
return;
@ -492,18 +460,25 @@ static void CV_palette_OnChange(void)
V_SetPalette(0);
}
}; // extern "C"
#if defined (__GNUC__) && defined (__i386__) && !defined (NOASM) && !defined (__APPLE__) && !defined (NORUSEASM)
void VID_BlitLinearScreen_ASM(const UINT8 *srcptr, UINT8 *destptr, INT32 width, INT32 height, size_t srcrowbytes,
size_t destrowbytes);
#define HAVE_VIDCOPY
#endif
static void CV_constextsize_OnChange(void)
extern "C" {
void CV_constextsize_OnChange(void);
void CV_constextsize_OnChange(void)
{
if (!con_startup)
con_recalc = true;
}
}; // extern "C"
// --------------------------------------------------------------------------
// Copy a rectangular area from one bitmap to another (8bpp)