diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index dab39589c..e555c1cf6 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -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 @@ -426,7 +427,6 @@ target_compile_options(SRB2SDL2 PRIVATE -Wmissing-prototypes -Wmissing-declarations -Wmissing-noreturn - -Wnested-externs -Winline -Wformat-y2k -Wformat-security diff --git a/src/command.c b/src/command.c index 3d091cbfe..fd5044e8b 100644 --- a/src/command.c +++ b/src/command.c @@ -60,14 +60,13 @@ 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); consvar_t *CV_FindVar(const char *name); static const char *CV_StringValue(const char *var_name); -static consvar_t *consvar_vars; // list of registered console variables +consvar_t *consvar_vars; // list of registered console variables static UINT16 consvar_number_of_netids = 0; static char com_token[1024]; @@ -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); diff --git a/src/command.h b/src/command.h index 52e18f0fd..953af40b1 100644 --- a/src/command.h +++ b/src/command.h @@ -144,6 +144,7 @@ struct consvar_t //NULL, NULL, 0, NULL, NULL |, 0, NULL, NULL, 0, 0, NULL INT32 flags; // flags see cvflags_t above CV_PossibleValue_t *PossibleValue; // table of possible values void (*func)(void); // called on change, if CV_CALL set + const char *description; INT32 value; // for INT32 and fixed_t const char *string; // value in string char *zstring; // Either NULL or same as string. @@ -162,11 +163,52 @@ 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 } +{ __VA_ARGS__, NULL, 0, NULL, NULL, {0, {NULL}}, 0U, (char)0, NULL } +#endif + +extern consvar_t *consvar_vars; // list of registered console variables extern CV_PossibleValue_t CV_OnOff[]; extern CV_PossibleValue_t CV_YesNo[]; @@ -179,6 +221,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 +230,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); diff --git a/src/console.c b/src/console.c index 16fc3b8f9..128e4eba9 100644 --- a/src/console.c +++ b/src/console.c @@ -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 diff --git a/src/console.h b/src/console.h index b5b806369..4f7a517bc 100644 --- a/src/console.h +++ b/src/console.h @@ -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; diff --git a/src/cvars.cpp b/src/cvars.cpp new file mode 100644 index 000000000..88d9c07ee --- /dev/null +++ b/src/cvars.cpp @@ -0,0 +1,1386 @@ +// DR. ROBOTNIK'S RING RACERS +//----------------------------------------------------------------------------- +// Copyright (C) 2023 by James Robert Roman +// +// This program is free software distributed under the +// terms of the GNU General Public License, version 2. +// See the 'LICENSE' file for more details. +//----------------------------------------------------------------------------- + +#include +#include +#include +#include +#include + +// +// Don't include anything here unless it's absolutely needed. +// If you need CV_PossibleValue_t arrays or "OnChange" +// functions, don't include headers -- extern them manually. +// Keep the includes short to minimize recompiles dependent on +// other parts of the codebase. +// +// If your cvar's possible values depend on constants defined +// in some headers, don't include it. Just define the values +// array in another file and extern it from here. +// +// Look at the - HOW TO ORGANIZE - section before changing or +// adding any cvars. +// + +#include "command.h" +#include "doomdef.h" +#include "doomtype.h" +#include "m_fixed.h" // FRACUNIT +#include "r_skins.h" // DEFAULTSKIN + +// There is a memset in one of consvar_t's constructors. It +// SHOULD be safe if there is no polymorphism, but just +// double-checking. +static_assert(std::is_trivially_copyable_v); + +struct consvar_t::Builder +{ + using values_list_t = std::initializer_list; + + struct ValuesCollect + { + explicit ValuesCollect(int size) : values_{new CV_PossibleValue_t[size]} {} + + void release() { values_ = nullptr; } + + operator CV_PossibleValue_t*() const { return values_; } + + ~ValuesCollect() + { + if (values_) + { + delete[] values_; + } + } + + private: + CV_PossibleValue_t* values_; + }; + + CVarList* list_; + consvar_t var_ = {nullptr, nullptr, 0, nullptr, nullptr}; + std::shared_ptr values_collect_; + + explicit Builder(CVarList* list) : list_(list) {} + + Builder operator ()() const { return *this; } + + Builder operator ()(CVarList* list) const + { + Builder builder = *this; + builder.list_ = list; + return builder; + } + + Builder operator ()(const char* name, const char* default_value) const + { + Builder builder = *this; + builder.var_.name = name; + builder.var_.defaultvalue = default_value; + return builder; + } + + Builder& description(const char* description) + { + var_.description = description; + return *this; + } + + Builder& save() + { + var_.flags |= CV_SAVE; + return *this; + } + + Builder& dont_save() + { + var_.flags &= ~(CV_SAVE); + return *this; + } + + Builder& network() + { + var_.flags |= CV_NETVAR; + return *this; + } + + Builder& floating_point() + { + var_.flags |= CV_FLOAT; + return *this; + } + + Builder& cheat() + { + var_.flags |= CV_CHEAT; + return *this; + } + + Builder& flags(INT32 flags) + { + var_.flags |= flags; + return *this; + } + + Builder& on_off() { return values(CV_OnOff); } + Builder& yes_no() { return values(CV_YesNo); } + + Builder& min_max(INT32 min, INT32 max, values_list_t values = {}) + { + return combine_values({{min, "MIN"}, {max, "MAX"}}, values); + } + + Builder& values(values_list_t values) { return combine_values({}, values); } + + Builder& values(CV_PossibleValue_t* values) + { + values_collect_ = {}; + var_.PossibleValue = values; + return *this; + } + + Builder& onchange(void (*fn)()) + { + var_.flags |= CV_CALL; + var_.func = fn; + return *this; + } + + Builder& onchange_noinit(void (*fn)()) + { + var_.flags |= CV_CALL | CV_NOINIT; + var_.func = fn; + return *this; + } + +private: + Builder& combine_values(values_list_t a, values_list_t b) + { + values_collect_ = std::make_shared(a.size() + b.size() + 1); + var_.PossibleValue = *values_collect_; + + std::copy(a.begin(), a.end(), var_.PossibleValue); + std::copy(b.begin(), b.end(), var_.PossibleValue + a.size()); + var_.PossibleValue[a.size() + b.size()] = {}; // terminator + + return *this; + } +}; + +struct CVarList +{ + void add(consvar_t& var) { vec_.push_back(&var); } + + void finish() + { + // load is guaranteed to only be called once, even + // across different instances of CVarList. + static int once_only = load(); + (void)once_only; + + for (consvar_t* var : vec_) + { + CV_RegisterVar(var); + } + + vec_ = {}; + } + +private: + std::vector vec_; + + static int load(); +}; + +consvar_t& consvar_t::operator=(Builder& builder) +{ + *this = builder.var_; + + builder.list_->add(*this); + + // Any memory that was allocated now belongs to the cvar + // and can no longer be managed by the Builder. + if (builder.values_collect_) + { + builder.values_collect_->release(); + } + + return *this; +} + +void CV_RegisterList(CVarList* list) +{ + list->finish(); +} + +// clang-format off + +extern "C" { + +#define X(id) CVarList* id = new CVarList() + +X (cvlist_player); // not required by dedicated servers +X (cvlist_server); // always required + +X (cvlist_command); +X (cvlist_console); +X (cvlist_graphics_driver); +X (cvlist_opengl); +X (cvlist_screen); +X (cvlist_timer); + +X (cvlist_execversion); + +#ifdef DUMPCONSISTENCY + X (cvlist_dumpconsistency); +#endif + +#undef X + +namespace +{ + +const auto Player = consvar_t::Builder(cvlist_player).save(); +const auto Server = consvar_t::Builder(cvlist_server).save(); + +const auto NetVar = Server().network(); +const auto UnsavedNetVar = NetVar().dont_save(); + +const auto OnlineCheat = UnsavedNetVar().cheat(); +const auto ServerCheat = Server().cheat().dont_save(); +const auto PlayerCheat = Player().cheat().dont_save(); +const auto ObjectPlace = Player().flags(CV_NOTINNET).dont_save(); + +const auto Console = consvar_t::Builder(cvlist_console).save(); +const auto OpenGL = consvar_t::Builder(cvlist_opengl).save(); + +const auto MenuDummy = Player().flags(CV_HIDDEN).dont_save(); + +const auto GraphicsDriver = consvar_t::Builder(cvlist_graphics_driver).save(); + +#ifdef DEVELOP + const auto AuthDebug = Player().values(CV_Unsigned).dont_save(); +#endif + +}; // namespace + + +// +// - HOW TO ORGANIZE - +// +// - Prefer to make a section based on cvars being registered together. +// - This is not a hard rule, but if a bunch of cvars are going against this rule, then make a new section. +// - You can make a new section if there are a bunch of cvars following sharing some other kind of similarity. +// - Group cvars together under a CV_PossibleValue_t or "OnChange" function. +// - You may group them together by some other rule if it makes more sense. +// - The cvars in each group are alphabetically sorted. +// - The groups are sorted by the first cvar in each group. +// - Use the variable name, not the console command name, for sorting. +// + + +// +// Player local, not available on dedicated servers. +// These usually save... +// + +consvar_t cv_addons_md5 = Player("addons_md5", "Name").values({{0, "Name"}, {1, "Contents"}}); +consvar_t cv_addons_search_case = Player("addons_search_case", "No").yes_no(); +consvar_t cv_addons_search_type = Player("addons_search_type", "Anywhere").values({{0, "Start"}, {1, "Anywhere"}}); +consvar_t cv_addons_showall = Player("addons_showall", "No").yes_no(); +consvar_t cv_allowguests = Player("allowguests", "On").on_off(); + +void AltTitle_OnChange(void); +consvar_t cv_alttitle = Player("alttitle", "Off").flags(CV_NOSHOWHELP).on_off().onchange_noinit(AltTitle_OnChange); + +consvar_t cv_alwaysgrabmouse = GraphicsDriver("alwaysgrabmouse", "Off").on_off(); + +consvar_t cv_apng_delay = Player("apng_speed", "1x").values({ + {1, "1x"}, + {2, "1/2x"}, + {3, "1/3x"}, + {4, "1/4x"}, +}); + +consvar_t cv_apng_downscale = Player("apng_downscale", "On").on_off(); + +void Captioning_OnChange(void); +consvar_t cv_closedcaptioning = Player("closedcaptioning", "Off").on_off().onchange(Captioning_OnChange); + +consvar_t cv_controlperkey = Player("controlperkey", "One").values({{1, "One"}, {2, "Several"}}); + +// actual general (maximum) sound & music volume, saved into the config +// 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 +consvar_t cv_digmusicvolume = Player("musicvolume", "80").min_max(0, 100); +consvar_t cv_soundvolume = Player("soundvolume", "80").min_max(0, 100); + +#ifdef HAVE_DISCORDRPC + void DRPC_UpdatePresence(void); + consvar_t cv_discordasks = Player("discordasks", "Yes").yes_no().onchange(DRPC_UpdatePresence); + consvar_t cv_discordrp = Player("discordrp", "On").on_off().onchange(DRPC_UpdatePresence); + consvar_t cv_discordstreamer = Player("discordstreamer", "Off").on_off(); +#endif + +consvar_t cv_drawdist = Player("drawdist", "8192").values({ + //{256, "256"}, + {512, "512"}, + {768, "768"}, + {1024, "1024"}, + {1536, "1536"}, + {2048, "2048"}, + {3072, "3072"}, + {4096, "4096"}, + {6144, "6144"}, + {8192, "8192"}, + {0, "Infinite"}, +}); + +consvar_t cv_drawdist_precip = Player("drawdist_precip", "1024").values({ + {256, "256"}, + {512, "512"}, + {768, "768"}, + {1024, "1024"}, + {1536, "1536"}, + {2048, "2048"}, + {0, "None"}, +}); + +consvar_t cv_ffloorclip = Player("ffloorclip", "On").on_off(); + +consvar_t cv_fpscap = Player("fpscap", "Match refresh rate").values({ +#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"}, +}); + +void SCR_ChangeFullscreen(void); +consvar_t cv_fullscreen = Player("fullscreen", "Yes").yes_no().onchange(SCR_ChangeFullscreen); + +// Sound system toggles, saved into the config +void GameDigiMusic_OnChange(void); +void GameSounds_OnChange(void); +consvar_t cv_gamedigimusic = Player("music", "On").on_off().onchange_noinit(GameDigiMusic_OnChange); +consvar_t cv_gamesounds = Player("sounds", "On").on_off().onchange_noinit(GameSounds_OnChange); + +// time attack ghost options are also saved to config +static CV_PossibleValue_t ghost_cons_t[] = {{0, "Hide"}, {1, "Show Character"}, {2, "Show All"}, {0, NULL}}; +consvar_t cv_ghost_bestlap = Player("ghost_bestlap", "Show All").values(ghost_cons_t); +consvar_t cv_ghost_besttime = Player("ghost_besttime", "Show All").values(ghost_cons_t); +consvar_t cv_ghost_last = Player("ghost_last", "Show All").values(ghost_cons_t); + +static CV_PossibleValue_t ghost2_cons_t[] = {{0, "Hide"}, {1, "Show"}, {0, NULL}}; +consvar_t cv_ghost_guest = Player("ghost_guest", "Show").values(ghost2_cons_t); +consvar_t cv_ghost_staff = Player("ghost_staff", "Show").values(ghost2_cons_t); + +void ItemFinder_OnChange(void); +consvar_t cv_itemfinder = Player("itemfinder", "Off").flags(CV_NOSHOWHELP).on_off().onchange(ItemFinder_OnChange).dont_save(); + +consvar_t cv_maxportals = Player("maxportals", "2").values({{0, "MIN"}, {12, "MAX"}}); // lmao rendering 32 portals, you're a card +consvar_t cv_mindelay = Player("mindelay", "2").min_max(0, 30); +consvar_t cv_movebob = Player("movebob", "1.0").floating_point().min_max(0, 4*FRACUNIT); +consvar_t cv_netstat = Player("netstat", "Off").on_off().dont_save(); // show bandwidth statistics +consvar_t cv_netticbuffer = Player("netticbuffer", "1").min_max(0, 3); + +// number of channels available +void SetChannelsNum(void); +consvar_t cv_numChannels = Player("snd_channels", "64").values(CV_Unsigned).onchange(SetChannelsNum); + +extern CV_PossibleValue_t perfstats_cons_t[]; +consvar_t cv_perfstats = Player("perfstats", "Off").dont_save().values(perfstats_cons_t); + +// Window focus sound sytem toggles +void PlayMusicIfUnfocused_OnChange(void); +void PlaySoundIfUnfocused_OnChange(void); +consvar_t cv_playmusicifunfocused = Player("playmusicifunfocused", "No").yes_no().onchange_noinit(PlayMusicIfUnfocused_OnChange); +consvar_t cv_playsoundifunfocused = Player("playsoundsifunfocused", "No").yes_no().onchange_noinit(PlaySoundIfUnfocused_OnChange); + +// Pause game upon window losing focus +consvar_t cv_pauseifunfocused = Player("pauseifunfocused", "Yes").yes_no(); + +extern CV_PossibleValue_t cv_renderer_t[]; +consvar_t cv_renderer = Player("renderer", "Software").flags(CV_NOLUA).values(cv_renderer_t).onchange(SCR_ChangeRenderer); + +consvar_t cv_renderview = Player("renderview", "On").on_off().dont_save(); +consvar_t cv_rollingdemos = Player("rollingdemos", "On").on_off(); +consvar_t cv_scr_depth = Player("scr_depth", "16 bits").values({{8, "8 bits"}, {16, "16 bits"}, {24, "24 bits"}, {32, "32 bits"}}); + +//added : 03-02-98: default screen mode, as loaded/saved in config +consvar_t cv_scr_width = Player("scr_width", "640").values(CV_Unsigned); +consvar_t cv_scr_height = Player("scr_height", "400").values(CV_Unsigned); + +consvar_t cv_seenames = Player("seenames", "On").on_off(); +consvar_t cv_shadow = Player("shadow", "On").on_off(); +consvar_t cv_shittyscreen = Player("televisionsignal", "Okay").flags(CV_NOSHOWHELP).values({{0, "Okay"}, {1, "Shitty"}, {2, "Extra Shitty"}}).dont_save(); +consvar_t cv_showfocuslost = Player("showfocuslost", "Yes").yes_no(); + +void R_SetViewSize(void); +consvar_t cv_showhud = Player("showhud", "Yes").yes_no().onchange(R_SetViewSize).dont_save(); + +consvar_t cv_showinputjoy = Player("showinputjoy", "Off").on_off().dont_save(); +consvar_t cv_skybox = Player("skybox", "On").on_off(); + +// Display song credits +consvar_t cv_songcredits = Player("songcredits", "On").on_off(); + +void SoundTest_OnChange(void); +consvar_t cv_soundtest = Player("soundtest", "0").onchange(SoundTest_OnChange).dont_save(); + +// Cvar for using splitscreen with 1 device. +consvar_t cv_splitdevice = Player("splitdevice", "Off").on_off(); + +void Splitplayers_OnChange(void); +consvar_t cv_splitplayers = Player("splitplayers", "One").values({{1, "One"}, {2, "Two"}, {3, "Three"}, {4, "Four"}}).onchange(Splitplayers_OnChange).dont_save(); + +consvar_t cv_ticrate = Player(cvlist_screen)("showfps", "No").yes_no(); +consvar_t cv_tilting = Player("tilting", "On").on_off(); +consvar_t cv_translucenthud = Player("translucenthud", "10").min_max(0, 10); + +// first time memory +consvar_t cv_tutorialprompt = Player("tutorialprompt", "On").on_off(); + +void I_StartupMouse(void); +consvar_t cv_usemouse = Player("use_mouse", "Off").values({{0, "Off"}, {1, "On"}, {2, "Force"}}).onchange(I_StartupMouse); + +consvar_t cv_vhseffect = Player("vhspause", "On").on_off(); + +// synchronize page flipping with screen refresh +consvar_t cv_vidwait = GraphicsDriver("vid_wait", "Off").on_off(); + +// if true, all sounds are loaded at game startup +consvar_t precachesound = Player("precachesound", "Off").on_off(); + +// stereo reverse +consvar_t stereoreverse = Player("stereoreverse", "Off").on_off(); + +consvar_t surround = Player("surround", "Off").on_off(); + + +// +// Server local, also available on dedicated servers. +// Usually saved, not sycned though... +// + +void Joinable_OnChange(void); +consvar_t cv_allownewplayer = Server("allowjoin", "On").on_off().onchange(Joinable_OnChange); +consvar_t cv_maxconnections = Server("maxconnections", "16").min_max(2, MAXPLAYERS).onchange(Joinable_OnChange); + +// autorecord demos for time attack +consvar_t cv_autorecord = Server("autorecord", "Yes").yes_no().dont_save(); + +// Here for dedicated servers +consvar_t cv_discordinvites = Server("discordinvites", "Everyone").values({{0, "Admins Only"}, {1, "Everyone"}}).onchange(Joinable_OnChange); + +consvar_t cv_downloading = Server("downloading", "On").on_off().dont_save(); + +// Okay, whoever said homremoval causes a performance hit should be shot. +consvar_t cv_homremoval = Server("homremoval", "Yes").values({{0, "No"}, {1, "Yes"}, {2, "Flash"}}); + +consvar_t cv_httpsource = Server("http_source", ""); + +void JoinTimeout_OnChange(void); +consvar_t cv_jointimeout = Server("jointimeout", "210").min_max(TICRATE/7, 60*TICRATE).onchange(JoinTimeout_OnChange); + +extern CV_PossibleValue_t kartvoices_cons_t[]; +consvar_t cv_karthorns = Server("taunthorns", "Tasteful").values(kartvoices_cons_t); +consvar_t cv_kartvoices = Server("tauntvoices", "Tasteful").values(kartvoices_cons_t); + +consvar_t cv_kartspeedometer = Server("speedometer", "Percentage").values({{0, "Off"}, {1, "Percentage"}, {2, "Kilometers"}, {3, "Miles"}, {4, "Fracunits"}}); // use tics in display +consvar_t cv_kicktime = Server("kicktime", "20").values(CV_Unsigned); + +void MasterServer_OnChange(void); +consvar_t cv_masterserver = Server("masterserver", "https://ms.kartkrew.org/ms/api").onchange(MasterServer_OnChange); + +void MasterServer_Debug_OnChange (void); +consvar_t cv_masterserver_debug = Server("masterserver_debug", "Off").on_off().onchange(MasterServer_Debug_OnChange); + +consvar_t cv_masterserver_timeout = Server("masterserver_timeout", "5").values(CV_Unsigned); +consvar_t cv_masterserver_token = Server("masterserver_token", ""); + +void MasterClient_Ticker(void); +consvar_t cv_masterserver_update_rate = Server("masterserver_update_rate", "15").min_max(2, 60).onchange_noinit(MasterClient_Ticker); + +consvar_t cv_maxping = Server("maxdelay", "20").values(CV_Unsigned); +consvar_t cv_menujam = Server("menujam", "menu").values({{0, "menu"}, {1, "menu2"}, {2, "menu3"}}); +consvar_t cv_menujam_update = Server("menujam_update", "Off").on_off(); +consvar_t cv_netdemosyncquality = Server("netdemo_syncquality", "1").min_max(1, 35); + +void NetTimeout_OnChange(void); +consvar_t cv_nettimeout = Server("nettimeout", "210").min_max(TICRATE/7, 60*TICRATE).onchange(NetTimeout_OnChange); + +consvar_t cv_pause = NetVar("pausepermission", "Server").values({{0, "Server"}, {1, "All"}}); +consvar_t cv_pingmeasurement = Server("pingmeasurement", "Frames").values({{0, "Frames"}, {1, "Milliseconds"}}); +consvar_t cv_playbackspeed = Server("playbackspeed", "1").min_max(1, 10).dont_save(); + +#ifdef TESTERS + consvar_t cv_recordmultiplayerdemos = Server("netdemo_record", "Auto Save").values({{2, "Auto Save"}}); +#else + consvar_t cv_recordmultiplayerdemos = Server("netdemo_record", "Manual Save").values({{0, "Disabled"}, {1, "Manual Save"}, {2, "Auto Save"}}); +#endif + +consvar_t cv_reducevfx = Server("reducevfx", "No").yes_no(); + +void RendezvousServer_OnChange(void); +consvar_t cv_rendezvousserver = Server("holepunchserver", "relay.kartkrew.org").onchange(RendezvousServer_OnChange); + +void Update_parameters (void); +consvar_t cv_server_contact = Server("server_contact", "").onchange_noinit(Update_parameters); +consvar_t cv_servername = Server("servername", "Ring Racers server").onchange_noinit(Update_parameters); + +void M_SortServerList(void); +consvar_t cv_serversort = Server("serversort", "Ping").dont_save().onchange(M_SortServerList).values({ + {0,"Ping"}, + {1,"AVG. Power Level"}, + {2,"Most Players"}, + {3,"Least Players"}, + {4,"Max Player Slots"}, + {5,"Gametype"}, +}); + +// show your ping on the HUD next to framerate. Defaults to warning only (shows up if your ping is > maxping) +consvar_t cv_showping = Server("showping", "Always").values({{0, "Off"}, {1, "Always"}, {2, "Warning"}}); + +consvar_t cv_showviewpointtext = Server("showviewpointtext", "On").on_off(); +consvar_t cv_skipmapcheck = Server("skipmapcheck", "Off").on_off(); +consvar_t cv_sleep = Server("cpusleep", "1").min_max(0, 1000/TICRATE); + +#ifdef USE_STUN + /* https://gist.github.com/zziuni/3741933 */ + /* I can only trust google to keep their shit up :y */ + consvar_t cv_stunserver = Server("stunserver", "stun.l.google.com:19302"); +#endif + + +// +// Netvars - synced in netgames, also saved. +// There's a separate section for netvars that don't save... +// + +void AutoBalance_OnChange(void); +consvar_t cv_autobalance = NetVar("autobalance", "Off").on_off().onchange(AutoBalance_OnChange); + +consvar_t cv_blamecfail = NetVar("blamecfail", "Off").on_off(); + +// Speed of file downloading (in packets per tic) +consvar_t cv_downloadspeed = NetVar("downloadspeed", "32").min_max(1, 300); + +#ifdef DUMPCONSISTENCY + consvar_t cv_dumpconsistency = NetVar(cvlist_dumpconsistency)("dumpconsistency", "Off").on_off(); +#endif + +// Intermission time Tails 04-19-2002 +consvar_t cv_inttime = NetVar("inttime", "10").min_max(0, 3600); + +consvar_t cv_joindelay = NetVar("joindelay", "10").min_max(1, 3600, {{0, "Off"}}); + +#ifdef VANILLAJOINNEXTROUND + consvar_t cv_joinnextround = NetVar("joinnextround", "Off").on_off(); /// \todo not done +#endif + +void Lagless_OnChange(void); +consvar_t cv_lagless = NetVar("lagless", "Off").on_off().onchange(Lagless_OnChange); + +// max file size to send to a player (in kilobytes) +consvar_t cv_maxsend = NetVar("maxsend", "51200").min_max(0, 51200); + +consvar_t cv_noticedownload = NetVar("noticedownload", "Off").on_off(); +consvar_t cv_pingtimeout = NetVar("maxdelaytimeout", "10").min_max(8, 120); +consvar_t cv_resynchattempts = NetVar("resynchattempts", "2").min_max(1, 20, {{0, "No"}}); + +void TeamScramble_OnChange(void); +consvar_t cv_scrambleonchange = NetVar("scrambleonchange", "Off").values({{0, "Off"}, {1, "Random"}, {2, "Points"}}); +consvar_t cv_teamscramble = NetVar("teamscramble", "Off").values({{0, "Off"}, {1, "Random"}, {2, "Points"}}).onchange_noinit(TeamScramble_OnChange); + +consvar_t cv_showjoinaddress = NetVar("showjoinaddress", "Off").on_off(); +consvar_t cv_zvote_delay = NetVar("zvote_delay", "20").values(CV_Unsigned); +consvar_t cv_zvote_length = NetVar("zvote_length", "20").values(CV_Unsigned); +consvar_t cv_zvote_quorum = NetVar("zvote_quorum", "0.6").floating_point().min_max(0, FRACUNIT); +consvar_t cv_zvote_spectators = NetVar("zvote_spectator_votes", "Off").on_off(); + + +// +// Netvars that don't save... +// + +consvar_t cv_advancemap = UnsavedNetVar("advancemap", "Vote").values({{0, "Same"}, {1, "Next"}, {2, "Random"}, {3, "Vote"}}); + +void Advertise_OnChange(void); +consvar_t cv_advertise = UnsavedNetVar("advertise", "No").yes_no().onchange_noinit(Advertise_OnChange); + +consvar_t cv_allowexitlevel = UnsavedNetVar("allowexitlevel", "No").yes_no(); +consvar_t cv_allowmlook = UnsavedNetVar("allowmlook", "Yes").yes_no(); +consvar_t cv_allowteamchange = UnsavedNetVar("allowteamchange", "Yes").yes_no(); +consvar_t cv_antigrief = UnsavedNetVar("antigrief", "30").min_max(10, 180, {{0, "Off"}}); +consvar_t cv_automate = UnsavedNetVar("automate", "On").on_off(); + +// If on and you're an admin, your messages will automatically become shouts. +consvar_t cv_autoshout = UnsavedNetVar("autoshout", "Off").on_off(); + +consvar_t cv_cheats = UnsavedNetVar(cvlist_command)("cheats", +#ifdef DEVELOP + "On" +#else + "Off" +#endif +).on_off().onchange_noinit(CV_CheatsChanged); + +consvar_t cv_countdowntime = UnsavedNetVar("countdowntime", "30").min_max(15, 9999); +consvar_t cv_duelspectatorreentry = UnsavedNetVar("duelspectatorreentry", "180").min_max(0, 10*60); + +// SRB2kart +consvar_t cv_items[] = { + UnsavedNetVar("sneaker", "On").on_off(), + UnsavedNetVar("rocketsneaker", "On").on_off(), + UnsavedNetVar("invincibility", "On").on_off(), + UnsavedNetVar("banana", "On").on_off(), + UnsavedNetVar("eggmark", "On").on_off(), + UnsavedNetVar("orbinaut", "On").on_off(), + UnsavedNetVar("jawz", "On").on_off(), + UnsavedNetVar("mine", "On").on_off(), + UnsavedNetVar("landmine", "On").on_off(), + UnsavedNetVar("ballhog", "On").on_off(), + UnsavedNetVar("selfpropelledbomb", "On").on_off(), + UnsavedNetVar("grow", "On").on_off(), + UnsavedNetVar("shrink", "On").on_off(), + UnsavedNetVar("lightningshield", "On").on_off(), + UnsavedNetVar("bubbleshield", "On").on_off(), + UnsavedNetVar("flameshield", "On").on_off(), + UnsavedNetVar("hyudoro", "On").on_off(), + UnsavedNetVar("pogospring", "On").on_off(), + UnsavedNetVar("superring", "On").on_off(), + UnsavedNetVar("kitchensink", "On").on_off(), + UnsavedNetVar("droptarget", "On").on_off(), + UnsavedNetVar("gardentop", "On").on_off(), + UnsavedNetVar("gachabom", "On").on_off(), + UnsavedNetVar("dualsneaker", "On").on_off(), + UnsavedNetVar("triplesneaker", "On").on_off(), + UnsavedNetVar("triplebanana", "On").on_off(), + UnsavedNetVar("tripleorbinaut", "On").on_off(), + UnsavedNetVar("quadorbinaut", "On").on_off(), + UnsavedNetVar("dualjawz", "On").on_off(), + UnsavedNetVar("triplegachabom", "On").on_off(), +}; + +consvar_t cv_kartbot = UnsavedNetVar("bots", "Off").values({ + {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"}, +}); + +consvar_t cv_kartbumpers = UnsavedNetVar("battlebumpers", "3").min_max(1, 12); + +void KartEliminateLast_OnChange(void); +consvar_t cv_karteliminatelast = UnsavedNetVar("eliminatelast", "Yes").yes_no().onchange(KartEliminateLast_OnChange); + +void KartEncore_OnChange(void); +consvar_t cv_kartencore = UnsavedNetVar("encore", "Auto").values({{-1, "Auto"}, {0, "Off"}, {1, "On"}}).onchange_noinit(KartEncore_OnChange); + +void KartFrantic_OnChange(void); +consvar_t cv_kartfrantic = UnsavedNetVar("franticitems", "Off").on_off().onchange_noinit(KartFrantic_OnChange); + +void KartSpeed_OnChange(void); +consvar_t cv_kartspeed = UnsavedNetVar("gamespeed", "Auto").values(kartspeed_cons_t).onchange_noinit(KartSpeed_OnChange); + +consvar_t cv_kartusepwrlv = UnsavedNetVar("usepwrlv", "Yes").yes_no(); + +void LiveStudioAudience_OnChange(void); +#ifdef DEVELOP + consvar_t cv_livestudioaudience = UnsavedNetVar("livestudioaudience", "On").on_off().onchange(LiveStudioAudience_OnChange); +#else + consvar_t cv_livestudioaudience = UnsavedNetVar("livestudioaudience", "Off").on_off().onchange(LiveStudioAudience_OnChange); +#endif + +consvar_t cv_maxplayers = UnsavedNetVar("maxplayers", "8").min_max(1, MAXPLAYERS); + +// Scoring type options +consvar_t cv_overtime = UnsavedNetVar("overtime", "Yes").yes_no(); + +extern CV_PossibleValue_t pointlimit_cons_t[]; +void PointLimit_OnChange(void); +consvar_t cv_pointlimit = UnsavedNetVar("pointlimit", "Default").values(pointlimit_cons_t).onchange_noinit(PointLimit_OnChange); + +void Schedule_OnChange(void); +consvar_t cv_schedule = UnsavedNetVar("schedule", "On").on_off().onchange(Schedule_OnChange); + +consvar_t cv_shoutcolor = UnsavedNetVar("shout_color", "Red").values({ + {-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"}, +}); + +// Shout settings +// The relevant ones are CV_NETVAR because too lazy to send them any other way +consvar_t cv_shoutname = UnsavedNetVar("shout_name", "SERVER"); + +consvar_t cv_spectatorreentry = UnsavedNetVar("spectatorreentry", "30").min_max(0, 10*60); +consvar_t cv_thunderdome = UnsavedNetVar("thunderdome", "Off").on_off(); + +void TimeLimit_OnChange(void); +consvar_t cv_timelimit = UnsavedNetVar("timelimit", "Default").min_max(1, 30*60, {{0, "None"}, {-1, "Default"}}).onchange_noinit(TimeLimit_OnChange); + +consvar_t cv_votetime = UnsavedNetVar("votetime", "20").min_max(10, 3600); + + +// +// Online cheats - synced in netgames. +// Cheats don't save... +// + +consvar_t cv_battletest = OnlineCheat("battletest", "Off").on_off().description("Free Play goes to Battle instead of Prisons"); + +#ifdef DEVELOP + consvar_t cv_botcontrol = OnlineCheat("botcontrol", "On").on_off().description("Toggle bot AI movement"); +#endif + +extern CV_PossibleValue_t capsuletest_cons_t[]; +void CapsuleTest_OnChange(void); +consvar_t cv_capsuletest = OnlineCheat("capsuletest", "Off").values(capsuletest_cons_t).onchange(CapsuleTest_OnChange).description("Force item capsule spawning rules"); + +consvar_t cv_debugencorevote = OnlineCheat("debugencorevote", "Off").on_off().description("Force encore choice to appear on vote screen"); + +void ForceSkin_OnChange(void); +consvar_t cv_forceskin = OnlineCheat("forcecharacter", "None").onchange(ForceSkin_OnChange).description("Force all players to use one character"); + +consvar_t cv_kartdebugamount = OnlineCheat("debugitemamount", "1").min_max(1, 255).description("If debugitem, give multiple copies of an item"); +consvar_t cv_kartdebugbots = OnlineCheat("debugbots", "Off").on_off().description("Bot AI debugger"); +consvar_t cv_kartdebugdistribution = OnlineCheat("debugitemodds", "Off").on_off().description("Show items that the roulette can roll"); +consvar_t cv_kartdebughuddrop = OnlineCheat("debugitemdrop", "Off").on_off().description("Players drop paper items when damaged in any way"); + +extern CV_PossibleValue_t kartdebugitem_cons_t[]; +consvar_t cv_kartdebugitem = OnlineCheat("debugitem", "None").values(kartdebugitem_cons_t).description("Force item boxes to only roll one kind of item"); + +consvar_t cv_kartdebugstart = OnlineCheat("debugstart", "Off").on_off().description("Skip POSITION"); +consvar_t cv_kartdebugwaypoints = OnlineCheat("debugwaypoints", "Off").values({{0, "Off"}, {1, "Forwards"}, {2, "Backwards"}}).description("Make waypoints visible"); + +#ifdef DEVELOP + consvar_t cv_kartencoremap = OnlineCheat("encoremap", "On").on_off().description("Toggle Encore colormap"); +#endif + +extern CV_PossibleValue_t numlaps_cons_t[]; +void NumLaps_OnChange(void); +consvar_t cv_numlaps = OnlineCheat("numlaps", "Map default").values(numlaps_cons_t).onchange(NumLaps_OnChange).save().description("Race maps always have the same number of laps"); + +consvar_t cv_restrictskinchange = OnlineCheat("restrictskinchange", "Yes").yes_no().description("Don't let players change their skin in the middle of gameplay"); +consvar_t cv_spbtest = OnlineCheat("spbtest", "Off").on_off().description("SPB can never target a player"); +consvar_t cv_timescale = OnlineCheat(cvlist_timer)("timescale", "1.0").floating_point().min_max(FRACUNIT/20, 20*FRACUNIT).description("Overclock or slow down the game"); + + +// +// Server local cheats. +// Not netsynced, not saved... +// + +consvar_t cv_botscanvote = ServerCheat("botscanvote", "No").yes_no(); +consvar_t cv_debugrank = ServerCheat("debugrank", "Off").on_off().description("Show GP rank state on the HUD"); + +void Gravity_OnChange(void); +consvar_t cv_gravity = ServerCheat("gravity", "0.8").floating_point().onchange(Gravity_OnChange).description("Change the default gravity"); // change DEFAULT_GRAVITY if you change this + +consvar_t cv_kartdebugcolorize = ServerCheat("debugcolorize", "Off").on_off().description("Show all colorized options on the HUD"); +consvar_t cv_kartdebugdirector = ServerCheat("debugdirector", "Off").on_off().description("Show director AI on the HUD"); +consvar_t cv_kartdebugnodes = ServerCheat("debugnodes", "Off").on_off().description("Show player node and latency on the HUD"); + + +// +// Player local cheats. +// Dedicated servers don't see these. +// Not saved... +// + +consvar_t cv_debugfinishline = PlayerCheat("debugfinishline", "Off").on_off().description("Highlight finish lines and respawn lines with high contrast colors"); +consvar_t cv_debugrender_contrast = PlayerCheat("debugrender_contrast", "0.0").floating_point().min_max(-FRACUNIT, FRACUNIT).description("Change level lighting"); +consvar_t cv_debugrender_portal = PlayerCheat("debugrender_portal", "Off").on_off().description("Highlight visual portals in red"); +consvar_t cv_debugrender_spriteclip = PlayerCheat("debugrender_spriteclip", "Off").on_off().description("Let sprites draw through walls"); +consvar_t cv_devmode_screen = PlayerCheat("devmode_screen", "1").min_max(1, 4).description("Choose which splitscreen player devmode applies to"); +consvar_t cv_drawpickups = PlayerCheat("drawpickups", "Yes").yes_no().description("Hide rings, spheres, item capsules, prison capsules (visual only)"); + +void CV_palette_OnChange(void); +consvar_t cv_palette = PlayerCheat("palette", "").onchange_noinit(CV_palette_OnChange).description("Force palette to a different lump"); +consvar_t cv_palettenum = PlayerCheat("palettenum", "0").values(CV_Unsigned).onchange_noinit(CV_palette_OnChange).description("Use a different sub-palette by default"); + +extern CV_PossibleValue_t renderhitbox_cons_t[]; +consvar_t cv_renderhitbox = PlayerCheat("renderhitbox", "Off").values(renderhitbox_cons_t).description("Show hitboxes around objects"); + + +// +// Dummy 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. +// + +extern CV_PossibleValue_t skins_cons_t[]; +consvar_t cv_chooseskin = MenuDummy(cvlist_server)("chooseskin", DEFAULTSKIN).values(skins_cons_t); + +void M_UpdateAddonsSearch(void); +consvar_t cv_dummyaddonsearch = MenuDummy("dummyaddonsearch", "").onchange_noinit(M_UpdateAddonsSearch); + +consvar_t cv_dummyextraspassword = MenuDummy("dummyextraspassword", ""); + +extern CV_PossibleValue_t gpdifficulty_cons_t[]; +consvar_t cv_dummygpdifficulty = MenuDummy("dummygpdifficulty", "Normal").values(gpdifficulty_cons_t); +consvar_t cv_dummygpencore = MenuDummy("dummygpencore", "Off").on_off(); + +consvar_t cv_dummyip = MenuDummy("dummyip", ""); + +extern CV_PossibleValue_t dummykartspeed_cons_t[]; +consvar_t cv_dummykartspeed = MenuDummy("dummykartspeed", "Normal").values(dummykartspeed_cons_t); + +consvar_t cv_dummymatchbots = MenuDummy("dummymatchbots", "Off").values({ + {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"}, +}); + +void Dummymenuplayer_OnChange(void); +consvar_t cv_dummymenuplayer = MenuDummy("dummymenuplayer", "P1").onchange(Dummymenuplayer_OnChange).values({{0, "NOPE"}, {1, "P1"}, {2, "P2"}, {3, "P3"}, {4, "P4"}}); + +consvar_t cv_dummyprofileautoroulette = MenuDummy("dummyprofileautoroulette", "Off").on_off(); +consvar_t cv_dummyprofilekickstart = MenuDummy("dummyprofilekickstart", "Off").on_off(); +consvar_t cv_dummyprofilename = MenuDummy("dummyprofilename", ""); +consvar_t cv_dummyprofileplayername = MenuDummy("dummyprofileplayername", ""); +consvar_t cv_dummyprofilerumble = MenuDummy("dummyprofilerumble", "On").on_off(); + +consvar_t cv_dummyscramble = MenuDummy("dummyscramble", "Random").values({{0, "Random"}, {1, "Points"}}); + +void CV_SPBAttackChanged(void); +consvar_t cv_dummyspbattack = MenuDummy("dummyspbattack", "Off").on_off().onchange(CV_SPBAttackChanged); + +consvar_t cv_dummyspectate = MenuDummy("dummyspectate", "Spectator").values({{0, "Spectator"}, {1, "Playing"}}); + +extern CV_PossibleValue_t dummystaff_cons_t[]; +void Dummystaff_OnChange(void); +consvar_t cv_dummystaff = MenuDummy("dummystaff", "0").values(dummystaff_cons_t).onchange(Dummystaff_OnChange); + +consvar_t cv_dummyteam = MenuDummy("dummyteam", "Spectator").values({{0, "Spectator"}, {1, "Red"}, {2, "Blue"}}); + + +// +// lastprofile +// + +extern CV_PossibleValue_t lastprofile_cons_t[]; + +// currently loaded profile for P1 menuing. +// You choose this profile when starting the game, this will also set lastprofile[0] +consvar_t cv_currprofile = MenuDummy("currprofile", "-1").values(lastprofile_cons_t); + +// last selected profile, unaccessible cvar only set internally but is saved. +// It's used to know what profile to autoload you to when you get into the character setup. +consvar_t cv_lastprofile[MAXSPLITSCREENPLAYERS] = { + Player("lastprofile", "0").flags(CV_HIDDEN).values(lastprofile_cons_t), + Player("lastprofile2", "0").flags(CV_HIDDEN).values(lastprofile_cons_t), + Player("lastprofile3", "0").flags(CV_HIDDEN).values(lastprofile_cons_t), + Player("lastprofile4", "0").flags(CV_HIDDEN).values(lastprofile_cons_t), +}; + +// This one is used exclusively for the titlescreen +consvar_t cv_ttlprofilen = Player("ttlprofilen", "0").values(lastprofile_cons_t); + + +// +// GIF / Movie / Screenshot +// + +consvar_t cv_gif_downscale = Player("gif_downscale", "On").on_off(); +consvar_t cv_gif_dynamicdelay = Player("gif_dynamicdelay", "On").values({{0, "Off"}, {1, "On"}, {2, "Accurate, experimental"}}); +consvar_t cv_gif_localcolortable = Player("gif_localcolortable", "On").on_off(); +consvar_t cv_gif_optimize = Player("gif_optimize", "On").on_off(); + +extern CV_PossibleValue_t lossless_recorder_cons_t[]; +consvar_t cv_lossless_recorder = Player("lossless_recorder", "GIF").values(lossless_recorder_cons_t); + +#ifdef SRB2_CONFIG_ENABLE_WEBM_MOVIES + extern CV_PossibleValue_t movie_resolution_cons_t[]; + consvar_t cv_movie_custom_resolution = Player("movie_custom_resolution", "640x400"); + consvar_t cv_movie_resolution = Player("movie_resolution", "Medium").values(movie_resolution_cons_t); + + static CV_PossibleValue_t movie_limit_cons_t[] = {{1, "MIN"}, {INT32_MAX, "MAX"}, {0, "Unlimited"}, {0, NULL}}; + consvar_t cv_movie_duration = Player("movie_duration", "Unlimited").floating_point().values(movie_limit_cons_t); + consvar_t cv_movie_size = Player("movie_size", "25.0").floating_point().values(movie_limit_cons_t); + + consvar_t cv_movie_fps = Player("movie_fps", "60").values(CV_Natural); + consvar_t cv_movie_showfps = Player("movie_showfps", "Yes").yes_no(); + consvar_t cv_movie_sound = Player("movie_sound", "On").on_off(); +#endif + +consvar_t cv_screenshot_colorprofile = Player("screenshot_colorprofile", "Yes").yes_no(); + +extern CV_PossibleValue_t zlib_mem_level_t[]; +extern CV_PossibleValue_t zlib_level_t[]; +extern CV_PossibleValue_t zlib_strategy_t[]; +extern CV_PossibleValue_t zlib_window_bits_t[]; + +// zlib memory usage is as follows: +// (1 << (zlib_window_bits+2)) + (1 << (zlib_level+9)) +consvar_t cv_zlib_level = Player("png_compress_level", "(Optimal) 6").values(zlib_level_t); +consvar_t cv_zlib_memory = Player("png_memory_level", "7").values(zlib_mem_level_t); +consvar_t cv_zlib_strategy = Player("png_strategy", "Normal").values(zlib_strategy_t); +consvar_t cv_zlib_window_bits = Player("png_window_size", "32k").values(zlib_window_bits_t); + +consvar_t cv_zlib_levela = Player("apng_compress_level", "4").values(zlib_level_t); +consvar_t cv_zlib_memorya = Player("apng_memory_level", "(Max Memory) 9").values(zlib_mem_level_t); +consvar_t cv_zlib_strategya = Player("apng_strategy", "RLE").values(zlib_strategy_t); +consvar_t cv_zlib_window_bitsa = Player("apng_window_size", "32k").values(zlib_window_bits_t); + + +// +// Splitscreen cvars - one each for P1, P2, P3 and P4. +// This is only its own section because it's an ugly mess. +// TODO: make it easier to register splitscreen cvars... +// + +void weaponPrefChange(void); +void weaponPrefChange2(void); +void weaponPrefChange3(void); +void weaponPrefChange4(void); + +consvar_t cv_autoroulette[MAXSPLITSCREENPLAYERS] = { + Player("autoroulette", "Off").on_off().onchange(weaponPrefChange), + Player("autoroulette2", "Off").on_off().onchange(weaponPrefChange2), + Player("autoroulette3", "Off").on_off().onchange(weaponPrefChange3), + Player("autoroulette4", "Off").on_off().onchange(weaponPrefChange4), +}; + +consvar_t cv_cam_dist[MAXSPLITSCREENPLAYERS] = { + Player("cam_dist", "190").floating_point(), + Player("cam2_dist", "190").floating_point(), + Player("cam3_dist", "190").floating_point(), + Player("cam4_dist", "190").floating_point(), +}; + +consvar_t cv_cam_height[MAXSPLITSCREENPLAYERS] = { + Player("cam_height", "95").floating_point(), + Player("cam2_height", "95").floating_point(), + Player("cam3_height", "95").floating_point(), + Player("cam4_height", "95").floating_point(), +}; + +void CV_CamRotate_OnChange(void); +void CV_CamRotate2_OnChange(void); +void CV_CamRotate3_OnChange(void); +void CV_CamRotate4_OnChange(void); + +consvar_t cv_cam_rotate[MAXSPLITSCREENPLAYERS] = { + Player("cam_rotate", "0").min_max(-720, 720).onchange_noinit(CV_CamRotate_OnChange).dont_save(), + Player("cam2_rotate", "0").min_max(-720, 720).onchange_noinit(CV_CamRotate2_OnChange).dont_save(), + Player("cam3_rotate", "0").min_max(-720, 720).onchange_noinit(CV_CamRotate3_OnChange).dont_save(), + Player("cam4_rotate", "0").min_max(-720, 720).onchange_noinit(CV_CamRotate4_OnChange).dont_save(), +}; + +consvar_t cv_cam_speed[MAXSPLITSCREENPLAYERS] = { + Player("cam_speed", "0.4").floating_point().min_max(0, 1*FRACUNIT), + Player("cam2_speed", "0.4").floating_point().min_max(0, 1*FRACUNIT), + Player("cam3_speed", "0.4").floating_point().min_max(0, 1*FRACUNIT), + Player("cam4_speed", "0.4").floating_point().min_max(0, 1*FRACUNIT), +}; + +consvar_t cv_cam_still[MAXSPLITSCREENPLAYERS] = { + Player("cam_still", "Off").on_off().dont_save(), + Player("cam2_still", "Off").on_off().dont_save(), + Player("cam3_still", "Off").on_off().dont_save(), + Player("cam4_still", "Off").on_off().dont_save(), +}; + +void ChaseCam_OnChange(void); +void ChaseCam2_OnChange(void); +void ChaseCam3_OnChange(void); +void ChaseCam4_OnChange(void); + +consvar_t cv_chasecam[MAXSPLITSCREENPLAYERS] = { + Player("chasecam", "On").on_off().onchange(ChaseCam_OnChange).dont_save(), + Player("chasecam2", "On").on_off().onchange(ChaseCam2_OnChange).dont_save(), + Player("chasecam3", "On").on_off().onchange(ChaseCam3_OnChange).dont_save(), + Player("chasecam4", "On").on_off().onchange(ChaseCam4_OnChange).dont_save(), +}; + +consvar_t cv_deadzone[MAXSPLITSCREENPLAYERS] = { + Player("deadzone", "0.25").floating_point().min_max(0, FRACUNIT), + Player("deadzone2", "0.25").floating_point().min_max(0, FRACUNIT), + Player("deadzone3", "0.25").floating_point().min_max(0, FRACUNIT), + Player("deadzone4", "0.25").floating_point().min_max(0, FRACUNIT) +}; + +void Follower_OnChange(void); +void Follower2_OnChange(void); +void Follower3_OnChange(void); +void Follower4_OnChange(void); + +// player's followers. Also saved. +consvar_t cv_follower[MAXSPLITSCREENPLAYERS] = { + Player("follower", "None").onchange_noinit(Follower_OnChange), + Player("follower2", "None").onchange_noinit(Follower2_OnChange), + Player("follower3", "None").onchange_noinit(Follower3_OnChange), + Player("follower4", "None").onchange_noinit(Follower4_OnChange), +}; + +extern CV_PossibleValue_t Followercolor_cons_t[]; +void Followercolor_OnChange(void); +void Followercolor2_OnChange(void); +void Followercolor3_OnChange(void); +void Followercolor4_OnChange(void); + +// player's follower colors... Also saved... +consvar_t cv_followercolor[MAXSPLITSCREENPLAYERS] = { + Player("followercolor", "Match").values(Followercolor_cons_t).onchange_noinit(Followercolor_OnChange), + Player("followercolor2", "Match").values(Followercolor_cons_t).onchange_noinit(Followercolor2_OnChange), + Player("followercolor3", "Match").values(Followercolor_cons_t).onchange_noinit(Followercolor3_OnChange), + Player("followercolor4", "Match").values(Followercolor_cons_t).onchange_noinit(Followercolor4_OnChange), +}; + +void Fov_OnChange(void); +consvar_t cv_fov[MAXSPLITSCREENPLAYERS] = { + Player("fov", "90").floating_point().min_max(60*FRACUNIT, 179*FRACUNIT).onchange(Fov_OnChange).dont_save(), + Player("fov2", "90").floating_point().min_max(60*FRACUNIT, 179*FRACUNIT).onchange(Fov_OnChange).dont_save(), + Player("fov3", "90").floating_point().min_max(60*FRACUNIT, 179*FRACUNIT).onchange(Fov_OnChange).dont_save(), + Player("fov4", "90").floating_point().min_max(60*FRACUNIT, 179*FRACUNIT).onchange(Fov_OnChange).dont_save(), +}; + +void I_JoyScale(void); +void I_JoyScale2(void); +void I_JoyScale3(void); +void I_JoyScale4(void); + +consvar_t cv_joyscale[MAXSPLITSCREENPLAYERS] = { + Player("padscale", "1").onchange(I_JoyScale), + Player("padscale2", "1").onchange(I_JoyScale2), + Player("padscale3", "1").onchange(I_JoyScale3), + Player("padscale4", "1").onchange(I_JoyScale4), +}; + +consvar_t cv_kickstartaccel[MAXSPLITSCREENPLAYERS] = { + Player("kickstartaccel", "Off").on_off().onchange(weaponPrefChange), + Player("kickstartaccel2", "Off").on_off().onchange(weaponPrefChange2), + Player("kickstartaccel3", "Off").on_off().onchange(weaponPrefChange3), + Player("kickstartaccel4", "Off").on_off().onchange(weaponPrefChange4) +}; + +extern CV_PossibleValue_t Color_cons_t[]; +void Color1_OnChange(void); +void Color2_OnChange(void); +void Color3_OnChange(void); +void Color4_OnChange(void); + +// player colors +consvar_t cv_playercolor[MAXSPLITSCREENPLAYERS] = { + Player("color", "Default").values(Color_cons_t).onchange_noinit(Color1_OnChange), + Player("color2", "Default").values(Color_cons_t).onchange_noinit(Color2_OnChange), + Player("color3", "Default").values(Color_cons_t).onchange_noinit(Color3_OnChange), + Player("color4", "Default").values(Color_cons_t).onchange_noinit(Color4_OnChange), +}; + +void Name1_OnChange(void); +void Name2_OnChange(void); +void Name3_OnChange(void); +void Name4_OnChange(void); + +// names +consvar_t cv_playername[MAXSPLITSCREENPLAYERS] = { + Player("name", "Dr. Eggman").onchange_noinit(Name1_OnChange), + Player("name2", "Tails").onchange_noinit(Name2_OnChange), + Player("name3", "Sonic").onchange_noinit(Name3_OnChange), + Player("name4", "Knuckles").onchange_noinit(Name4_OnChange), +}; + +void rumble_off_handle(void); +void rumble_off_handle2(void); +void rumble_off_handle3(void); +void rumble_off_handle4(void); + +consvar_t cv_rumble[MAXSPLITSCREENPLAYERS] = { + Player("rumble", "On").on_off().onchange(rumble_off_handle), + Player("rumble2", "On").on_off().onchange(rumble_off_handle2), + Player("rumble3", "On").on_off().onchange(rumble_off_handle3), + Player("rumble4", "On").on_off().onchange(rumble_off_handle4) +}; + +consvar_t cv_shrinkme[MAXSPLITSCREENPLAYERS] = { + Player("shrinkme", "Off").on_off().onchange(weaponPrefChange).dont_save(), + Player("shrinkme2", "Off").on_off().onchange(weaponPrefChange2).dont_save(), + Player("shrinkme3", "Off").on_off().onchange(weaponPrefChange3).dont_save(), + Player("shrinkme4", "Off").on_off().onchange(weaponPrefChange4).dont_save() +}; + +void Skin1_OnChange(void); +void Skin2_OnChange(void); +void Skin3_OnChange(void); +void Skin4_OnChange(void); + +// player's skin, saved for commodity, when using a favorite skins wad.. +consvar_t cv_skin[MAXSPLITSCREENPLAYERS] = { + Player("skin", DEFAULTSKIN).onchange_noinit(Skin1_OnChange), + Player("skin2", DEFAULTSKIN2).onchange_noinit(Skin2_OnChange), + Player("skin3", DEFAULTSKIN3).onchange_noinit(Skin3_OnChange), + Player("skin4", DEFAULTSKIN4).onchange_noinit(Skin4_OnChange), +}; + + +// +// Developer Console +// + +void CONS_backcolor_Change(void); +consvar_t cons_backcolor = Console("con_backcolor", "Black").onchange(CONS_backcolor_Change).values({ + {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"}, +}); + +// whether to use console background picture, or translucent mode +consvar_t cons_backpic = Console("con_backpic", "translucent").values({{0, "translucent"}, {1, "picture"}}); + +// percentage of screen height to use for console +void CONS_height_Change(void); +consvar_t cons_height = Console("con_height", "50").values(CV_Unsigned).onchange(CONS_height_Change); + +// number of lines displayed on the HUD +extern CV_PossibleValue_t hudlines_cons_t[]; +void CONS_hudlines_Change(void); +consvar_t cons_hudlines = Console("con_hudlines", "5").values(hudlines_cons_t).onchange(CONS_hudlines_Change); + +// 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 +consvar_t cons_hudtime = Console("con_hudtime", "5").min_max(0, 99999999); + +// number of lines console move per frame +// (con_speed needs a limit, apparently) +consvar_t cons_speed = Console("con_speed", "8").min_max(0, 64); + +extern CV_PossibleValue_t constextsize_cons_t[]; +void CV_constextsize_OnChange(void); +consvar_t cv_constextsize = Player(cvlist_screen)("con_textsize", "Medium").values(constextsize_cons_t).onchange(CV_constextsize_OnChange); + + +// +// Chat window +// + +// minichat text background +consvar_t cv_chatbacktint = Player("chatbacktint", "On").on_off(); + +// chatheight +consvar_t cv_chatheight = Player("chatheight", "8").min_max(6, 22); + +// chat notifications (do you want to hear beeps? I'd understand if you didn't.) +consvar_t cv_chatnotifications = Player("chatnotifications", "On").on_off(); + +// chat spam protection (why would you want to disable that???) +consvar_t cv_chatspamprotection = Player("chatspamprotection", "On").on_off(); + +// chat timer thingy +consvar_t cv_chattime = Player("chattime", "8").min_max(5, 999); + +// chatwidth +consvar_t cv_chatwidth = Player("chatwidth", "150").min_max(64, 150); + +// old shit console chat. (mostly exists for stuff like terminal, not because I cared if anyone liked the old chat.) +consvar_t cv_consolechat = Player("chatmode", "Window").values({{0, "Window"}, {1, "Console"}, {2, "Window (Hidden)"}}); + +consvar_t cv_gamestochat = Player("gamestochat", "0").values(CV_Unsigned); + +void Mute_OnChange(void); +consvar_t cv_mute = UnsavedNetVar("mute", "Off").on_off().onchange(Mute_OnChange); + + +// +// OpenGL +// + +#ifdef HWRENDER + consvar_t cv_fovchange = OpenGL("gr_fovchange", "Off").on_off(); + + extern CV_PossibleValue_t glshaders_cons_t[]; + consvar_t cv_glallowshaders = OpenGL("gr_allowclientshaders", "On").on_off().network().dont_save(); + consvar_t cv_glshaders = OpenGL("gr_shaders", "On").values(glshaders_cons_t); + + extern CV_PossibleValue_t glanisotropicmode_cons_t[]; + void CV_glanisotropic_OnChange(void); + consvar_t cv_glanisotropicmode = OpenGL("gr_anisotropicmode", "1").values(glanisotropicmode_cons_t).onchange(CV_glanisotropic_OnChange).dont_save(); + + consvar_t cv_glbatching = OpenGL("gr_batching", "On").on_off().dont_save(); + +#ifdef ALAM_LIGHTING + consvar_t cv_glcoronas = OpenGL("gr_coronas", "On").on_off(); + consvar_t cv_glcoronasize = OpenGL("gr_coronasize", "1").floating_point(); + consvar_t cv_gldynamiclighting = OpenGL("gr_dynamiclighting", "On").on_off(); + consvar_t cv_glstaticlighting = OpenGL("gr_staticlighting", "On").on_off(); +#endif + + extern CV_PossibleValue_t glfiltermode_cons_t[]; + void CV_glfiltermode_OnChange(void); + consvar_t cv_glfiltermode = OpenGL("gr_filtermode", "Nearest").values(glfiltermode_cons_t).onchange(CV_glfiltermode_OnChange); + +#ifdef BAD_MODEL_OPTIONS + consvar_t cv_glmodelinterpolation = OpenGL("gr_modelinterpolation", "Sometimes").values({{0, "Off"}, {1, "Sometimes"}, {2, "Always"}}); + consvar_t cv_glmodellighting = OpenGL("gr_modellighting", "Off").on_off(); +#endif + + consvar_t cv_glmodels = OpenGL("gr_models", "Off").on_off(); + consvar_t cv_glshearing = OpenGL("gr_shearing", "Off").values({{0, "Off"}, {1, "On"}, {2, "Third-person"}}); + consvar_t cv_glskydome = OpenGL("gr_skydome", "On").on_off(); + consvar_t cv_glsolvetjoin = OpenGL("gr_solvetjoin", "On").on_off().dont_save(); + consvar_t cv_glspritebillboarding = OpenGL("gr_spritebillboarding", "On").on_off(); +#endif // HWRENDER + + +// +// Objectplace +// + +consvar_t cv_mapthingnum = ObjectPlace("op_mapthingnum", "0").min_max(0, 4095); +consvar_t cv_opflags = ObjectPlace("op_flags", "0").min_max(0, 15); +consvar_t cv_ophoopflags = ObjectPlace("op_hoopflags", "4").min_max(0, 15); +consvar_t cv_speed = ObjectPlace("op_speed", "16").min_max(1, 128); + + +// +// RRID debugging +// + +#ifdef DEVELOP + consvar_t cv_badip = AuthDebug("badip", "0"); + consvar_t cv_badjoin = AuthDebug("badjoin", "0"); + consvar_t cv_badresponse = AuthDebug("badresponse", "0"); + consvar_t cv_badresults = AuthDebug("badresults", "0"); + consvar_t cv_badtime = AuthDebug("badtime", "0"); + consvar_t cv_badtraffic = AuthDebug("badtraffic", "0"); + consvar_t cv_nochallenge = AuthDebug("nochallenge", "0"); + consvar_t cv_noresponse = AuthDebug("noresponse", "0"); + consvar_t cv_noresults = AuthDebug("noresults", "0"); +#endif + + +// +// Special cvars that don't fit with the rest. +// + +void DummyConsvar_OnChange(void); +consvar_t cv_dummyconsvar = Server("dummyconsvar", "Off").flags(CV_NOSHOWHELP).on_off().onchange(DummyConsvar_OnChange).dont_save(); + +void CV_EnforceExecVersion(void); +consvar_t cv_execversion = Server(cvlist_execversion)("execversion", "1").dont_save().values(CV_Unsigned).onchange(CV_EnforceExecVersion); + + +// +// Initialized by CVarList::load... +// + +// color cube +consvar_t cv_globalgamma; +consvar_t cv_globalsaturation; +consvar_t cv_rgamma, cv_ygamma, cv_ggamma, cv_cgamma, cv_bgamma, cv_mgamma; +consvar_t cv_rhue, cv_yhue, cv_ghue, cv_chue, cv_bhue, cv_mhue; +consvar_t cv_rsaturation, cv_ysaturation, cv_gsaturation, cv_csaturation, cv_bsaturation, cv_msaturation; + +// clang-format on + +// This function can be used for more advanced cvar +// initialization. It's only called once, the first time that +// any cvlist is registered. +// +// Use it when you might need to create intermediate objects +// but don't want to pollute this file's namespace, or don't +// want to keep them around for the duration of the program. +int CVarList::load() +{ + // color cube + { + extern CV_PossibleValue_t hue_cons_t[]; + + const auto Color = Player().onchange(CV_palette_OnChange); + const auto Gamma = Color().min_max(-15, 5); + const auto Saturation = Color().min_max(0, 10); + const auto Hue = Color().values(hue_cons_t); + + cv_globalgamma = Gamma("gamma", "0"); + cv_globalsaturation = Saturation("saturation", "10"); + + cv_rhue = Hue("rhue", "0"); + cv_yhue = Hue("yhue", "4"); + cv_ghue = Hue("ghue", "8"); + cv_chue = Hue("chue", "12"); + cv_bhue = Hue("bhue", "16"); + cv_mhue = Hue("mhue", "20"); + + cv_rgamma = Gamma("rgamma", "0"); + cv_ygamma = Gamma("ygamma", "0"); + cv_ggamma = Gamma("ggamma", "0"); + cv_cgamma = Gamma("cgamma", "0"); + cv_bgamma = Gamma("bgamma", "0"); + cv_mgamma = Gamma("mgamma", "0"); + + cv_rsaturation = Saturation("rsaturation", "10"); + cv_ysaturation = Saturation("ysaturation", "10"); + cv_gsaturation = Saturation("gsaturation", "10"); + cv_csaturation = Saturation("csaturation", "10"); + cv_bsaturation = Saturation("bsaturation", "10"); + cv_msaturation = Saturation("msaturation", "10"); + } + + return 0; +} + +} // extern "C" diff --git a/src/d_clisrv.c b/src/d_clisrv.c index 0c8d736de..41279577f 100644 --- a/src/d_clisrv.c +++ b/src/d_clisrv.c @@ -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); diff --git a/src/d_netcmd.c b/src/d_netcmd.c index 6193dca52..e5e3e267f 100644 --- a/src/d_netcmd.c +++ b/src/d_netcmd.c @@ -108,55 +108,6 @@ static void Got_RequestMapQueuecmd(UINT8 **cp, INT32 playernum); static void Got_MapQueuecmd(UINT8 **cp, INT32 playernum); static void Got_Cheat(UINT8 **cp, INT32 playernum); -static void PointLimit_OnChange(void); -static void TimeLimit_OnChange(void); -static void NumLaps_OnChange(void); -static void Mute_OnChange(void); - -static void AutoBalance_OnChange(void); -static void TeamScramble_OnChange(void); - -static void NetTimeout_OnChange(void); -static void JoinTimeout_OnChange(void); - -static void Lagless_OnChange (void); - -static void Gravity_OnChange(void); -static void ForceSkin_OnChange(void); - -static void Name1_OnChange(void); -static void Name2_OnChange(void); -static void Name3_OnChange(void); -static void Name4_OnChange(void); -static void Skin1_OnChange(void); -static void Skin2_OnChange(void); -static void Skin3_OnChange(void); -static void Skin4_OnChange(void); - -static void Follower_OnChange(void); -static void Follower2_OnChange(void); -static void Follower3_OnChange(void); -static void Follower4_OnChange(void); -static void Followercolor_OnChange(void); -static void Followercolor2_OnChange(void); -static void Followercolor3_OnChange(void); -static void Followercolor4_OnChange(void); - -static void Color1_OnChange(void); -static void Color2_OnChange(void); -static void Color3_OnChange(void); -static void Color4_OnChange(void); -static void DummyConsvar_OnChange(void); -static void SoundTest_OnChange(void); - -static void KartFrantic_OnChange(void); -static void KartSpeed_OnChange(void); -static void KartEncore_OnChange(void); -static void KartEliminateLast_OnChange(void); - -static void Schedule_OnChange(void); -static void LiveStudioAudience_OnChange(void); - static void Command_Playdemo_f(void); static void Command_Timedemo_f(void); static void Command_Stopdemo_f(void); @@ -240,180 +191,9 @@ static void Command_Eval(void); // CLIENT VARIABLES // ========================================================================= -static CV_PossibleValue_t usemouse_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Force"}, {0, NULL}}; - -static CV_PossibleValue_t teamscramble_cons_t[] = {{0, "Off"}, {1, "Random"}, {2, "Points"}, {0, NULL}}; - -static CV_PossibleValue_t sleeping_cons_t[] = {{0, "MIN"}, {1000/TICRATE, "MAX"}, {0, NULL}}; - -static CV_PossibleValue_t pause_cons_t[] = {{0, "Server"}, {1, "All"}, {0, NULL}}; - -consvar_t cv_showinputjoy = CVAR_INIT ("showinputjoy", "Off", 0, CV_OnOff, NULL); - -static consvar_t cv_dummyconsvar = CVAR_INIT ("dummyconsvar", "Off", CV_CALL|CV_NOSHOWHELP, CV_OnOff, DummyConsvar_OnChange); - -consvar_t cv_restrictskinchange = CVAR_INIT ("restrictskinchange", "Yes", CV_NETVAR|CV_CHEAT, CV_YesNo, NULL); -consvar_t cv_allowteamchange = CVAR_INIT ("allowteamchange", "Yes", CV_NETVAR, CV_YesNo, NULL); - -static CV_PossibleValue_t maxplayers_cons_t[] = {{1, "MIN"}, {MAXPLAYERS, "MAX"}, {0, NULL}}; -consvar_t cv_maxplayers = CVAR_INIT ("maxplayers", "8", CV_NETVAR, maxplayers_cons_t, NULL); - -static CV_PossibleValue_t spectatorreentry_cons_t[] = {{0, "MIN"}, {10*60, "MAX"}, {0, NULL}}; -consvar_t cv_spectatorreentry = CVAR_INIT ("spectatorreentry", "30", CV_NETVAR, spectatorreentry_cons_t, NULL); -consvar_t cv_duelspectatorreentry = CVAR_INIT ("duelspectatorreentry", "180", CV_NETVAR, spectatorreentry_cons_t, NULL); - -static CV_PossibleValue_t antigrief_cons_t[] = {{10, "MIN"}, {180, "MAX"}, {0, "Off"}, {0, NULL}}; -consvar_t cv_antigrief = CVAR_INIT ("antigrief", "30", CV_NETVAR, antigrief_cons_t, NULL); - -consvar_t cv_seenames = CVAR_INIT ("seenames", "On", CV_SAVE, CV_OnOff, NULL); - -// names -consvar_t cv_playername[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("name", "Dr. Eggman", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Name1_OnChange), - CVAR_INIT ("name2", "Tails", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Name2_OnChange), - CVAR_INIT ("name3", "Sonic", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Name3_OnChange), - CVAR_INIT ("name4", "Knuckles", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Name4_OnChange) -}; -// player colors UINT16 lastgoodcolor[MAXSPLITSCREENPLAYERS] = {SKINCOLOR_NONE, SKINCOLOR_NONE, SKINCOLOR_NONE, SKINCOLOR_NONE}; -consvar_t cv_playercolor[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("color", "Default", CV_SAVE|CV_CALL|CV_NOINIT, Color_cons_t, Color1_OnChange), - CVAR_INIT ("color2", "Default", CV_SAVE|CV_CALL|CV_NOINIT, Color_cons_t, Color2_OnChange), - CVAR_INIT ("color3", "Default", CV_SAVE|CV_CALL|CV_NOINIT, Color_cons_t, Color3_OnChange), - CVAR_INIT ("color4", "Default", CV_SAVE|CV_CALL|CV_NOINIT, Color_cons_t, Color4_OnChange) -}; -// player's skin, saved for commodity, when using a favorite skins wad.. -consvar_t cv_skin[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("skin", DEFAULTSKIN, CV_SAVE|CV_CALL|CV_NOINIT, NULL, Skin1_OnChange), - CVAR_INIT ("skin2", DEFAULTSKIN2, CV_SAVE|CV_CALL|CV_NOINIT, NULL, Skin2_OnChange), - CVAR_INIT ("skin3", DEFAULTSKIN3, CV_SAVE|CV_CALL|CV_NOINIT, NULL, Skin3_OnChange), - CVAR_INIT ("skin4", DEFAULTSKIN4, CV_SAVE|CV_CALL|CV_NOINIT, NULL, Skin4_OnChange) -}; -// player's followers. Also saved. -consvar_t cv_follower[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("follower", "None", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Follower_OnChange), - CVAR_INIT ("follower2", "None", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Follower2_OnChange), - CVAR_INIT ("follower3", "None", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Follower3_OnChange), - CVAR_INIT ("follower4", "None", CV_SAVE|CV_CALL|CV_NOINIT, NULL, Follower4_OnChange) -}; - -// player's follower colors... Also saved... -consvar_t cv_followercolor[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("followercolor", "Match", CV_SAVE|CV_CALL|CV_NOINIT, Followercolor_cons_t, Followercolor_OnChange), - CVAR_INIT ("followercolor2", "Match", CV_SAVE|CV_CALL|CV_NOINIT, Followercolor_cons_t, Followercolor2_OnChange), - CVAR_INIT ("followercolor3", "Match", CV_SAVE|CV_CALL|CV_NOINIT, Followercolor_cons_t, Followercolor3_OnChange), - CVAR_INIT ("followercolor4", "Match", CV_SAVE|CV_CALL|CV_NOINIT, Followercolor_cons_t, Followercolor4_OnChange) -}; - -// last selected profile, unaccessible cvar only set internally but is saved. -// It's used to know what profile to autoload you to when you get into the character setup. - -static CV_PossibleValue_t lastprofile_cons_t[] = {{-1, "MIN"}, {MAXPROFILES, "MAX"}, {0, NULL}}; - -consvar_t cv_lastprofile[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("lastprofile", "0", CV_SAVE|CV_HIDDEN, lastprofile_cons_t, NULL), - CVAR_INIT ("lastprofile2", "0", CV_SAVE|CV_HIDDEN, lastprofile_cons_t, NULL), - CVAR_INIT ("lastprofile3", "0", CV_SAVE|CV_HIDDEN, lastprofile_cons_t, NULL), - CVAR_INIT ("lastprofile4", "0", CV_SAVE|CV_HIDDEN, lastprofile_cons_t, NULL), -}; - -// currently loaded profile for P1 menuing. -// You choose this profile when starting the game, this will also set lastprofile[0] -consvar_t cv_currprofile = CVAR_INIT ("currprofile", "-1", CV_HIDDEN, lastprofile_cons_t, NULL); - -// This one is used exclusively for the titlescreen -consvar_t cv_ttlprofilen = CVAR_INIT ("ttlprofilen", "0", CV_SAVE, lastprofile_cons_t, NULL); - -// Cvar for using splitscreen with 1 device. -consvar_t cv_splitdevice = CVAR_INIT ("splitdevice", "Off", CV_SAVE, CV_OnOff, NULL); - -consvar_t cv_skipmapcheck = CVAR_INIT ("skipmapcheck", "Off", CV_SAVE, CV_OnOff, NULL); - -consvar_t cv_usemouse = CVAR_INIT ("use_mouse", "Off", CV_SAVE|CV_CALL,usemouse_cons_t, I_StartupMouse); - -consvar_t cv_joyscale[MAXSPLITSCREENPLAYERS] = { - CVAR_INIT ("padscale", "1", CV_SAVE|CV_CALL, NULL, I_JoyScale), - CVAR_INIT ("padscale2", "1", CV_SAVE|CV_CALL, NULL, I_JoyScale2), - CVAR_INIT ("padscale3", "1", CV_SAVE|CV_CALL, NULL, I_JoyScale3), - CVAR_INIT ("padscale4", "1", CV_SAVE|CV_CALL, NULL, I_JoyScale4) -}; - -// SRB2kart -consvar_t cv_items[NUMKARTRESULTS-1] = { - CVAR_INIT ("sneaker", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("rocketsneaker", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("invincibility", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("banana", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("eggmark", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("orbinaut", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("jawz", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("mine", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("landmine", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("ballhog", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("selfpropelledbomb", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("grow", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("shrink", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("lightningshield", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("bubbleshield", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("flameshield", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("hyudoro", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("pogospring", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("superring", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("kitchensink", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("droptarget", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("gardentop", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("gachabom", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("dualsneaker", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("triplesneaker", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("triplebanana", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("tripleorbinaut", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("quadorbinaut", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("dualjawz", "On", CV_NETVAR, CV_OnOff, NULL), - CVAR_INIT ("triplegachabom", "On", CV_NETVAR, CV_OnOff, NULL) -}; - -consvar_t cv_kartspeed = CVAR_INIT ("gamespeed", "Auto", CV_NETVAR|CV_CALL|CV_NOINIT, kartspeed_cons_t, KartSpeed_OnChange); -static CV_PossibleValue_t kartbumpers_cons_t[] = {{1, "MIN"}, {12, "MAX"}, {0, NULL}}; -consvar_t cv_kartbumpers = CVAR_INIT ("battlebumpers", "3", CV_NETVAR, kartbumpers_cons_t, NULL); -consvar_t cv_kartfrantic = CVAR_INIT ("franticitems", "Off", CV_NETVAR|CV_CALL|CV_NOINIT, CV_OnOff, KartFrantic_OnChange); -static CV_PossibleValue_t kartencore_cons_t[] = {{-1, "Auto"}, {0, "Off"}, {1, "On"}, {0, NULL}}; -consvar_t cv_kartencore = CVAR_INIT ("encore", "Auto", CV_NETVAR|CV_CALL|CV_NOINIT, kartencore_cons_t, KartEncore_OnChange); -static CV_PossibleValue_t kartspeedometer_cons_t[] = {{0, "Off"}, {1, "Percentage"}, {2, "Kilometers"}, {3, "Miles"}, {4, "Fracunits"}, {0, NULL}}; -consvar_t cv_kartspeedometer = CVAR_INIT ("speedometer", "Percentage", CV_SAVE, kartspeedometer_cons_t, NULL); // use tics in display -consvar_t cv_kartvoices = CVAR_INIT ("tauntvoices", "Tasteful", CV_SAVE, kartvoices_cons_t, NULL); -consvar_t cv_karthorns = CVAR_INIT ("taunthorns", "Tasteful", CV_SAVE, kartvoices_cons_t, NULL); - -#ifdef DEVELOP - consvar_t cv_kartencoremap = CVAR_INIT ("encoremap", "On", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL); -#endif - -static CV_PossibleValue_t kartbot_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_kartbot = CVAR_INIT ("bots", "Off", CV_NETVAR, kartbot_cons_t, NULL); - -consvar_t cv_karteliminatelast = CVAR_INIT ("eliminatelast", "Yes", CV_NETVAR|CV_CALL, CV_YesNo, KartEliminateLast_OnChange); - -consvar_t cv_thunderdome = CVAR_INIT ("thunderdome", "Off", CV_NETVAR, CV_OnOff, NULL); - -consvar_t cv_kartusepwrlv = CVAR_INIT ("usepwrlv", "Yes", CV_NETVAR, CV_YesNo, NULL); - -static CV_PossibleValue_t kartdebugitem_cons_t[] = +CV_PossibleValue_t kartdebugitem_cons_t[] = { #define FOREACH( name, n ) { n, #name } KART_ITEM_ITERATOR, @@ -425,110 +205,24 @@ static CV_PossibleValue_t kartdebugitem_cons_t[] = {POWERUP_SUPERFLICKY, "SuperFlicky"}, {0} }; -consvar_t cv_kartdebugitem = CVAR_INIT ("debugitem", "None", CV_NETVAR|CV_CHEAT, kartdebugitem_cons_t, NULL); -static CV_PossibleValue_t kartdebugamount_cons_t[] = {{1, "MIN"}, {255, "MAX"}, {0, NULL}}; -consvar_t cv_kartdebugamount = CVAR_INIT ("debugitemamount", "1", CV_NETVAR|CV_CHEAT, kartdebugamount_cons_t, NULL); -consvar_t cv_kartdebugdistribution = CVAR_INIT ("debugitemodds", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_kartdebughuddrop = CVAR_INIT ("debugitemdrop", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL); -static CV_PossibleValue_t kartdebugwaypoint_cons_t[] = {{0, "Off"}, {1, "Forwards"}, {2, "Backwards"}, {0, NULL}}; -consvar_t cv_kartdebugwaypoints = CVAR_INIT ("debugwaypoints", "Off", CV_NETVAR|CV_CHEAT, kartdebugwaypoint_cons_t, NULL); -consvar_t cv_kartdebugbots = CVAR_INIT ("debugbots", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_kartdebugnodes = CVAR_INIT ("debugnodes", "Off", CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_kartdebugcolorize = CVAR_INIT ("debugcolorize", "Off", CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_kartdebugdirector = CVAR_INIT ("debugdirector", "Off", CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_kartdebugstart = CVAR_INIT ("debugstart", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_spbtest = CVAR_INIT ("spbtest", "Off", CV_CHEAT|CV_NETVAR, CV_OnOff, NULL); -consvar_t cv_debugrank = CVAR_INIT ("debugrank", "Off", CV_CHEAT, CV_OnOff, NULL); -consvar_t cv_battletest = CVAR_INIT ("battletest", "Off", CV_CHEAT|CV_NETVAR, CV_OnOff, NULL); - -static CV_PossibleValue_t capsuletest_cons_t[] = { +CV_PossibleValue_t capsuletest_cons_t[] = { {CV_CAPSULETEST_OFF, "Off"}, {CV_CAPSULETEST_MULTIPLAYER, "Multiplayer"}, {CV_CAPSULETEST_TIMEATTACK, "TimeAttack"}, {0, NULL}}; -static void CapsuleTest_OnChange(void) +void CapsuleTest_OnChange(void); +void CapsuleTest_OnChange(void) { if (gamestate == GS_LEVEL) CONS_Printf("Level must be restarted for capsuletest to have effect.\n"); } -consvar_t cv_capsuletest = CVAR_INIT ("capsuletest", "Off", CV_CHEAT|CV_NETVAR|CV_CALL, capsuletest_cons_t, CapsuleTest_OnChange); +CV_PossibleValue_t pointlimit_cons_t[] = {{1, "MIN"}, {MAXSCORE, "MAX"}, {0, "None"}, {-1, "Default"}, {0, NULL}}; +CV_PossibleValue_t numlaps_cons_t[] = {{0, "MIN"}, {MAX_LAPS, "MAX"}, {-1, "Map default"}, {0, NULL}}; -consvar_t cv_reducevfx = CVAR_INIT ("reducevfx", "No", CV_SAVE, CV_YesNo, NULL); - -static CV_PossibleValue_t votetime_cons_t[] = {{10, "MIN"}, {3600, "MAX"}, {0, NULL}}; -consvar_t cv_votetime = CVAR_INIT ("votetime", "20", CV_NETVAR, votetime_cons_t, NULL); - -consvar_t cv_botscanvote = CVAR_INIT ("botscanvote", "No", CV_CHEAT, CV_YesNo, NULL); - -consvar_t cv_gravity = CVAR_INIT ("gravity", "0.8", CV_CHEAT|CV_FLOAT|CV_CALL, NULL, Gravity_OnChange); // change DEFAULT_GRAVITY if you change this - -consvar_t cv_soundtest = CVAR_INIT ("soundtest", "0", CV_CALL, NULL, SoundTest_OnChange); - -static CV_PossibleValue_t minitimelimit_cons_t[] = {{15, "MIN"}, {9999, "MAX"}, {0, NULL}}; -consvar_t cv_countdowntime = CVAR_INIT ("countdowntime", "30", CV_NETVAR, minitimelimit_cons_t, NULL); - -consvar_t cv_autobalance = CVAR_INIT ("autobalance", "Off", CV_SAVE|CV_NETVAR|CV_CALL, CV_OnOff, AutoBalance_OnChange); -consvar_t cv_teamscramble = CVAR_INIT ("teamscramble", "Off", CV_SAVE|CV_NETVAR|CV_CALL|CV_NOINIT, teamscramble_cons_t, TeamScramble_OnChange); -consvar_t cv_scrambleonchange = CVAR_INIT ("scrambleonchange", "Off", CV_SAVE|CV_NETVAR, teamscramble_cons_t, NULL); - -consvar_t cv_alttitle = CVAR_INIT ("alttitle", "Off", CV_CALL|CV_NOSHOWHELP|CV_NOINIT|CV_SAVE, CV_OnOff, AltTitle_OnChange); -consvar_t cv_itemfinder = CVAR_INIT ("itemfinder", "Off", CV_CALL|CV_NOSHOWHELP, CV_OnOff, ItemFinder_OnChange); - -// Scoring type options -consvar_t cv_overtime = CVAR_INIT ("overtime", "Yes", CV_NETVAR, CV_YesNo, NULL); - -consvar_t cv_rollingdemos = CVAR_INIT ("rollingdemos", "On", CV_SAVE, CV_OnOff, NULL); - -static CV_PossibleValue_t pointlimit_cons_t[] = {{1, "MIN"}, {MAXSCORE, "MAX"}, {0, "None"}, {-1, "Default"}, {0, NULL}}; -consvar_t cv_pointlimit = CVAR_INIT ("pointlimit", "Default", CV_NETVAR|CV_CALL|CV_NOINIT, pointlimit_cons_t, PointLimit_OnChange); -static CV_PossibleValue_t timelimit_cons_t[] = {{1, "MIN"}, {30*60, "MAX"}, {0, "None"}, {-1, "Default"}, {0, NULL}}; -consvar_t cv_timelimit = CVAR_INIT ("timelimit", "Default", CV_NETVAR|CV_CALL|CV_NOINIT, timelimit_cons_t, TimeLimit_OnChange); - -static CV_PossibleValue_t numlaps_cons_t[] = {{0, "MIN"}, {MAX_LAPS, "MAX"}, {-1, "Map default"}, {0, NULL}}; -consvar_t cv_numlaps = CVAR_INIT ("numlaps", "Map default", CV_SAVE|CV_NETVAR|CV_CALL|CV_CHEAT, numlaps_cons_t, NumLaps_OnChange); - -consvar_t cv_forceskin = CVAR_INIT ("forcecharacter", "None", CV_NETVAR|CV_CALL|CV_CHEAT, NULL, ForceSkin_OnChange); - -consvar_t cv_downloading = CVAR_INIT ("downloading", "On", 0, CV_OnOff, NULL); -consvar_t cv_allowexitlevel = CVAR_INIT ("allowexitlevel", "No", CV_NETVAR, CV_YesNo, NULL); - -consvar_t cv_netstat = CVAR_INIT ("netstat", "Off", 0, CV_OnOff, NULL); // show bandwidth statistics -static CV_PossibleValue_t nettimeout_cons_t[] = {{TICRATE/7, "MIN"}, {60*TICRATE, "MAX"}, {0, NULL}}; -consvar_t cv_nettimeout = CVAR_INIT ("nettimeout", "210", CV_CALL|CV_SAVE, nettimeout_cons_t, NetTimeout_OnChange); -//static CV_PossibleValue_t jointimeout_cons_t[] = {{5*TICRATE, "MIN"}, {60*TICRATE, "MAX"}, {0, NULL}}; -consvar_t cv_jointimeout = CVAR_INIT ("jointimeout", "210", CV_CALL|CV_SAVE, nettimeout_cons_t, JoinTimeout_OnChange); -consvar_t cv_maxping = CVAR_INIT ("maxdelay", "20", CV_SAVE, CV_Unsigned, NULL); - -consvar_t cv_lagless = CVAR_INIT ("lagless", "Off", CV_SAVE|CV_NETVAR|CV_CALL, CV_OnOff, Lagless_OnChange); - -static CV_PossibleValue_t pingtimeout_cons_t[] = {{8, "MIN"}, {120, "MAX"}, {0, NULL}}; -consvar_t cv_pingtimeout = CVAR_INIT ("maxdelaytimeout", "10", CV_SAVE|CV_NETVAR, pingtimeout_cons_t, NULL); - -// show your ping on the HUD next to framerate. Defaults to warning only (shows up if your ping is > maxping) -static CV_PossibleValue_t showping_cons_t[] = {{0, "Off"}, {1, "Always"}, {2, "Warning"}, {0, NULL}}; -consvar_t cv_showping = CVAR_INIT ("showping", "Always", CV_SAVE, showping_cons_t, NULL); - -static CV_PossibleValue_t pingmeasurement_cons_t[] = {{0, "Frames"}, {1, "Milliseconds"}, {0, NULL}}; -consvar_t cv_pingmeasurement = CVAR_INIT ("pingmeasurement", "Frames", CV_SAVE, pingmeasurement_cons_t, NULL); - -consvar_t cv_showviewpointtext = CVAR_INIT ("showviewpointtext", "On", CV_SAVE, CV_OnOff, NULL); - -// Intermission time Tails 04-19-2002 -static CV_PossibleValue_t inttime_cons_t[] = {{0, "MIN"}, {3600, "MAX"}, {0, NULL}}; -consvar_t cv_inttime = CVAR_INIT ("inttime", "10", CV_SAVE|CV_NETVAR, inttime_cons_t, NULL); - -static CV_PossibleValue_t advancemap_cons_t[] = {{0, "Same"}, {1, "Next"}, {2, "Random"}, {3, "Vote"}, {0, NULL}}; -consvar_t cv_advancemap = CVAR_INIT ("advancemap", "Vote", CV_NETVAR, advancemap_cons_t, NULL); - -consvar_t cv_pause = CVAR_INIT ("pausepermission", "Server", CV_SAVE|CV_NETVAR, pause_cons_t, NULL); -consvar_t cv_mute = CVAR_INIT ("mute", "Off", CV_NETVAR|CV_CALL, CV_OnOff, Mute_OnChange); - -consvar_t cv_sleep = CVAR_INIT ("cpusleep", "1", CV_SAVE, sleeping_cons_t, NULL); - -static CV_PossibleValue_t perfstats_cons_t[] = { +CV_PossibleValue_t perfstats_cons_t[] = { {PS_OFF, "Off"}, {PS_RENDER, "Rendering"}, {PS_LOGIC, "Logic"}, @@ -536,17 +230,6 @@ static CV_PossibleValue_t perfstats_cons_t[] = { {PS_THINKFRAME, "ThinkFrame"}, {0, NULL} }; -consvar_t cv_perfstats = CVAR_INIT ("perfstats", "Off", 0, perfstats_cons_t, NULL); - -consvar_t cv_schedule = CVAR_INIT ("schedule", "On", CV_NETVAR|CV_CALL, CV_OnOff, Schedule_OnChange); - -consvar_t cv_automate = CVAR_INIT ("automate", "On", CV_NETVAR, CV_OnOff, NULL); - -#ifdef DEVELOP -consvar_t cv_livestudioaudience = CVAR_INIT ("livestudioaudience", "On", CV_NETVAR|CV_CALL, CV_OnOff, LiveStudioAudience_OnChange); -#else -consvar_t cv_livestudioaudience = CVAR_INIT ("livestudioaudience", "Off", CV_NETVAR|CV_CALL, CV_OnOff, LiveStudioAudience_OnChange); -#endif char timedemo_name[256]; boolean timedemo_csv; @@ -746,93 +429,17 @@ void D_RegisterServerCommands(void) // for master server connection AddMServCommands(); - // misc - CV_RegisterVar(&cv_pointlimit); - CV_RegisterVar(&cv_numlaps); - - CV_RegisterVar(&cv_autobalance); - CV_RegisterVar(&cv_teamscramble); - CV_RegisterVar(&cv_scrambleonchange); - - CV_RegisterVar(&cv_inttime); - CV_RegisterVar(&cv_advancemap); - CV_RegisterVar(&cv_timelimit); - CV_RegisterVar(&cv_playbackspeed); - CV_RegisterVar(&cv_forceskin); - CV_RegisterVar(&cv_downloading); - - K_RegisterKartStuff(); // SRB2kart - - CV_RegisterVar(&cv_countdowntime); - CV_RegisterVar(&cv_overtime); - CV_RegisterVar(&cv_pause); - CV_RegisterVar(&cv_mute); - RegisterNetXCmd(XD_RANDOMSEED, Got_RandomSeed); - CV_RegisterVar(&cv_allowexitlevel); - CV_RegisterVar(&cv_restrictskinchange); - CV_RegisterVar(&cv_allowteamchange); - CV_RegisterVar(&cv_maxplayers); - CV_RegisterVar(&cv_spectatorreentry); - CV_RegisterVar(&cv_duelspectatorreentry); - CV_RegisterVar(&cv_antigrief); - // d_clisrv - CV_RegisterVar(&cv_maxconnections); - CV_RegisterVar(&cv_joindelay); - CV_RegisterVar(&cv_resynchattempts); - CV_RegisterVar(&cv_maxsend); - CV_RegisterVar(&cv_noticedownload); - CV_RegisterVar(&cv_downloadspeed); - CV_RegisterVar(&cv_httpsource); - CV_RegisterVar(&cv_allownewplayer); -#ifdef VANILLAJOINNEXTROUND - CV_RegisterVar(&cv_joinnextround); -#endif - CV_RegisterVar(&cv_showjoinaddress); - CV_RegisterVar(&cv_blamecfail); COM_AddCommand("ping", Command_Ping_f); - CV_RegisterVar(&cv_nettimeout); - CV_RegisterVar(&cv_jointimeout); - CV_RegisterVar(&cv_kicktime); - CV_RegisterVar(&cv_skipmapcheck); - CV_RegisterVar(&cv_sleep); - CV_RegisterVar(&cv_maxping); - CV_RegisterVar(&cv_lagless); - CV_RegisterVar(&cv_pingtimeout); - CV_RegisterVar(&cv_showping); - CV_RegisterVar(&cv_pingmeasurement); - CV_RegisterVar(&cv_showviewpointtext); - CV_RegisterVar(&cv_schedule); - CV_RegisterVar(&cv_automate); - CV_RegisterVar(&cv_livestudioaudience); - - CV_RegisterVar(&cv_dummyconsvar); - -#ifdef USE_STUN - CV_RegisterVar(&cv_stunserver); -#endif - -#ifdef DEVELOP - CV_RegisterVar(&cv_botcontrol); -#endif - - CV_RegisterVar(&cv_discordinvites); RegisterNetXCmd(XD_DISCORD, Got_DiscordInfo); COM_AddCommand("numthinkers", Command_Numthinkers_f); COM_AddCommand("countmobjs", Command_CountMobjs_f); - CV_RegisterVar(&cv_recordmultiplayerdemos); - CV_RegisterVar(&cv_netdemosyncquality); - - CV_RegisterVar(&cv_shoutname); - CV_RegisterVar(&cv_shoutcolor); - CV_RegisterVar(&cv_autoshout); - #ifdef _DEBUG COM_AddCommand("causecfail", Command_CauseCfail_f); #endif @@ -841,6 +448,11 @@ void D_RegisterServerCommands(void) #endif K_RegisterMidVoteCVars(); + + { + extern struct CVarList *cvlist_server; + CV_RegisterList(cvlist_server); + } } // ========================================================================= @@ -900,179 +512,18 @@ void D_RegisterClientCommands(void) COM_AddCommand("stopmovie", Command_StopMovie_f); COM_AddCommand("minigen", M_MinimapGenerate); - CV_RegisterVar(&cv_screenshot_colorprofile); - CV_RegisterVar(&cv_lossless_recorder); - #ifdef SRB2_CONFIG_ENABLE_WEBM_MOVIES M_AVRecorder_AddCommands(); #endif - // PNG variables - CV_RegisterVar(&cv_zlib_level); - CV_RegisterVar(&cv_zlib_memory); - CV_RegisterVar(&cv_zlib_strategy); - CV_RegisterVar(&cv_zlib_window_bits); - // APNG variables - CV_RegisterVar(&cv_zlib_levela); - CV_RegisterVar(&cv_zlib_memorya); - CV_RegisterVar(&cv_zlib_strategya); - CV_RegisterVar(&cv_zlib_window_bitsa); - CV_RegisterVar(&cv_apng_delay); - CV_RegisterVar(&cv_apng_downscale); - // GIF variables - CV_RegisterVar(&cv_gif_optimize); - CV_RegisterVar(&cv_gif_downscale); - CV_RegisterVar(&cv_gif_dynamicdelay); - CV_RegisterVar(&cv_gif_localcolortable); - - // register these so it is saved to config - for (i = 0; i < MAXSPLITSCREENPLAYERS; i++) - { - CV_RegisterVar(&cv_playername[i]); - CV_RegisterVar(&cv_playercolor[i]); - CV_RegisterVar(&cv_skin[i]); - CV_RegisterVar(&cv_follower[i]); - CV_RegisterVar(&cv_followercolor[i]); - CV_RegisterVar(&cv_lastprofile[i]); - } - - CV_RegisterVar(&cv_currprofile); - CV_RegisterVar(&cv_ttlprofilen); - CV_RegisterVar(&cv_splitdevice); - - // preferred number of players - CV_RegisterVar(&cv_splitplayers); - - CV_RegisterVar(&cv_seenames); - CV_RegisterVar(&cv_rollingdemos); - CV_RegisterVar(&cv_netstat); - CV_RegisterVar(&cv_netticbuffer); - CV_RegisterVar(&cv_mindelay); - - CV_RegisterVar(&cv_allowguests); - CV_RegisterVar(&cv_gamestochat); - - #ifdef DEVELOP - CV_RegisterVar(&cv_badjoin); - CV_RegisterVar(&cv_badtraffic); - CV_RegisterVar(&cv_badresponse); - CV_RegisterVar(&cv_noresponse); - CV_RegisterVar(&cv_nochallenge); - CV_RegisterVar(&cv_badresults); - CV_RegisterVar(&cv_noresults); - CV_RegisterVar(&cv_badtime); - CV_RegisterVar(&cv_badip); - #endif - - // HUD - CV_RegisterVar(&cv_alttitle); - CV_RegisterVar(&cv_itemfinder); - CV_RegisterVar(&cv_showinputjoy); - - // time attack ghost options are also saved to config - CV_RegisterVar(&cv_ghost_besttime); - CV_RegisterVar(&cv_ghost_bestlap); - CV_RegisterVar(&cv_ghost_last); - CV_RegisterVar(&cv_ghost_guest); - CV_RegisterVar(&cv_ghost_staff); - COM_AddCommand("displayplayer", Command_Displayplayer_f); - // FIXME: not to be here.. but needs be done for config loading - CV_RegisterVar(&cv_globalgamma); - CV_RegisterVar(&cv_globalsaturation); - - CV_RegisterVar(&cv_rhue); - CV_RegisterVar(&cv_yhue); - CV_RegisterVar(&cv_ghue); - CV_RegisterVar(&cv_chue); - CV_RegisterVar(&cv_bhue); - CV_RegisterVar(&cv_mhue); - - CV_RegisterVar(&cv_rgamma); - CV_RegisterVar(&cv_ygamma); - CV_RegisterVar(&cv_ggamma); - CV_RegisterVar(&cv_cgamma); - CV_RegisterVar(&cv_bgamma); - CV_RegisterVar(&cv_mgamma); - - CV_RegisterVar(&cv_rsaturation); - CV_RegisterVar(&cv_ysaturation); - CV_RegisterVar(&cv_gsaturation); - CV_RegisterVar(&cv_csaturation); - CV_RegisterVar(&cv_bsaturation); - CV_RegisterVar(&cv_msaturation); - - CV_RegisterVar(&cv_palette); - CV_RegisterVar(&cv_palettenum); - // k_menu.c //CV_RegisterVar(&cv_compactscoreboard); - CV_RegisterVar(&cv_chatheight); - CV_RegisterVar(&cv_chatwidth); - CV_RegisterVar(&cv_chattime); - CV_RegisterVar(&cv_chatspamprotection); - CV_RegisterVar(&cv_consolechat); - CV_RegisterVar(&cv_chatnotifications); - CV_RegisterVar(&cv_chatbacktint); - - CV_RegisterVar(&cv_songcredits); - CV_RegisterVar(&cv_tutorialprompt); - CV_RegisterVar(&cv_showfocuslost); - CV_RegisterVar(&cv_pauseifunfocused); - - // g_input.c - for (i = 0; i < MAXSPLITSCREENPLAYERS; i++) - { - CV_RegisterVar(&cv_kickstartaccel[i]); - CV_RegisterVar(&cv_autoroulette[i]); - CV_RegisterVar(&cv_shrinkme[i]); - CV_RegisterVar(&cv_deadzone[i]); - CV_RegisterVar(&cv_rumble[i]); - } - - // filesrch.c - CV_RegisterVar(&cv_addons_md5); - CV_RegisterVar(&cv_addons_showall); - CV_RegisterVar(&cv_addons_search_type); - CV_RegisterVar(&cv_addons_search_case); - - CV_RegisterVar(&cv_controlperkey); - - CV_RegisterVar(&cv_usemouse); - - for (i = 0; i < MAXSPLITSCREENPLAYERS; i++) - { - CV_RegisterVar(&cv_joyscale[i]); - } - - // s_sound.c - CV_RegisterVar(&cv_soundvolume); - CV_RegisterVar(&cv_closedcaptioning); - CV_RegisterVar(&cv_digmusicvolume); - CV_RegisterVar(&cv_numChannels); - - // screen.c - CV_RegisterVar(&cv_fullscreen); - CV_RegisterVar(&cv_renderview); - CV_RegisterVar(&cv_vhseffect); - CV_RegisterVar(&cv_shittyscreen); - CV_RegisterVar(&cv_renderer); - CV_RegisterVar(&cv_scr_depth); - CV_RegisterVar(&cv_scr_width); - CV_RegisterVar(&cv_scr_height); - - CV_RegisterVar(&cv_soundtest); - - CV_RegisterVar(&cv_perfstats); // ingame object placing COM_AddCommand("objectplace", Command_ObjectPlace_f); //COM_AddCommand("writethings", Command_Writethings_f); - CV_RegisterVar(&cv_speed); - CV_RegisterVar(&cv_opflags); - CV_RegisterVar(&cv_ophoopflags); - CV_RegisterVar(&cv_mapthingnum); // CV_RegisterVar(&cv_grid); // CV_RegisterVar(&cv_snapto); @@ -1096,14 +547,11 @@ void D_RegisterClientCommands(void) COM_AddCommand("goto", Command_Goto_f); COM_AddCommand("angle", Command_Angle_f); COM_AddCommand("respawnat", Command_RespawnAt_f); - CV_RegisterVar(&cv_renderhitbox); - CV_RegisterVar(&cv_devmode_screen); -#ifdef HAVE_DISCORDRPC - CV_RegisterVar(&cv_discordrp); - CV_RegisterVar(&cv_discordstreamer); - CV_RegisterVar(&cv_discordasks); -#endif + { + extern struct CVarList *cvlist_player; + CV_RegisterList(cvlist_player); + } } /** Checks if a name (as received from another player) is okay. @@ -4534,6 +3982,8 @@ void Automate_Set(automateEvents_t type, const char *command) void Automate_Run(automateEvents_t type) { + extern consvar_t cv_automate; + if (!server) { // Only the server should be doing this. @@ -5293,7 +4743,8 @@ void ItemFinder_OnChange(void) * \sa cv_pointlimit, TimeLimit_OnChange * \author Graue */ -static void PointLimit_OnChange(void) +void PointLimit_OnChange(void); +void PointLimit_OnChange(void) { if (K_CanChangeRules(false) == false) { @@ -5339,18 +4790,20 @@ static void PointLimit_OnChange(void) } } -static void NetTimeout_OnChange(void) +void NetTimeout_OnChange(void); +void NetTimeout_OnChange(void) { connectiontimeout = (tic_t)cv_nettimeout.value; } -static void JoinTimeout_OnChange(void) +void JoinTimeout_OnChange(void); +void JoinTimeout_OnChange(void) { jointimeout = (tic_t)cv_jointimeout.value; } -static void -Lagless_OnChange (void) +void Lagless_OnChange (void); +void Lagless_OnChange (void) { /* don't back out of dishonesty, or go lagless after playing honestly */ if (cv_lagless.value && gamestate == GS_LEVEL) @@ -5371,7 +4824,8 @@ UINT32 g_pointlimit = 0; * * \sa cv_timelimit, PointLimit_OnChange */ -static void TimeLimit_OnChange(void) +void TimeLimit_OnChange(void); +void TimeLimit_OnChange(void) { if (K_CanChangeRules(false) == false) { @@ -5461,7 +4915,8 @@ void D_GameTypeChanged(INT32 lastgametype) } } -static void Gravity_OnChange(void) +void Gravity_OnChange(void); +void Gravity_OnChange(void) { if (netgame) { @@ -5472,7 +4927,8 @@ static void Gravity_OnChange(void) gravity = cv_gravity.value; } -static void SoundTest_OnChange(void) +void SoundTest_OnChange(void); +void SoundTest_OnChange(void) { INT32 sfxfreeint = (INT32)sfxfree; if (cv_soundtest.value < 0) @@ -5491,12 +4947,14 @@ static void SoundTest_OnChange(void) S_StartSound(NULL, cv_soundtest.value); } -static void AutoBalance_OnChange(void) +void AutoBalance_OnChange(void); +void AutoBalance_OnChange(void) { autobalance = (INT16)cv_autobalance.value; } -static void TeamScramble_OnChange(void) +void TeamScramble_OnChange(void); +void TeamScramble_OnChange(void) { INT16 i = 0, j = 0, playercount = 0; boolean repick = true; @@ -6683,7 +6141,8 @@ static void Command_Eval(void) * \sa Command_SetForcedSkin_f, cv_forceskin, forcedskin * \author Graue */ -static void ForceSkin_OnChange(void) +void ForceSkin_OnChange(void); +void ForceSkin_OnChange(void) { // NOT in SP, silly! if (!Playing() || !K_CanChangeRules(true)) @@ -6711,22 +6170,26 @@ static void Name_OnChange(const UINT8 p) SendNameAndColor(p); } -static void Name1_OnChange(void) +void Name1_OnChange(void); +void Name1_OnChange(void) { Name_OnChange(0); } -static void Name2_OnChange(void) +void Name2_OnChange(void); +void Name2_OnChange(void) { Name_OnChange(1); } -static void Name3_OnChange(void) +void Name3_OnChange(void); +void Name3_OnChange(void) { Name_OnChange(2); } -static void Name4_OnChange(void) +void Name4_OnChange(void); +void Name4_OnChange(void) { Name_OnChange(3); } @@ -6742,45 +6205,53 @@ static void FollowerAny_OnChange(UINT8 pnum) } // sends the follower change for players -static void Follower_OnChange(void) +void Follower_OnChange(void); +void Follower_OnChange(void) { FollowerAny_OnChange(0); } // About the same as Color_OnChange but for followers. -static void Followercolor_OnChange(void) +void Followercolor_OnChange(void); +void Followercolor_OnChange(void) { FollowerAny_OnChange(0); } // repeat for the 3 other players -static void Follower2_OnChange(void) +void Follower2_OnChange(void); +void Follower2_OnChange(void) { FollowerAny_OnChange(1); } -static void Followercolor2_OnChange(void) +void Followercolor2_OnChange(void); +void Followercolor2_OnChange(void) { FollowerAny_OnChange(1); } -static void Follower3_OnChange(void) +void Follower3_OnChange(void); +void Follower3_OnChange(void) { FollowerAny_OnChange(2); } -static void Followercolor3_OnChange(void) +void Followercolor3_OnChange(void); +void Followercolor3_OnChange(void) { FollowerAny_OnChange(2); } -static void Follower4_OnChange(void) +void Follower4_OnChange(void); +void Follower4_OnChange(void) { FollowerAny_OnChange(3); } -static void Followercolor4_OnChange(void) +void Followercolor4_OnChange(void); +void Followercolor4_OnChange(void) { FollowerAny_OnChange(3); } @@ -6815,7 +6286,8 @@ static void Skin_OnChange(const UINT8 p) } } -static void Skin1_OnChange(void) +void Skin1_OnChange(void); +void Skin1_OnChange(void) { Skin_OnChange(0); } @@ -6825,17 +6297,20 @@ static void Skin1_OnChange(void) * \sa cv_skin2, Skin_OnChange, Color2_OnChange * \author Graue */ -static void Skin2_OnChange(void) +void Skin2_OnChange(void); +void Skin2_OnChange(void) { Skin_OnChange(1); } -static void Skin3_OnChange(void) +void Skin3_OnChange(void); +void Skin3_OnChange(void) { Skin_OnChange(2); } -static void Skin4_OnChange(void) +void Skin4_OnChange(void); +void Skin4_OnChange(void) { Skin_OnChange(3); } @@ -6873,8 +6348,9 @@ static void Color_OnChange(const UINT8 p) lastgoodcolor[p] = color; G_SetPlayerGamepadIndicatorToPlayerColor(p); } - -static void Color1_OnChange(void) + +void Color1_OnChange(void); +void Color1_OnChange(void) { Color_OnChange(0); } @@ -6884,17 +6360,20 @@ static void Color1_OnChange(void) * \sa cv_playercolor2, Color_OnChange, Skin2_OnChange * \author Graue */ -static void Color2_OnChange(void) +void Color2_OnChange(void); +void Color2_OnChange(void) { Color_OnChange(1); } -static void Color3_OnChange(void) +void Color3_OnChange(void); +void Color3_OnChange(void) { Color_OnChange(2); } -static void Color4_OnChange(void) +void Color4_OnChange(void); +void Color4_OnChange(void) { Color_OnChange(3); } @@ -6906,7 +6385,8 @@ static void Color4_OnChange(void) * \sa cv_mute * \author Graue */ -static void Mute_OnChange(void) +void Mute_OnChange(void); +void Mute_OnChange(void) { /*if (server || (IsPlayerAdmin(consoleplayer))) return;*/ @@ -6935,8 +6415,11 @@ static void Mute_OnChange(void) * \sa cv_dummyconsvar * \author Graue */ -static void DummyConsvar_OnChange(void) +void DummyConsvar_OnChange(void); +void DummyConsvar_OnChange(void) { + extern consvar_t cv_dummyconsvar; + if (cv_dummyconsvar.value == 1) { CV_SetValue(&cv_dummyconsvar, 0); @@ -6976,7 +6459,8 @@ static void Command_ShowTime_f(void) } // SRB2Kart: On change messages -static void NumLaps_OnChange(void) +void NumLaps_OnChange(void); +void NumLaps_OnChange(void) { if (gamestate == GS_LEVEL) { @@ -6997,7 +6481,8 @@ static void NumLaps_OnChange(void) } } -static void KartFrantic_OnChange(void) +void KartFrantic_OnChange(void); +void KartFrantic_OnChange(void) { if (K_CanChangeRules(false) == false) { @@ -7015,7 +6500,8 @@ static void KartFrantic_OnChange(void) } } -static void KartSpeed_OnChange(void) +void KartSpeed_OnChange(void); +void KartSpeed_OnChange(void) { if (K_CanChangeRules(false) == false) { @@ -7033,7 +6519,8 @@ static void KartSpeed_OnChange(void) } } -static void KartEncore_OnChange(void) +void KartEncore_OnChange(void); +void KartEncore_OnChange(void) { if (K_CanChangeRules(false) == false) { @@ -7043,7 +6530,8 @@ static void KartEncore_OnChange(void) CONS_Printf(M_GetText("Encore Mode will be set to %s next round.\n"), cv_kartencore.string); } -static void KartEliminateLast_OnChange(void) +void KartEliminateLast_OnChange(void); +void KartEliminateLast_OnChange(void) { if (K_CanChangeRules(false) == false) { @@ -7053,7 +6541,8 @@ static void KartEliminateLast_OnChange(void) P_CheckRacers(); } -static void Schedule_OnChange(void) +void Schedule_OnChange(void); +void Schedule_OnChange(void) { size_t i; @@ -7075,7 +6564,8 @@ static void Schedule_OnChange(void) } } -static void LiveStudioAudience_OnChange(void) +void LiveStudioAudience_OnChange(void); +void LiveStudioAudience_OnChange(void) { livestudioaudience_timer = 90; } diff --git a/src/discord.c b/src/discord.c index 4fe49719d..df8f3cd85 100644 --- a/src/discord.c +++ b/src/discord.c @@ -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; diff --git a/src/doomdef.h b/src/doomdef.h index 9fffb78b4..dd5e5d95f 100644 --- a/src/doomdef.h +++ b/src/doomdef.h @@ -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 diff --git a/src/filesrch.c b/src/filesrch.c index 3ac345d5f..78232c26e 100644 --- a/src/filesrch.c +++ b/src/filesrch.c @@ -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; diff --git a/src/g_demo.c b/src/g_demo.c index 5bcee7d48..2a94b8af9 100644 --- a/src/g_demo.c +++ b/src/g_demo.c @@ -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 diff --git a/src/g_game.c b/src/g_game.c index 1ef8faee1..345b65d95 100644 --- a/src/g_game.c +++ b/src/g_game.c @@ -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); diff --git a/src/g_input.c b/src/g_input.c index 0ea851dec..6e1b3f8d9 100644 --- a/src/g_input.c +++ b/src/g_input.c @@ -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]; diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index ba480ea9a..a16c8b447 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -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) diff --git a/src/http-mserv.c b/src/http-mserv.c index d7d65d871..d47122cbf 100644 --- a/src/http-mserv.c +++ b/src/http-mserv.c @@ -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. */ diff --git a/src/i_time.c b/src/i_time.c index c1cc9dfd4..ff6454a8d 100644 --- a/src/i_time.c +++ b/src/i_time.c @@ -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 diff --git a/src/k_bot.c b/src/k_bot.c index 2ce99b6bd..89c7cd244 100644 --- a/src/k_bot.c +++ b/src/k_bot.c @@ -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) diff --git a/src/k_kart.c b/src/k_kart.c index 2a2f4c8f4..529ca6c7f 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -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; diff --git a/src/k_kart.h b/src/k_kart.h index 8982e9d75..e0bcabf06 100644 --- a/src/k_kart.h +++ b/src/k_kart.h @@ -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); diff --git a/src/k_menu.h b/src/k_menu.h index 69ec29542..875da6535 100644 --- a/src/k_menu.h +++ b/src/k_menu.h @@ -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[]; @@ -461,6 +462,7 @@ typedef enum mpause_canceljoin, mpause_spectatemenu, mpause_psetup, + mpause_cheats, mpause_options, mpause_title, @@ -602,7 +604,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); diff --git a/src/k_menufunc.c b/src/k_menufunc.c index 54b0f26b7..b52a500e8 100644 --- a/src/k_menufunc.c +++ b/src/k_menufunc.c @@ -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); } diff --git a/src/k_profiles.c b/src/k_profiles.c index 817392d68..5cd98cf7f 100644 --- a/src/k_profiles.c +++ b/src/k_profiles.c @@ -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. diff --git a/src/k_pwrlv.c b/src/k_pwrlv.c index 3bac55b5c..0a15b6c9b 100644 --- a/src/k_pwrlv.c +++ b/src/k_pwrlv.c @@ -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) diff --git a/src/k_zvote.c b/src/k_zvote.c index dd5cf32b9..cf7757232 100644 --- a/src/k_zvote.c +++ b/src/k_zvote.c @@ -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); diff --git a/src/m_anigif.c b/src/m_anigif.c index 0bd14f422..08cac979d 100644 --- a/src/m_anigif.c +++ b/src/m_anigif.c @@ -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 diff --git a/src/m_avrecorder.cpp b/src/m_avrecorder.cpp index 0ca87f80e..bff239070 100644 --- a/src/m_avrecorder.cpp +++ b/src/m_avrecorder.cpp @@ -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 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(); } diff --git a/src/m_cheat.c b/src/m_cheat.c index 081987198..7c6855e21 100644 --- a/src/m_cheat.c +++ b/src/m_cheat.c @@ -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 diff --git a/src/m_misc.cpp b/src/m_misc.cpp index 226128fc1..f4b3005f9 100644 --- a/src/m_misc.cpp +++ b/src/m_misc.cpp @@ -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... diff --git a/src/menus/extras-1.c b/src/menus/extras-1.c index f623b2d3b..24bf60c0f 100644 --- a/src/menus/extras-1.c +++ b/src/menus/extras-1.c @@ -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 diff --git a/src/menus/extras-addons.c b/src/menus/extras-addons.c index 8610992d3..745fe26b4 100644 --- a/src/menus/extras-addons.c +++ b/src/menus/extras-addons.c @@ -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); diff --git a/src/menus/options-profiles-1.c b/src/menus/options-profiles-1.c index b27578c75..ee9f3a40d 100644 --- a/src/menus/options-profiles-1.c +++ b/src/menus/options-profiles-1.c @@ -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; diff --git a/src/menus/play-char-select.c b/src/menus/play-char-select.c index 257f0ad06..52f7f648d 100644 --- a/src/menus/play-char-select.c +++ b/src/menus/play-char-select.c @@ -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) diff --git a/src/menus/play-local-race-difficulty.c b/src/menus/play-local-race-difficulty.c index 4055cd3b8..3f334e70f 100644 --- a/src/menus/play-local-race-difficulty.c +++ b/src/menus/play-local-race-difficulty.c @@ -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; diff --git a/src/menus/play-local-race-time-attack.c b/src/menus/play-local-race-time-attack.c index 9ae5c5199..dfdc185ac 100644 --- a/src/menus/play-local-race-time-attack.c +++ b/src/menus/play-local-race-time-attack.c @@ -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) { diff --git a/src/menus/play-online-join-ip.c b/src/menus/play-online-join-ip.c index ba67c7039..a176d4e72 100644 --- a/src/menus/play-online-join-ip.c +++ b/src/menus/play-online-join-ip.c @@ -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) { diff --git a/src/menus/play-online-server-browser.c b/src/menus/play-online-server-browser.c index 673af7cc3..730a34956 100644 --- a/src/menus/play-online-server-browser.c +++ b/src/menus/play-online-server-browser.c @@ -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; diff --git a/src/menus/transient/CMakeLists.txt b/src/menus/transient/CMakeLists.txt index aa1397595..ea38b8505 100644 --- a/src/menus/transient/CMakeLists.txt +++ b/src/menus/transient/CMakeLists.txt @@ -11,4 +11,5 @@ target_sources(SRB2SDL2 PRIVATE pause-kick.c pause-replay.c virtual-keyboard.c + pause-cheats.cpp ) diff --git a/src/menus/transient/pause-cheats.cpp b/src/menus/transient/pause-cheats.cpp new file mode 100644 index 000000000..92d9a1a1b --- /dev/null +++ b/src/menus/transient/pause-cheats.cpp @@ -0,0 +1,161 @@ +// DR. ROBOTNIK'S RING RACERS +//----------------------------------------------------------------------------- +// Copyright (C) 2023 by James Robert Roman +// +// This program is free software distributed under the +// terms of the GNU General Public License, version 2. +// See the 'LICENSE' file for more details. +//----------------------------------------------------------------------------- +/// \file menus/transient/pause-cheats.c +/// \brief Cheats directory, for developers + +#include +#include +#include +#include + +#include "../../v_draw.hpp" +#include "../../v_video.h" + +#include "../../command.h" +#include "../../doomtype.h" +#include "../../k_menu.h" +#include "../../screen.h" + +using srb2::Draw; + +namespace +{ + +std::vector g_menu; +std::vector g_menu_offsets; + +void sort_menu() +{ + std::sort(g_menu.begin(), g_menu.end(), + [](menuitem_t& a, menuitem_t& b) { return std::strcmp(a.text, b.text) < 0; }); + + int old_key = '\0'; + + // Can't use range-for because iterators are invalidated + // by std::vector::insert. + for (std::size_t i = 0; i < g_menu.size(); ++i) + { + int new_key = g_menu[i].text[0]; + + if (new_key == old_key) + { + // Group cvars starting with the same letter + // together. + continue; + } + + old_key = new_key; + + if (i == 0) + { + continue; + } + + constexpr int spacer = 8; + + g_menu.insert( + g_menu.begin() + i, + menuitem_t {IT_SPACE | IT_DYLITLSPACE, nullptr, nullptr, nullptr, {}, spacer, spacer} + ); + + i++; // skip the inserted element + } +} + +void menu_open() +{ + g_menu = {}; + g_menu_offsets = {}; + + for (consvar_t* var = consvar_vars; var; var = var->next) + { + if (!(var->flags & CV_CHEAT)) + { + continue; + } + + UINT16 status = IT_STRING | IT_CVAR; + INT32 height = 8; + + if (!var->PossibleValue && !(var->flags & CV_FLOAT)) + { + status |= IT_CV_STRING; + height += 16; + } + + g_menu.push_back(menuitem_t {status, var->name, nullptr, nullptr, {.cvar = var}, 0, height}); + } + + sort_menu(); + + INT32 y = 0; + + for (menuitem_t& item : g_menu) + { + g_menu_offsets.push_back(y); + y += item.mvar2; + } + + PAUSE_CheatsDef.menuitems = g_menu.data(); + PAUSE_CheatsDef.numitems = g_menu.size(); +} + +boolean menu_close() +{ + PAUSE_CheatsDef.menuitems = nullptr; + PAUSE_CheatsDef.numitems = 0; + + g_menu = {}; + g_menu_offsets = {}; + + return true; +} + +void draw_menu() +{ + auto tooltip = Draw(0, 0); + + tooltip.patch("MENUHINT"); + + const menuitem_t& item = currentMenu->menuitems[itemOn]; + + if (const consvar_t* cvar = item.itemaction.cvar; cvar && cvar->description) + { + tooltip.xy(BASEVIDWIDTH/2, 12).font(Draw::Font::kThin).align(Draw::Align::kCenter).text(cvar->description); + } + + constexpr int kTooltipHeight = 27; + constexpr int kPad = 4; + int y = tooltip.y() + kTooltipHeight + kPad; + + currentMenu->y = std::min(y, (BASEVIDHEIGHT/2) - g_menu_offsets[itemOn]); + + V_SetClipRect(0, y * FRACUNIT, BASEVIDWIDTH * FRACUNIT, (BASEVIDHEIGHT - y - kPad) * FRACUNIT, 0); + M_DrawGenericMenu(); + V_ClearClipRect(); +} + +}; // namespace + +menu_t PAUSE_CheatsDef = { + 0, + &PAUSE_MainDef, + 0, + nullptr, + 48, 0, + 0, 0, + MBF_SOUNDLESS, + nullptr, + 0, 0, + draw_menu, + nullptr, + menu_open, + menu_close, + nullptr, +}; diff --git a/src/menus/transient/pause-game.c b/src/menus/transient/pause-game.c index 06cb7e0a6..3f69e4655 100644 --- a/src/menus/transient/pause-game.c +++ b/src/menus/transient/pause-game.c @@ -64,6 +64,9 @@ menuitem_t PAUSE_Main[] = {IT_STRING | IT_CALL, "PLAYER SETUP", "M_ICOCHR", NULL, {.routine = M_CharacterSelect}, 0, 0}, + {IT_STRING | IT_SUBMENU, "CHEATS", "M_ICOCHT", + NULL, {.submenu = &PAUSE_CheatsDef}, 0, 0}, + {IT_STRING | IT_CALL, "OPTIONS", "M_ICOOPT", NULL, {.routine = M_InitOptions}, 0, 0}, @@ -88,16 +91,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); @@ -141,6 +138,7 @@ void M_OpenPauseMenu(void) PAUSE_Main[mpause_canceljoin].status = IT_DISABLED; PAUSE_Main[mpause_spectatemenu].status = IT_DISABLED; PAUSE_Main[mpause_psetup].status = IT_DISABLED; + PAUSE_Main[mpause_cheats].status = IT_DISABLED; Dummymenuplayer_OnChange(); // Make sure the consvar is within bounds of the amount of splitscreen players we have. @@ -223,6 +221,11 @@ void M_OpenPauseMenu(void) } } + if (CV_CheatsEnabled()) + { + PAUSE_Main[mpause_cheats].status = IT_STRING | IT_SUBMENU; + } + G_ResetAllDeviceRumbles(); } diff --git a/src/mserv.c b/src/mserv.c index dd02d6c48..e1f2b9820 100644 --- a/src/mserv.c +++ b/src/mserv.c @@ -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; diff --git a/src/p_mobj.c b/src/p_mobj.c index 481849eb2..1e6a797d1 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -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; diff --git a/src/p_user.c b/src/p_user.c index b3f88115f..a5176e580 100644 --- a/src/p_user.c +++ b/src/p_user.c @@ -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}; diff --git a/src/r_bbox.c b/src/r_bbox.c index 66732d08a..af444e148 100644 --- a/src/r_bbox.c +++ b/src/r_bbox.c @@ -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; diff --git a/src/r_debug.cpp b/src/r_debug.cpp index 2c77d162b..b7f88a561 100644 --- a/src/r_debug.cpp +++ b/src/r_debug.cpp @@ -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) diff --git a/src/r_fps.c b/src/r_fps.c index f21d38943..2e9b8a7ce 100644 --- a/src/r_fps.c +++ b/src/r_fps.c @@ -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) diff --git a/src/r_main.c b/src/r_main.c index 50fee5b58..2ff520ab1 100644 --- a/src/r_main.c +++ b/src/r_main.c @@ -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); } diff --git a/src/s_sound.c b/src/s_sound.c index e6abc1791..a6a0925a1 100644 --- a/src/s_sound.c +++ b/src/s_sound.c @@ -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; diff --git a/src/s_sound.h b/src/s_sound.h index d101f307c..bd1955187 100644 --- a/src/s_sound.h +++ b/src/s_sound.h @@ -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 diff --git a/src/screen.c b/src/screen.c index 8f2113265..92f087c4c 100644 --- a/src/screen.c +++ b/src/screen.c @@ -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 diff --git a/src/sdl/i_video.cpp b/src/sdl/i_video.cpp index 7a2a09d23..cd5ba1848 100644 --- a/src/sdl/i_video.cpp +++ b/src/sdl/i_video.cpp @@ -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(M_CheckParm("-nomouse")); disable_fullscreen = M_CheckParm("-win") ? SDL_TRUE : SDL_FALSE; diff --git a/src/stun.cpp b/src/stun.cpp index 97b418c24..68e705d4e 100644 --- a/src/stun.cpp +++ b/src/stun.cpp @@ -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_callbacks; /* 18.4 STUN UDP and TCP Port Numbers */ diff --git a/src/v_video.cpp b/src/v_video.cpp index 351ff4d46..9c6583916 100644 --- a/src/v_video.cpp +++ b/src/v_video.cpp @@ -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) @@ -1015,6 +990,8 @@ void V_DrawBlock(INT32 x, INT32 y, INT32 scrn, INT32 width, INT32 height, const // void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c) { + const cliprect_t *clip = V_GetClipRect(); + if (rendermode == render_none) return; @@ -1076,6 +1053,21 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c) UINT8 g = (color.rgba & 0xFF00) >> 8; UINT8 b = (color.rgba & 0xFF0000) >> 16; + if (clip && clip->enabled) + { + int x2 = std::min(x + w, clip->right); + int y2 = std::min(y + h, clip->bottom); + + if (x < clip->left) + x = clip->left; + + if (y < clip->top) + y = clip->top; + + w = std::max(0, x2 - x); + h = std::max(0, y2 - y); + } + g_2d.begin_quad() .patch(nullptr) .color(r / 255.f, g / 255.f, b / 255.f, 1.f)