tbd-station-14/Content.Shared/CCVar/CCVars.cs

using Robust.Shared;
using Robust.Shared.Configuration;
using Robust.Shared.Utility;

namespace Content.Shared.CCVar
{
    // ReSharper disable once InconsistentNaming
    [CVarDefs]
    public sealed class CCVars : CVars
    {
        /*
         * Server
         */

        /// <summary>
        ///     Change this to have the changelog and rules "last seen" date stored separately.
        /// </summary>
        public static readonly CVarDef<string> ServerId =
            CVarDef.Create("server.id", "unknown_server_id", CVar.REPLICATED | CVar.SERVER);

        /// <summary>
        ///     Name of the rules txt file in the "Resources/Server Info" dir. Include the extension.
        /// </summary>
        public static readonly CVarDef<string> RulesFile =
            CVarDef.Create("server.rules_file", "Rules.txt", CVar.REPLICATED | CVar.SERVER);

        /// <summary>
        ///     A loc string for what should be displayed as the title on the Rules window.
        /// </summary>
        public static readonly CVarDef<string> RulesHeader =
            CVarDef.Create("server.rules_header", "ui-rules-header", CVar.REPLICATED | CVar.SERVER);

        /*
         * Ambience
         */
        //TODO: This is so that this compiles, yell at me if this is still in
        public static readonly CVarDef<bool> AmbienceBasicEnabled =
            CVarDef.Create("ambiance.basic_enabled", true, CVar.CLIENTONLY | CVar.ARCHIVE);


        /// <summary>
        /// How long we'll wait until re-sampling nearby objects for ambience. Should be pretty fast, but doesn't have to match the tick rate.
        /// </summary>
        public static readonly CVarDef<float> AmbientCooldown =
            CVarDef.Create("ambience.cooldown", 0.1f, CVar.ARCHIVE | CVar.CLIENTONLY);

        /// <summary>
        /// How large of a range to sample for ambience.
        /// </summary>
        public static readonly CVarDef<float> AmbientRange =
            CVarDef.Create("ambience.range", 8f, CVar.REPLICATED | CVar.SERVER);

        /// <summary>
        /// Maximum simultaneous ambient sounds.
        /// </summary>
        public static readonly CVarDef<int> MaxAmbientSources =
            CVarDef.Create("ambience.max_sounds", 16, CVar.ARCHIVE | CVar.CLIENTONLY);

        /// <summary>
        /// The minimum value the user can set for ambience.max_sounds
        /// </summary>
        public static readonly CVarDef<int> MinMaxAmbientSourcesConfigured =
            CVarDef.Create("ambience.min_max_sounds_configured", 16, CVar.REPLICATED | CVar.SERVER | CVar.CHEAT);

        /// <summary>
        /// The maximum value the user can set for ambience.max_sounds
        /// </summary>
        public static readonly CVarDef<int> MaxMaxAmbientSourcesConfigured =
            CVarDef.Create("ambience.max_max_sounds_configured", 64, CVar.REPLICATED | CVar.SERVER | CVar.CHEAT);

        /// <summary>
        /// Ambience volume.
        /// </summary>
        public static readonly CVarDef<float> AmbienceVolume =
            CVarDef.Create("ambience.volume", 0.0f, CVar.ARCHIVE | CVar.CLIENTONLY);

        /// <summary>
        /// Lobby / round end music volume.
        /// </summary>
        public static readonly CVarDef<float> LobbyMusicVolume =
            CVarDef.Create("ambience.lobby_music_volume", 0.0f, CVar.ARCHIVE | CVar.CLIENTONLY);

        /// <summary>
        /// Whether to play the station ambience (humming) sound
        /// </summary>
        public static readonly CVarDef<bool> StationAmbienceEnabled =
            CVarDef.Create("ambience.station_ambience", true, CVar.ARCHIVE | CVar.CLIENTONLY);

        /// <summary>
        /// Whether to play the space ambience
        /// </summary>
        public static readonly CVarDef<bool> SpaceAmbienceEnabled =
            CVarDef.Create("ambience.space_ambience", true, CVar.ARCHIVE | CVar.CLIENTONLY);

        /*
         * Status
         */

        public static readonly CVarDef<string> StatusMoMMIUrl =
            CVarDef.Create("status.mommiurl", "", CVar.SERVERONLY);

        public static readonly CVarDef<string> StatusMoMMIPassword =
            CVarDef.Create("status.mommipassword", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);

        /*
         * Events
         */

        /// <summary>
        ///     Controls if the game should run station events
        /// </summary>
        public static readonly CVarDef<bool>
            EventsEnabled = CVarDef.Create("events.enabled", true, CVar.ARCHIVE | CVar.SERVERONLY);

        /// <summary>
        ///     Average time (in minutes) for when the ramping event scheduler should stop increasing the chaos modifier.
        ///     Close to how long you expect a round to last, so you'll probably have to tweak this on downstreams.
        /// </summary>
        public static readonly CVarDef<float>
            EventsRampingAverageEndTime = CVarDef.Create("events.ramping_average_end_time", 40f, CVar.ARCHIVE | CVar.SERVERONLY);

        /// <summary>
        ///     Average ending chaos modifier for the ramping event scheduler.
        ///     Max chaos chosen for a round will deviate from this
        /// </summary>
        public static readonly CVarDef<float>
            EventsRampingAverageChaos = CVarDef.Create("events.ramping_average_chaos", 6f, CVar.ARCHIVE | CVar.SERVERONLY);

        /*
         * Game
         */

        /// <summary>
        ///     Disables most functionality in the GameTicker.
        /// </summary>
        public static readonly CVarDef<bool>
            GameDummyTicker = CVarDef.Create("game.dummyticker", false, CVar.ARCHIVE | CVar.SERVERONLY);

        /// <summary>
        ///     Controls if the lobby is enabled. If it is not, and there are no available jobs, you may get stuck on a black screen.
        /// </summary>
        public static readonly CVarDef<bool>
            GameLobbyEnabled = CVarDef.Create("game.lobbyenabled", true, CVar.ARCHIVE);

        /// <summary>
        ///     Controls the duration of the lobby timer in seconds. Defaults to 2 minutes and 30 seconds.
        /// </summary>
        public static readonly CVarDef<int>
            GameLobbyDuration = CVarDef.Create("game.lobbyduration", 150, CVar.ARCHIVE);

        /// <summary>
        ///     Controls if players can latejoin at all.
        /// </summary>
        public static readonly CVarDef<bool>
            GameDisallowLateJoins = CVarDef.Create("game.disallowlatejoins", false, CVar.ARCHIVE | CVar.SERVERONLY);

        /// <summary>
        ///     Controls the default game preset.
        /// </summary>
        public static readonly CVarDef<string>
            GameLobbyDefaultPreset = CVarDef.Create("game.defaultpreset", "secret", CVar.ARCHIVE);

        /// <summary>
        ///     Controls if the game can force a different preset if the current preset's criteria are not met.
        /// </summary>
        public static readonly CVarDef<bool>
            GameLobbyFallbackEnabled = CVarDef.Create("game.fallbackenabled", true, CVar.ARCHIVE);

        /// <summary>
        ///     The preset for the game to fall back to if the selected preset could not be used, and fallback is enabled.
        /// </summary>
        public static readonly CVarDef<string>
            GameLobbyFallbackPreset = CVarDef.Create("game.fallbackpreset", "extended", CVar.ARCHIVE);

        /// <summary>
        ///     Controls if people can win the game in Suspicion or Deathmatch.
        /// </summary>
        public static readonly CVarDef<bool>
            GameLobbyEnableWin = CVarDef.Create("game.enablewin", true, CVar.ARCHIVE);

        /// <summary>
        ///     Controls the maximum number of character slots a player is allowed to have.
        /// </summary>
        public static readonly CVarDef<int>
            GameMaxCharacterSlots = CVarDef.Create("game.maxcharacterslots", 10, CVar.ARCHIVE | CVar.SERVERONLY);

        /// <summary>
        ///     Controls the game map prototype to load. SS14 stores these prototypes in Prototypes/Maps.
        /// </summary>
        public static readonly CVarDef<string>
            GameMap = CVarDef.Create("game.map", string.Empty, CVar.SERVERONLY);

        /// <summary>
        ///     Prototype to use for map pool.
        /// </summary>
        public static readonly CVarDef<string>
            GameMapPool = CVarDef.Create("game.map_pool", "DefaultMapPool", CVar.SERVERONLY);

        /// <summary>
        /// The depth of the queue used to calculate which map is next in rotation.
        /// This is how long the game "remembers" that some map was put in play. Default is 16 rounds.
        /// </summary>
        public static readonly CVarDef<int>
            GameMapMemoryDepth = CVarDef.Create("game.map_memory_depth", 16, CVar.SERVERONLY);

        /// <summary>
        /// Is map rotation enabled?
        /// </summary>
        public static readonly CVarDef<bool>
            GameMapRotation = CVarDef.Create("game.map_rotation", true, CVar.SERVERONLY);

        /// <summary>
        /// If roles should be restricted based on time.
        /// </summary>
        public static readonly CVarDef<bool>
            GameRoleTimers = CVarDef.Create("game.role_timers", true, CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        ///     Whether a random position offset will be applied to the station on roundstart.
        /// </summary>
        public static readonly CVarDef<bool> StationOffset =
            CVarDef.Create("game.station_offset", true);

        /// <summary>
        /// When the default blueprint is loaded what is the maximum amount it can be offset from 0,0.
        /// Does nothing without <see cref="StationOffset"/> as true.
        /// </summary>
        public static readonly CVarDef<float> MaxStationOffset =
            CVarDef.Create("game.maxstationoffset", 1000.0f);

        /// <summary>
        ///     Whether a random rotation will be applied to the station on roundstart.
        /// </summary>
        public static readonly CVarDef<bool> StationRotation =
            CVarDef.Create("game.station_rotation", true);

        /// <summary>
        ///     When enabled, guests will be assigned permanent UIDs and will have their preferences stored.
        /// </summary>
        public static readonly CVarDef<bool> GamePersistGuests =
            CVarDef.Create("game.persistguests", true, CVar.ARCHIVE | CVar.SERVERONLY);

        public static readonly CVarDef<bool> GameDiagonalMovement =
            CVarDef.Create("game.diagonalmovement", true, CVar.ARCHIVE);

        public static readonly CVarDef<int> SoftMaxPlayers =
            CVarDef.Create("game.soft_max_players", 30, CVar.SERVERONLY | CVar.ARCHIVE);

        /// <summary>
        /// Whether or not panic bunker is currently enabled.
        /// </summary>
        public static readonly CVarDef<bool> PanicBunkerEnabled =
            CVarDef.Create("game.panic_bunker.enabled", false, CVar.NOTIFY | CVar.REPLICATED);

        /// <summary>
        /// Show reason of disconnect for user or not.
        /// </summary>
        public static readonly CVarDef<bool> PanicBunkerShowReason =
            CVarDef.Create("game.panic_bunker.show_reason", false, CVar.SERVERONLY);

        /// <summary>
        /// Minimum age of the account (from server's PoV, so from first-seen date) in minutes.
        /// </summary>
        public static readonly CVarDef<int> PanicBunkerMinAccountAge =
            CVarDef.Create("game.panic_bunker.min_account_age", 1440, CVar.SERVERONLY);

        /// <summary>
        /// Minimal overall played time.
        /// </summary>
        public static readonly CVarDef<int> PanicBunkerMinOverallHours =
            CVarDef.Create("game.panic_bunker.min_overall_hours", 10, CVar.SERVERONLY);

        /// <summary>
        /// Make people bonk when trying to climb certain objects like tables.
        /// </summary>
        public static readonly CVarDef<bool> GameTableBonk =
            CVarDef.Create("game.table_bonk", false, CVar.SERVERONLY);

#if EXCEPTION_TOLERANCE
        /// <summary>
        ///     Amount of times round start must fail before the server is shut down.
        ///     Set to 0 or a negative number to disable.
        /// </summary>
        public static readonly CVarDef<int> RoundStartFailShutdownCount =
            CVarDef.Create("game.round_start_fail_shutdown_count", 5, CVar.SERVERONLY | CVar.SERVER);
#endif

        /*
         * Discord
         */

        /// <summary>
        /// URL of the Discord webhook which will relay all ahelp messages.
        /// </summary>
        public static readonly CVarDef<string> DiscordAHelpWebhook =
            CVarDef.Create("discord.ahelp_webhook", string.Empty, CVar.SERVERONLY);

        /// <summary>
        /// The server icon to use in the Discord ahelp embed footer.
        /// Valid values are specified at https://discord.com/developers/docs/resources/channel#embed-object-embed-footer-structure.
        /// </summary>
        public static readonly CVarDef<string> DiscordAHelpFooterIcon =
            CVarDef.Create("discord.ahelp_footer_icon", string.Empty, CVar.SERVERONLY);

        /// <summary>
        /// The avatar to use for the webhook. Should be an URL.
        /// </summary>
        public static readonly CVarDef<string> DiscordAHelpAvatar =
            CVarDef.Create("discord.ahelp_avatar", string.Empty, CVar.SERVERONLY);

        /*
         * Suspicion
         */

        public static readonly CVarDef<int> SuspicionMinPlayers =
            CVarDef.Create("suspicion.min_players", 5);

        public static readonly CVarDef<int> SuspicionMinTraitors =
            CVarDef.Create("suspicion.min_traitors", 2);

        public static readonly CVarDef<int> SuspicionPlayersPerTraitor =
            CVarDef.Create("suspicion.players_per_traitor", 6);

        public static readonly CVarDef<int> SuspicionStartingBalance =
            CVarDef.Create("suspicion.starting_balance", 20);

        public static readonly CVarDef<int> SuspicionMaxTimeSeconds =
            CVarDef.Create("suspicion.max_time_seconds", 300);

        /*
         * Traitor
         */

        public static readonly CVarDef<int> TraitorMinPlayers =
            CVarDef.Create("traitor.min_players", 5);

        public static readonly CVarDef<int> TraitorMaxTraitors =
            CVarDef.Create("traitor.max_traitors", 12); // Assuming average server maxes somewhere from like 50-80 people

        public static readonly CVarDef<int> TraitorPlayersPerTraitor =
            CVarDef.Create("traitor.players_per_traitor", 10);

        public static readonly CVarDef<int> TraitorCodewordCount =
            CVarDef.Create("traitor.codeword_count", 4);

        public static readonly CVarDef<int> TraitorStartingBalance =
            CVarDef.Create("traitor.starting_balance", 20);

        public static readonly CVarDef<int> TraitorMaxDifficulty =
            CVarDef.Create("traitor.max_difficulty", 5);

        public static readonly CVarDef<int> TraitorMaxPicks =
            CVarDef.Create("traitor.max_picks", 20);

        public static readonly CVarDef<float> TraitorStartDelay =
            CVarDef.Create("traitor.start_delay", 4f * 60f);

        public static readonly CVarDef<float> TraitorStartDelayVariance =
            CVarDef.Create("traitor.start_delay_variance", 3f * 60f);

        /*
         * TraitorDeathMatch
         */

        public static readonly CVarDef<int> TraitorDeathMatchStartingBalance =
            CVarDef.Create("traitordm.starting_balance", 20);

        /*
         * Zombie
         */

        public static readonly CVarDef<int> ZombieMinPlayers =
            CVarDef.Create("zombie.min_players", 20);

        public static readonly CVarDef<int> ZombieMaxInitialInfected =
            CVarDef.Create("zombie.max_initial_infected", 6);

        public static readonly CVarDef<int> ZombiePlayersPerInfected =
            CVarDef.Create("zombie.players_per_infected", 10);

        /*
         * Pirates
         */

        public static readonly CVarDef<int> PiratesMinPlayers =
            CVarDef.Create("pirates.min_players", 25);

        public static readonly CVarDef<int> PiratesMaxOps =
            CVarDef.Create("pirates.max_pirates", 6);

        public static readonly CVarDef<int> PiratesPlayersPerOp =
            CVarDef.Create("pirates.players_per_pirate", 5);

        /*
         * Tips
         */

        /// <summary>
        ///     Whether tips being shown is enabled at all.
        /// </summary>
        public static readonly CVarDef<bool> TipsEnabled =
            CVarDef.Create("tips.enabled", true);

        /// <summary>
        ///     The dataset prototype to use when selecting a random tip.
        /// </summary>
        public static readonly CVarDef<string> TipsDataset =
            CVarDef.Create("tips.dataset", "Tips");

        /// <summary>
        ///     The number of seconds between each tip being displayed when the round is not actively going
        ///     (i.e. postround or lobby)
        /// </summary>
        public static readonly CVarDef<float> TipFrequencyOutOfRound =
            CVarDef.Create("tips.out_of_game_frequency", 60f * 1.5f);

        /// <summary>
        ///     The number of seconds between each tip being displayed when the round is actively going
        /// </summary>
        public static readonly CVarDef<float> TipFrequencyInRound =
            CVarDef.Create("tips.in_game_frequency", 60f * 60);

        /*
         * Console
         */

        public static readonly CVarDef<bool>
            ConsoleLoginLocal = CVarDef.Create("console.loginlocal", true, CVar.ARCHIVE | CVar.SERVERONLY);


        /*
         * Database stuff
         */

        public static readonly CVarDef<string> DatabaseEngine =
            CVarDef.Create("database.engine", "sqlite", CVar.SERVERONLY);

        public static readonly CVarDef<string> DatabaseSqliteDbPath =
            CVarDef.Create("database.sqlite_dbpath", "preferences.db", CVar.SERVERONLY);

        /// <summary>
        /// Milliseconds to asynchronously delay all SQLite database acquisitions with.
        /// </summary>
        /// <remarks>
        /// Defaults to 1 on DEBUG, 0 on RELEASE.
        /// This is intended to help catch .Result deadlock bugs that only happen on postgres
        /// (because SQLite is not actually asynchronous normally)
        /// </remarks>
        public static readonly CVarDef<int> DatabaseSqliteDelay =
            CVarDef.Create("database.sqlite_delay", DefaultSqliteDelay, CVar.SERVERONLY);

#if DEBUG
        private const int DefaultSqliteDelay = 1;
#else
        private const int DefaultSqliteDelay = 0;
#endif


        public static readonly CVarDef<string> DatabasePgHost =
            CVarDef.Create("database.pg_host", "localhost", CVar.SERVERONLY);

        public static readonly CVarDef<int> DatabasePgPort =
            CVarDef.Create("database.pg_port", 5432, CVar.SERVERONLY);

        public static readonly CVarDef<string> DatabasePgDatabase =
            CVarDef.Create("database.pg_database", "ss14", CVar.SERVERONLY);

        public static readonly CVarDef<string> DatabasePgUsername =
            CVarDef.Create("database.pg_username", "postgres", CVar.SERVERONLY);

        public static readonly CVarDef<string> DatabasePgPassword =
            CVarDef.Create("database.pg_password", "", CVar.SERVERONLY | CVar.CONFIDENTIAL);

        // Basically only exists for integration tests to avoid race conditions.
        public static readonly CVarDef<bool> DatabaseSynchronous =
            CVarDef.Create("database.sync", false, CVar.SERVERONLY);


        /*
         * Outline
         */

        public static readonly CVarDef<bool> OutlineEnabled =
            CVarDef.Create("outline.enabled", true, CVar.CLIENTONLY);


        /*
         * Parallax
         */

        public static readonly CVarDef<bool> ParallaxEnabled =
            CVarDef.Create("parallax.enabled", true, CVar.CLIENTONLY);

        public static readonly CVarDef<bool> ParallaxDebug =
            CVarDef.Create("parallax.debug", false, CVar.CLIENTONLY);

        public static readonly CVarDef<bool> ParallaxLowQuality =
            CVarDef.Create("parallax.low_quality", false, CVar.ARCHIVE | CVar.CLIENTONLY);

        /*
         * Physics
         */

        /// <summary>
        /// When a mob is walking should its X / Y movement be relative to its parent (true) or the map (false).
        /// </summary>
        public static readonly CVarDef<bool> RelativeMovement =
            CVarDef.Create("physics.relative_movement", true, CVar.ARCHIVE | CVar.REPLICATED);

        public static readonly CVarDef<float> TileFrictionModifier =
            CVarDef.Create("physics.tile_friction", 40.0f, CVar.ARCHIVE | CVar.REPLICATED);

        public static readonly CVarDef<float> StopSpeed =
            CVarDef.Create("physics.stop_speed", 0.1f, CVar.ARCHIVE | CVar.REPLICATED);

        /// <summary>
        /// Whether mobs can push objects like lockers.
        /// </summary>
        /// <remarks>
        /// Technically client doesn't need to know about it but this may prevent a bug in the distant future so it stays.
        /// </remarks>
        public static readonly CVarDef<bool> MobPushing =
            CVarDef.Create("physics.mob_pushing", false, CVar.REPLICATED);

        /*
         * Music
         */

        public static readonly CVarDef<bool> LobbyMusicEnabled =
            CVarDef.Create("ambience.lobby_music_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);

        public static readonly CVarDef<bool> EventMusicEnabled =
            CVarDef.Create("ambience.event_music_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);

        /*
         * Specific Sounds
         */
        // Round  end sound (APC Destroyed)
        public static readonly CVarDef<bool> RestartSoundsEnabled =
            CVarDef.Create("ambience.restart_sounds_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);


        /*
         * Admin sounds
         */

        public static readonly CVarDef<bool> AdminSoundsEnabled =
            CVarDef.Create("audio.admin_sounds_enabled", true, CVar.ARCHIVE | CVar.CLIENTONLY);
        public static readonly CVarDef<string> AdminChatSoundPath =
            CVarDef.Create("audio.admin_chat_sound_path", "/Audio/Items/pop.ogg", CVar.ARCHIVE | CVar.CLIENT | CVar.REPLICATED);
        public static readonly CVarDef<float> AdminChatSoundVolume =
            CVarDef.Create("audio.admin_chat_sound_volume", -5f, CVar.ARCHIVE | CVar.CLIENT | CVar.REPLICATED);

        /*
         * HUD
         */

        public static readonly CVarDef<int> HudTheme =
            CVarDef.Create("hud.theme", 0, CVar.ARCHIVE | CVar.CLIENTONLY);

        public static readonly CVarDef<bool> HudHeldItemShow =
            CVarDef.Create("hud.held_item_show", true, CVar.ARCHIVE | CVar.CLIENTONLY);

        public static readonly CVarDef<float> HudHeldItemOffset =
            CVarDef.Create("hud.held_item_offset", 28f, CVar.ARCHIVE | CVar.CLIENTONLY);

        public static readonly CVarDef<bool> HudFpsCounterVisible =
            CVarDef.Create("hud.fps_counter_visible", false, CVar.CLIENTONLY | CVar.ARCHIVE);

        /*
         * NPCs
         */

        public static readonly CVarDef<int> NPCMaxUpdates =
            CVarDef.Create("npc.max_updates", 128);

        public static readonly CVarDef<bool> NPCEnabled = CVarDef.Create("npc.enabled", true);

        /// <summary>
        /// Should NPCs pathfind when steering. For debug purposes.
        /// </summary>
        public static readonly CVarDef<bool> NPCPathfinding = CVarDef.Create("npc.pathfinding", true);

        /*
         * Net
         */

        public static readonly CVarDef<float> NetAtmosDebugOverlayTickRate =
            CVarDef.Create("net.atmosdbgoverlaytickrate", 3.0f);

        public static readonly CVarDef<float> NetGasOverlayTickRate =
            CVarDef.Create("net.gasoverlaytickrate", 3.0f);

        public static readonly CVarDef<int> GasOverlayThresholds =
            CVarDef.Create("net.gasoverlaythresholds", 20);

        /*
         * Admin stuff
         */

        public static readonly CVarDef<bool> AdminAnnounceLogin =
            CVarDef.Create("admin.announce_login", true, CVar.SERVERONLY);

        public static readonly CVarDef<bool> AdminAnnounceLogout =
            CVarDef.Create("admin.announce_logout", true, CVar.SERVERONLY);

        /*
         * Explosions
         */

        /// <summary>
        ///     How many tiles the explosion system will process per tick
        /// </summary>
        /// <remarks>
        ///     Setting this too high will put a large load on a single tick. Setting this too low will lead to
        ///     unnaturally "slow" explosions.
        /// </remarks>
        public static readonly CVarDef<int> ExplosionTilesPerTick =
            CVarDef.Create("explosion.tiles_per_tick", 100, CVar.SERVERONLY);

        /// <summary>
        ///     Upper limit on the size of an explosion before physics-throwing is disabled.
        /// </summary>
        /// <remarks>
        ///     Large nukes tend to generate a lot of shrapnel that flies through space. This can functionally cripple
        ///     the server TPS for a while after an explosion (or even during, if the explosion is processed
        ///     incrementally.
        /// </remarks>
        public static readonly CVarDef<int> ExplosionThrowLimit =
            CVarDef.Create("explosion.throw_limit", 400, CVar.SERVERONLY);

        /// <summary>
        ///     If this is true, explosion processing will pause the NodeGroupSystem to pause updating.
        /// </summary>
        /// <remarks>
        ///     This only takes effect if an explosion needs more than one tick to process (i.e., covers more than <see
        ///     cref="ExplosionTilesPerTick"/> tiles). If this is not enabled, the node-system will rebuild its graph
        ///     every tick as the explosion shreds the station, causing significant slowdown.
        /// </remarks>
        public static readonly CVarDef<bool> ExplosionSleepNodeSys =
            CVarDef.Create("explosion.node_sleep", true, CVar.SERVERONLY);

        /// <summary>
        ///     Upper limit on the total area that an explosion can affect before the neighbor-finding algorithm just
        ///     stops. Defaults to a 60-rile radius explosion.
        /// </summary>
        /// <remarks>
        ///     Actual area may be larger, as it currently doesn't terminate mid neighbor finding. I.e., area may be that of a ~51 tile radius circle instead.
        /// </remarks>
        public static readonly CVarDef<int> ExplosionMaxArea =
            CVarDef.Create("explosion.max_area", (int) 3.14f * 256 * 256, CVar.SERVERONLY);

        /// <summary>
        ///     Upper limit on the number of neighbor finding steps for the explosion system neighbor-finding algorithm.
        /// </summary>
        /// <remarks>
        ///     Effectively places an upper limit on the range that any explosion can have. In the vast majority of
        ///     instances, <see cref="ExplosionMaxArea"/> will likely be hit before this becomes a limiting factor.
        /// </remarks>
        public static readonly CVarDef<int> ExplosionMaxIterations =
            CVarDef.Create("explosion.max_iterations", 500, CVar.SERVERONLY);

        /// <summary>
        ///     Max Time in milliseconds to spend processing explosions every tick.
        /// </summary>
        /// <remarks>
        ///     This time limiting is not perfectly implemented. Firstly, a significant chunk of processing time happens
        ///     due to queued entity deletions, which happen outside of the system update code. Secondly, explosion
        ///     spawning cannot currently be interrupted & resumed, and may lead to exceeding this time limit.
        /// </remarks>
        public static readonly CVarDef<float> ExplosionMaxProcessingTime =
            CVarDef.Create("explosion.max_tick_time", 7f, CVar.SERVERONLY);

        /// <summary>
        ///     If the explosion is being processed incrementally over several ticks, this variable determines whether
        ///     updating the grid tiles should be done incrementally at the end of every tick, or only once the explosion has finished processing.
        /// </summary>
        /// <remarks>
        ///     The most notable consequence of this change is that explosions will only punch a hole in the station &
        ///     create a vacumm once they have finished exploding. So airlocks will no longer slam shut as the explosion
        ///     expands, just suddenly at the end.
        /// </remarks>
        public static readonly CVarDef<bool> ExplosionIncrementalTileBreaking =
            CVarDef.Create("explosion.incremental_tile", false, CVar.SERVERONLY);

        /// <summary>
        ///     This determines for how many seconds an explosion should stay visible once it has finished expanding.
        /// </summary>
        public static readonly CVarDef<float> ExplosionPersistence =
            CVarDef.Create("explosion.persistence", 0.3f, CVar.SERVERONLY);

        /// <summary>
        ///     If an explosion covers a larger area than this number, the damaging/processing will always start during
        ///     the next tick, instead of during the same tick that the explosion was generated in.
        /// </summary>
        /// <remarks>
        ///     This value can be used to ensure that for large explosions the area/tile calculation and the explosion
        ///     processing/damaging occurs in separate ticks. This helps reduce the single-tick lag if both <see
        ///     cref="ExplosionMaxProcessingTime"/> and <see cref="ExplosionTilesPerTick"/> are large. I.e., instead of
        ///     a single tick explosion, this cvar allows for a configuration that results in a two-tick explosion,
        ///     though most of the computational cost is still in the second tick.
        /// </remarks>
        public static readonly CVarDef<int> ExplosionSingleTickAreaLimit =
            CVarDef.Create("explosion.single_tick_area_limit", 400, CVar.SERVERONLY);

        /*
         * Radiation
         */

        /// <summary>
        ///     What is the smallest radiation dose in rads that can be received by object.
        ///     Extremely small values may impact performance.
        /// </summary>
        public static readonly CVarDef<float> RadiationMinIntensity =
            CVarDef.Create("radiation.min_intensity", 0.1f, CVar.SERVERONLY);

        /// <summary>
        ///     Rate of radiation system update in seconds.
        /// </summary>
        public static readonly CVarDef<float> RadiationGridcastUpdateRate =
            CVarDef.Create("radiation.gridcast.update_rate", 1.0f, CVar.SERVERONLY);

        /// <summary>
        ///     If both radiation source and receiver are placed on same grid, ignore grids between them.
        ///     May get inaccurate result in some cases, but greatly boost performance in general.
        /// </summary>
        public static readonly CVarDef<bool> RadiationGridcastSimplifiedSameGrid =
            CVarDef.Create("radiation.gridcast.simplified_same_grid", true, CVar.SERVERONLY);

        /// <summary>
        ///     Max distance that radiation ray can travel in meters.
        /// </summary>
        public static readonly CVarDef<float> RadiationGridcastMaxDistance =
            CVarDef.Create("radiation.gridcast.max_distance", 50f, CVar.SERVERONLY);

        /*
         * Admin logs
         */

        /// <summary>
        ///     Controls if admin logs are enabled. Highly recommended to shut this off for development.
        /// </summary>
        public static readonly CVarDef<bool> AdminLogsEnabled =
            CVarDef.Create("adminlogs.enabled", true, CVar.SERVERONLY);

        public static readonly CVarDef<float> AdminLogsQueueSendDelay =
            CVarDef.Create("adminlogs.queue_send_delay_seconds", 5f, CVar.SERVERONLY);

        public static readonly CVarDef<int> AdminLogsQueueMax =
            CVarDef.Create("adminlogs.queue_max", 5000, CVar.SERVERONLY);

        public static readonly CVarDef<int> AdminLogsPreRoundQueueMax =
            CVarDef.Create("adminlogs.pre_round_queue_max", 5000, CVar.SERVERONLY);

        // How many logs to send to the client at once
        public static readonly CVarDef<int> AdminLogsClientBatchSize =
            CVarDef.Create("adminlogs.client_batch_size", 1000, CVar.SERVERONLY);

        public static readonly CVarDef<string> AdminLogsServerName =
            CVarDef.Create("adminlogs.server_name", "unknown", CVar.SERVERONLY);

        /*
         * Atmos
         */

        /// <summary>
        ///     Whether gas differences will move entities.
        /// </summary>
        public static readonly CVarDef<bool> SpaceWind =
            CVarDef.Create("atmos.space_wind", false, CVar.SERVERONLY);

        /// <summary>
        ///     Divisor from maxForce (pressureDifference * 2.25f) to force applied on objects.
        /// </summary>
        public static readonly CVarDef<float> SpaceWindPressureForceDivisorThrow =
            CVarDef.Create("atmos.space_wind_pressure_force_divisor_throw", 15f, CVar.SERVERONLY);

        /// <summary>
        ///     Divisor from maxForce (pressureDifference * 2.25f) to force applied on objects.
        /// </summary>
        public static readonly CVarDef<float> SpaceWindPressureForceDivisorPush =
            CVarDef.Create("atmos.space_wind_pressure_force_divisor_push", 2500f, CVar.SERVERONLY);

        /// <summary>
        ///     The maximum velocity (not force) that may be applied to an object by atmospheric pressure differences.
        ///     Useful to prevent clipping through objects.
        /// </summary>
        public static readonly CVarDef<float> SpaceWindMaxVelocity =
            CVarDef.Create("atmos.space_wind_max_velocity", 30f, CVar.SERVERONLY);

        /// <summary>
        ///     The maximum force that may be applied to an object by pushing (i.e. not throwing) atmospheric pressure differences.
        ///     A "throwing" atmospheric pressure difference ignores this limit, but not the max. velocity limit.
        /// </summary>
        public static readonly CVarDef<float> SpaceWindMaxPushForce =
            CVarDef.Create("atmos.space_wind_max_push_force", 20f, CVar.SERVERONLY);

        /// <summary>
        ///     Whether monstermos tile equalization is enabled.
        /// </summary>
        public static readonly CVarDef<bool> MonstermosEqualization =
            CVarDef.Create("atmos.monstermos_equalization", true, CVar.SERVERONLY);

        /// <summary>
        ///     Whether monstermos explosive depressurization is enabled.
        ///     Needs <see cref="MonstermosEqualization"/> to be enabled to work.
        /// </summary>
        public static readonly CVarDef<bool> MonstermosDepressurization =
            CVarDef.Create("atmos.monstermos_depressurization", true, CVar.SERVERONLY);

        /// <summary>
        ///     Whether monstermos explosive depressurization will rip tiles..
        ///     Needs <see cref="MonstermosEqualization"/> and <see cref="MonstermosDepressurization"/> to be enabled to work.
        /// </summary>
        public static readonly CVarDef<bool> MonstermosRipTiles =
            CVarDef.Create("atmos.monstermos_rip_tiles", true, CVar.SERVERONLY);

        /// <summary>
        ///     Whether explosive depressurization will cause the grid to gain an impulse.
        ///     Needs <see cref="MonstermosEqualization"/> and <see cref="MonstermosDepressurization"/> to be enabled to work.
        /// </summary>
        public static readonly CVarDef<bool> AtmosGridImpulse =
            CVarDef.Create("atmos.grid_impulse", false, CVar.SERVERONLY);

        /// <summary>
        ///     Whether atmos superconduction is enabled.
        /// </summary>
        /// <remarks> Disabled by default, superconduction is awful. </remarks>
        public static readonly CVarDef<bool> Superconduction =
            CVarDef.Create("atmos.superconduction", false, CVar.SERVERONLY);

        /// <summary>
        ///     Whether excited groups will be processed and created.
        /// </summary>
        public static readonly CVarDef<bool> ExcitedGroups =
            CVarDef.Create("atmos.excited_groups", true, CVar.SERVERONLY);

        /// <summary>
        ///     Whether all tiles in an excited group will clear themselves once being exposed to space.
        ///     Similar to <see cref="MonstermosDepressurization"/>, without none of the tile ripping or
        ///     things being thrown around very violently.
        ///     Needs <see cref="ExcitedGroups"/> to be enabled to work.
        /// </summary>
        public static readonly CVarDef<bool> ExcitedGroupsSpaceIsAllConsuming =
            CVarDef.Create("atmos.excited_groups_space_is_all_consuming", false, CVar.SERVERONLY);

        /// <summary>
        ///     Maximum time in milliseconds that atmos can take processing.
        /// </summary>
        public static readonly CVarDef<float> AtmosMaxProcessTime =
            CVarDef.Create("atmos.max_process_time", 3f, CVar.SERVERONLY);

        /// <summary>
        ///     Atmos tickrate in TPS. Atmos processing will happen every 1/TPS seconds.
        /// </summary>
        public static readonly CVarDef<float> AtmosTickRate =
            CVarDef.Create("atmos.tickrate", 15f, CVar.SERVERONLY);

        /*
         * MIDI instruments
         */

        public static readonly CVarDef<int> MaxMidiEventsPerSecond =
            CVarDef.Create("midi.max_events_per_second", 1000, CVar.REPLICATED | CVar.SERVER);

        public static readonly CVarDef<int> MaxMidiEventsPerBatch =
            CVarDef.Create("midi.max_events_per_batch", 60, CVar.REPLICATED | CVar.SERVER);

        public static readonly CVarDef<int> MaxMidiBatchesDropped =
            CVarDef.Create("midi.max_batches_dropped", 1, CVar.SERVERONLY);

        public static readonly CVarDef<int> MaxMidiLaggedBatches =
            CVarDef.Create("midi.max_lagged_batches", 8, CVar.SERVERONLY);

        /*
         * Holidays
         */

        public static readonly CVarDef<bool> HolidaysEnabled = CVarDef.Create("holidays.enabled", true, CVar.SERVERONLY);

        /*
         * Branding stuff
         */

        public static readonly CVarDef<bool> BrandingSteam = CVarDef.Create("branding.steam", false, CVar.CLIENTONLY);

        /*
         * OOC
         */

        public static readonly CVarDef<bool> OocEnabled = CVarDef.Create("ooc.enabled", true, CVar.NOTIFY | CVar.REPLICATED);

        public static readonly CVarDef<bool> AdminOocEnabled =
            CVarDef.Create("ooc.enabled_admin", true, CVar.NOTIFY);

        /// <summary>
        /// If true, whenever OOC is disabled the Discord OOC relay will also be disabled.
        /// </summary>
        public static readonly CVarDef<bool> DisablingOOCDisablesRelay = CVarDef.Create("ooc.disabling_ooc_disables_relay", true, CVar.SERVERONLY);

        /// <summary>
        /// Whether or not OOC chat should be enabled during a round.
        /// </summary>
        public static readonly CVarDef<bool> OocEnableDuringRound =
            CVarDef.Create("ooc.enable_during_round", false, CVar.NOTIFY | CVar.REPLICATED |CVar.SERVER);

        /*
         * LOOC
         */

        public static readonly CVarDef<bool> LoocEnabled = CVarDef.Create("looc.enabled", true, CVar.NOTIFY | CVar.REPLICATED);

        public static readonly CVarDef<bool> AdminLoocEnabled =
            CVarDef.Create("looc.enabled_admin", true, CVar.NOTIFY);

        /// <summary>
        /// True: Dead players can use LOOC
        /// False: Dead player LOOC gets redirected to dead chat
        /// </summary>
        public static readonly CVarDef<bool> DeadLoocEnabled = CVarDef.Create("looc.enabled_dead", false, CVar.NOTIFY | CVar.REPLICATED);

        /*
         * Entity Menu Grouping Types
         */
        public static readonly CVarDef<int> EntityMenuGroupingType = CVarDef.Create("entity_menu", 0, CVar.CLIENTONLY);

        /*
         * Whitelist
         */

        /// <summary>
        ///     Controls whether the server will deny any players that are not whitelisted in the DB.
        /// </summary>
        public static readonly CVarDef<bool> WhitelistEnabled =
            CVarDef.Create("whitelist.enabled", false, CVar.SERVERONLY);

        /// <summary>
        ///     The loc string to display as a disconnect reason when someone is not whitelisted.
        /// </summary>
        public static readonly CVarDef<string> WhitelistReason =
            CVarDef.Create("whitelist.reason", "whitelist-not-whitelisted", CVar.SERVERONLY);

        /// <summary>
        ///     If the playercount is below this number, the whitelist will not apply.
        /// </summary>
        public static readonly CVarDef<int> WhitelistMinPlayers =
            CVarDef.Create("whitelist.min_players", 0, CVar.SERVERONLY);

        /// <summary>
        ///     If the playercount is above this number, the whitelist will not apply.
        /// </summary>
        public static readonly CVarDef<int> WhitelistMaxPlayers =
            CVarDef.Create("whitelist.max_players", int.MaxValue, CVar.SERVERONLY);

        /*
         * VOTE
         */

        /// <summary>
        ///     Allows enabling/disabling player-started votes for ultimate authority
        /// </summary>
        public static readonly CVarDef<bool> VoteEnabled =
            CVarDef.Create("vote.enabled", true, CVar.SERVERONLY);

        /// <summary>
        ///     See vote.enabled, but specific to restart votes
        /// </summary>
        public static readonly CVarDef<bool> VoteRestartEnabled =
            CVarDef.Create("vote.restart_enabled", true, CVar.SERVERONLY);

        /// <summary>
        ///     See vote.enabled, but specific to preset votes
        /// </summary>
        public static readonly CVarDef<bool> VotePresetEnabled =
            CVarDef.Create("vote.preset_enabled", true, CVar.SERVERONLY);

        /// <summary>
        ///     See vote.enabled, but specific to map votes
        /// </summary>
        public static readonly CVarDef<bool> VoteMapEnabled =
            CVarDef.Create("vote.map_enabled", false, CVar.SERVERONLY);

        /// <summary>
        ///     The required ratio of the server that must agree for a restart round vote to go through.
        /// </summary>
        public static readonly CVarDef<float> VoteRestartRequiredRatio =
            CVarDef.Create("vote.restart_required_ratio", 0.85f, CVar.SERVERONLY);

        /// <summary>
        /// Whether or not to restrict the restart vote when there's online admins.
        /// </summary>
        public static readonly CVarDef<bool> VoteRestartNotAllowedWhenAdminOnline =
            CVarDef.Create("vote.restart_not_allowed_when_admin_online", true, CVar.SERVERONLY);

        /// <summary>
        ///     The delay which two votes of the same type are allowed to be made by separate people, in seconds.
        /// </summary>
        public static readonly CVarDef<float> VoteSameTypeTimeout =
            CVarDef.Create("vote.same_type_timeout", 240f, CVar.SERVERONLY);


        /// <summary>
        ///     Sets the duration of the map vote timer.
        /// </summary>
        public static readonly CVarDef<int>
            VoteTimerMap = CVarDef.Create("vote.timermap", 90, CVar.SERVERONLY);

        /// <summary>
        ///     Sets the duration of the restart vote timer.
        /// </summary>
        public static readonly CVarDef<int>
            VoteTimerRestart = CVarDef.Create("vote.timerrestart", 60, CVar.SERVERONLY);

        /// <summary>
        ///     Sets the duration of the gamemode/preset vote timer.
        /// </summary>
        public static readonly CVarDef<int>
            VoteTimerPreset = CVarDef.Create("vote.timerpreset", 30, CVar.SERVERONLY);

        /// <summary>
        ///     Sets the duration of the map vote timer when ALONE.
        /// </summary>
        public static readonly CVarDef<int>
            VoteTimerAlone = CVarDef.Create("vote.timeralone", 10, CVar.SERVERONLY);


        /*
         * BAN
         */

        public static readonly CVarDef<bool> BanHardwareIds =
            CVarDef.Create("ban.hardware_ids", true, CVar.SERVERONLY);

        /*
         * Procgen
         */

        /// <summary>
        /// Should we pre-load all of the procgen atlasses.
        /// </summary>
        public static readonly CVarDef<bool> ProcgenPreload =
            CVarDef.Create("procgen.preload", true, CVar.SERVERONLY);

        /*
         * Shuttles
         */

        // Look this is technically eye behavior but its main impact is shuttles so I just dumped it here.
        /// <summary>
        /// If true then the camera will match the grid / map and is unchangeable.
        /// - When traversing grids it will snap to 0 degrees rotation.
        /// False means the player has control over the camera rotation.
        /// - When traversing grids it will snap to the nearest cardinal which will generally be imperceptible.
        /// </summary>
        public static readonly CVarDef<bool> CameraRotationLocked =
            CVarDef.Create("shuttle.camera_rotation_locked", false, CVar.REPLICATED);

        /// <summary>
        /// Whether the arrivals shuttle is enabled.
        /// </summary>
        public static readonly CVarDef<bool> ArrivalsShuttles =
            CVarDef.Create("shuttle.arrivals", true, CVar.SERVERONLY);

        /// <summary>
        /// The map to use for the arrivals station.
        /// </summary>
        public static readonly CVarDef<ResourcePath> ArrivalsMap =
            CVarDef.Create("shuttle.arrivals_map", new ResourcePath("/Maps/Misc/terminal.yml"), CVar.SERVERONLY);

        /// <summary>
        /// Cooldown between arrivals departures. This should be longer than the FTL time or it will double cycle.
        /// </summary>
        public static readonly CVarDef<float> ArrivalsCooldown =
            CVarDef.Create("shuttle.arrivals_cooldown", 90f, CVar.SERVERONLY);

        /// <summary>
        /// Are players allowed to return on the arrivals shuttle.
        /// </summary>
        public static readonly CVarDef<bool> ArrivalsReturns =
            CVarDef.Create("shuttle.arrivals_returns", false, CVar.SERVERONLY);

        /// <summary>
        /// Whether cargo shuttles are enabled.
        /// </summary>
        public static readonly CVarDef<bool> CargoShuttles =
            CVarDef.Create("shuttle.cargo", true, CVar.SERVERONLY);

        /*
         * Emergency
         */

        /// <summary>
        /// Is the emergency shuttle allowed to be early launched.
        /// </summary>
        public static readonly CVarDef<bool> EmergencyEarlyLaunchAllowed =
            CVarDef.Create("shuttle.emergency_early_launch_allowed", false, CVar.SERVERONLY);

        /// <summary>
        /// How long the emergency shuttle remains docked with the station, in seconds.
        /// </summary>
        public static readonly CVarDef<float> EmergencyShuttleDockTime =
            CVarDef.Create("shuttle.emergency_dock_time", 180f, CVar.SERVERONLY);

        /// <summary>
        /// How long after the console is authorized for the shuttle to early launch.
        /// </summary>
        public static readonly CVarDef<float> EmergencyShuttleAuthorizeTime =
            CVarDef.Create("shuttle.emergency_authorize_time", 10f, CVar.SERVERONLY);

        /// <summary>
        /// The minimum time for the emergency shuttle to arrive at centcomm.
        /// </summary>
        public static readonly CVarDef<float> EmergencyShuttleMinTransitTime =
            CVarDef.Create("shuttle.emergency_transit_time_min", 60f, CVar.SERVERONLY);

        /// <summary>
        /// The maximum time for the emergency shuttle to arrive at centcomm.
        /// </summary>
        public static readonly CVarDef<float> EmergencyShuttleMaxTransitTime =
            CVarDef.Create("shuttle.emergency_transit_time_max", 180f, CVar.SERVERONLY);

        /// <summary>
        /// Whether the emergency shuttle is enabled or should the round just end.
        /// </summary>
        public static readonly CVarDef<bool> EmergencyShuttleEnabled =
            CVarDef.Create("shuttle.emergency", true, CVar.SERVERONLY);

        /// <summary>
        ///     The percentage of time passed from the initial call to when the shuttle can no longer be recalled.
        ///     ex. a call time of 10min and turning point of 0.5 means the shuttle cannot be recalled after 5 minutes.
        /// </summary>
        public static readonly CVarDef<float> EmergencyRecallTurningPoint =
            CVarDef.Create("shuttle.recall_turning_point", 0.5f, CVar.SERVERONLY);

        /// <summary>
        ///     Time in minutes after round start to auto-call the shuttle. Set to zero to disable.
        /// </summary>
        public static readonly CVarDef<int> EmergencyShuttleAutoCallTime =
            CVarDef.Create("shuttle.auto_call_time", 90, CVar.SERVERONLY);

        /// <summary>
        ///     Time in minutes after the round was extended (by recalling the shuttle) to call
        ///     the shuttle again.
        /// </summary>
        public static readonly CVarDef<int> EmergencyShuttleAutoCallExtensionTime =
            CVarDef.Create("shuttle.auto_call_extension_time", 45, CVar.SERVERONLY);

        /// <summary>
        /// The map to load for CentCom for the emergency shuttle to dock to.
        /// </summary>
        public static readonly CVarDef<string> CentcommMap =
            CVarDef.Create("shuttle.centcomm_map", "/Maps/centcomm.yml", CVar.SERVERONLY);

        /*
         * Crew Manifests
         */

        /// <summary>
        ///     Setting this allows a crew manifest to be opened from any window
        ///     that has a crew manifest button, and sends the correct message.
        ///     If this is false, only in-game entities will allow you to see
        ///     the crew manifest, if the functionality is coded in.
        ///     Having administrator priveledge ignores this, but will still
        ///     hide the button in UI windows.
        /// </summary>
        public static readonly CVarDef<bool> CrewManifestWithoutEntity =
            CVarDef.Create("crewmanifest.no_entity", true, CVar.REPLICATED);

        /// <summary>
        ///     Setting this allows the crew manifest to be viewed from 'unsecure'
        ///     entities, such as the PDA.
        /// </summary>
        public static readonly CVarDef<bool> CrewManifestUnsecure =
            CVarDef.Create("crewmanifest.unsecure", true, CVar.REPLICATED);

        /// <summary>
        ///     Dictates the order the crew manifest will appear in, in terms of its sections.
        ///     Sections not in this list will appear at the end of the list, in no
        ///     specific order.
        /// </summary>
        public static readonly CVarDef<string> CrewManifestOrdering =
            CVarDef.Create("crewmanifest.ordering", "Command,Security,Science,Medical,Engineering,Cargo,Civilian,Unknown",
                CVar.REPLICATED);

        /*
         * Biomass
         */

        /// <summary>
        ///     Enabled: Cloning has 70% cost and reclaimer will refuse to reclaim corpses with souls. (For LRP).
        ///     Disabled: Cloning has full biomass cost and reclaimer can reclaim corpses with souls. (Playtested and balanced for MRP+).
        /// </summary>
        public static readonly CVarDef<bool> BiomassEasyMode =
            CVarDef.Create("biomass.easy_mode", true, CVar.SERVERONLY);

        /*
         * Anomaly
         */

        /// <summary>
        ///     A scale factor applied to a grid's bounds when trying to find a spot to randomly generate an anomaly.
        /// </summary>
        public static readonly CVarDef<float> AnomalyGenerationGridBoundsScale =
            CVarDef.Create("anomaly.generation_grid_bounds_scale", 0.6f, CVar.SERVERONLY);

        /*
         * VIEWPORT
         */

        public static readonly CVarDef<bool> ViewportStretch =
            CVarDef.Create("viewport.stretch", true, CVar.CLIENTONLY | CVar.ARCHIVE);

        public static readonly CVarDef<int> ViewportFixedScaleFactor =
            CVarDef.Create("viewport.fixed_scale_factor", 2, CVar.CLIENTONLY | CVar.ARCHIVE);

        // This default is basically specifically chosen so fullscreen/maximized 1080p hits a 2x snap and does NN.
        public static readonly CVarDef<int> ViewportSnapToleranceMargin =
            CVarDef.Create("viewport.snap_tolerance_margin", 64, CVar.CLIENTONLY | CVar.ARCHIVE);

        public static readonly CVarDef<int> ViewportSnapToleranceClip =
            CVarDef.Create("viewport.snap_tolerance_clip", 32, CVar.CLIENTONLY | CVar.ARCHIVE);

        public static readonly CVarDef<bool> ViewportScaleRender =
            CVarDef.Create("viewport.scale_render", true, CVar.CLIENTONLY | CVar.ARCHIVE);

        public static readonly CVarDef<int> ViewportMinimumWidth =
            CVarDef.Create("viewport.minimum_width", 15, CVar.REPLICATED);

        public static readonly CVarDef<int> ViewportMaximumWidth =
            CVarDef.Create("viewport.maximum_width", 21, CVar.REPLICATED);

        public static readonly CVarDef<int> ViewportWidth =
            CVarDef.Create("viewport.width", 21, CVar.CLIENTONLY | CVar.ARCHIVE);

        /*
         * UI
         */

        public static readonly CVarDef<string> UILayout =
            CVarDef.Create("ui.layout", "Default", CVar.CLIENTONLY | CVar.ARCHIVE);

        public static readonly CVarDef<string> DefaultScreenChatSize =
            CVarDef.Create("ui.default_chat_size", "", CVar.CLIENTONLY | CVar.ARCHIVE);

        public static readonly CVarDef<string> SeparatedScreenChatSize =
            CVarDef.Create("ui.separated_chat_size", "0.6,0", CVar.CLIENTONLY | CVar.ARCHIVE);


        /*
         * CHAT
         */

        public static readonly CVarDef<int> ChatMaxMessageLength =
            CVarDef.Create("chat.max_message_length", 1000, CVar.SERVER | CVar.REPLICATED);

        public static readonly CVarDef<bool> ChatSanitizerEnabled =
            CVarDef.Create("chat.chat_sanitizer_enabled", true, CVar.SERVERONLY);

        public static readonly CVarDef<bool> ChatShowTypingIndicator =
            CVarDef.Create("chat.show_typing_indicator", true, CVar.CLIENTONLY);

        /// <summary>
        /// A message broadcast to each player that joins the lobby.
        /// May be changed by admins ingame through use of the "set-motd" command.
        /// In this case the new value, if not empty, is broadcast to all connected players and saved between rounds.
        /// May be requested by any player through use of the "get-motd" command.
        /// </summary>
        public static readonly CVarDef<string> MOTD =
            CVarDef.Create("chat.motd", "", CVar.SERVER | CVar.SERVERONLY | CVar.ARCHIVE, "A message broadcast to each player that joins the lobby.");

        /*
         * AFK
         */

        /// <summary>
        /// How long a client can go without any input before being considered AFK.
        /// </summary>
        public static readonly CVarDef<float> AfkTime =
            CVarDef.Create("afk.time", 60f, CVar.SERVERONLY);

        /*
         * IC
         */

        /// <summary>
        /// Restricts IC character names to alphanumeric chars.
        /// </summary>
        public static readonly CVarDef<bool> RestrictedNames =
            CVarDef.Create("ic.restricted_names", true, CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Allows flavor text (character descriptions)
        /// </summary>
        public static readonly CVarDef<bool> FlavorText =
            CVarDef.Create("ic.flavor_text", false, CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Adds a period at the end of a sentence if the sentence ends in a letter.
        /// </summary>
        public static readonly CVarDef<bool> ChatPunctuation =
            CVarDef.Create("ic.punctuation", false, CVar.SERVER);

        /// <summary>
        /// Enables automatically forcing IC name rules. Uppercases the first letter of the first and last words of the name
        /// </summary>
        public static readonly CVarDef<bool> ICNameCase =
            CVarDef.Create("ic.name_case", true, CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Whether or not players' characters are randomly generated rather than using their selected characters in the creator.
        /// </summary>
        public static readonly CVarDef<bool> ICRandomCharacters =
            CVarDef.Create("ic.random_characters", false, CVar.SERVER);

        /// <summary>
        /// A weighted random prototype used to determine the species selected for random characters.
        /// </summary>
        public static readonly CVarDef<string> ICRandomSpeciesWeights =
            CVarDef.Create("ic.random_species_weights", "SpeciesWeights", CVar.SERVER);

        /*
         * Salvage
         */

        /// <summary>
        ///     Forced salvage map prototype name (if empty, randomly selected)
        /// </summary>
        public static readonly CVarDef<string>
            SalvageForced = CVarDef.Create("salvage.forced", "", CVar.SERVERONLY);

        /*

         * Flavor
         */

        /// <summary>
        ///     Flavor limit. This is to ensure that having a large mass of flavors in
        ///     some food object won't spam a user with flavors.
        /// </summary>
        public static readonly CVarDef<int>
            FlavorLimit = CVarDef.Create("flavor.limit", 10, CVar.SERVERONLY);

        /*
         * Mapping
         */

        /// <summary>
        ///     Will mapping mode enable autosaves when it's activated?
        /// </summary>
        public static readonly CVarDef<bool>
            AutosaveEnabled = CVarDef.Create("mapping.autosave", true, CVar.SERVERONLY);

        /// <summary>
        ///     Autosave interval in seconds.
        /// </summary>
        public static readonly CVarDef<float>
            AutosaveInterval = CVarDef.Create("mapping.autosave_interval", 600f, CVar.SERVERONLY);

        /// <summary>
        ///     Directory in server user data to save to. Saves will be inside folders in this directory.
        /// </summary>
        public static readonly CVarDef<string>
            AutosaveDirectory = CVarDef.Create("mapping.autosave_dir", "Autosaves", CVar.SERVERONLY);


        /*
         * Rules
         */

        /// <summary>
        /// Time that players have to wait before rules can be accepted.
        /// </summary>
        public static readonly CVarDef<float> RulesWaitTime =
            CVarDef.Create("rules.time", 45f, CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Don't show rules to localhost/loopback interface.
        /// </summary>
        public static readonly CVarDef<bool> RulesExemptLocal =
            CVarDef.Create("rules.exempt_local", true, CVar.SERVERONLY);


        /*
         * Autogeneration
         */

        public static readonly CVarDef<string> DestinationFile =
            CVarDef.Create("autogen.destination_file", "", CVar.SERVER | CVar.SERVERONLY);

        /*
         * Network Resource Manager
         */

        /// <summary>
        /// Controls whether new resources can be uploaded by admins.
        /// Does not prevent already uploaded resources from being sent.
        /// </summary>
        public static readonly CVarDef<bool> ResourceUploadingEnabled =
            CVarDef.Create("netres.enabled", true, CVar.REPLICATED | CVar.SERVER);

        /// <summary>
        /// Controls the data size limit in megabytes for uploaded resources. If they're too big, they will be dropped.
        /// Set to zero or a negative value to disable limit.
        /// </summary>
        public static readonly CVarDef<float> ResourceUploadingLimitMb =
            CVarDef.Create("netres.limit", 3f, CVar.REPLICATED | CVar.SERVER);

        /// <summary>
        /// Whether uploaded files will be stored in the server's database.
        /// This is useful to keep "logs" on what files admins have uploaded in the past.
        /// </summary>
        public static readonly CVarDef<bool> ResourceUploadingStoreEnabled =
            CVarDef.Create("netres.store_enabled", true, CVar.SERVER | CVar.SERVERONLY);

        /// <summary>
        /// Numbers of days before stored uploaded files are deleted. Set to zero or negative to disable auto-delete.
        /// This is useful to free some space automatically. Auto-deletion runs only on server boot.
        /// </summary>
        public static readonly CVarDef<int> ResourceUploadingStoreDeletionDays =
            CVarDef.Create("netres.store_deletion_days", 30, CVar.SERVER | CVar.SERVERONLY);

        /*
         * Controls
         */

        /// <summary>
        /// Deadzone for drag-drop interactions.
        /// </summary>
        public static readonly CVarDef<float> DragDropDeadZone =
            CVarDef.Create("control.drag_dead_zone", 12f, CVar.CLIENTONLY | CVar.ARCHIVE);

        /*
         * UPDATE
         */

        /// <summary>
        /// If a server update restart is pending, the delay after the last player leaves before we actually restart. In seconds.
        /// </summary>
        public static readonly CVarDef<float> UpdateRestartDelay =
            CVarDef.Create("update.restart_delay", 20f, CVar.SERVERONLY);

        /*
         * Ghost
         */

        /// <summary>
        /// The time you must spend reading the rules, before the "Request" button is enabled
        /// </summary>
        public static readonly CVarDef<float> GhostRoleTime =
            CVarDef.Create("ghost.role_time", 3f, CVar.REPLICATED);

        /*
         * Fire alarm
         */

        /// <summary>
        ///     If fire alarms should have all access, or if activating/resetting these
        ///     should be restricted to what is dictated on a player's access card.
        ///     Defaults to true.
        /// </summary>
        public static readonly CVarDef<bool> FireAlarmAllAccess =
            CVarDef.Create("firealarm.allaccess", true, CVar.SERVERONLY);

        /*
         * PLAYTIME
         */

        /// <summary>
        /// Time between play time autosaves, in seconds.
        /// </summary>
        public static readonly CVarDef<float>
            PlayTimeSaveInterval = CVarDef.Create("playtime.save_interval", 900f, CVar.SERVERONLY);

        /*
         * INFOLINKS
         */

        /// <summary>
        /// Link to Discord server to show in the launcher.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksDiscord =
            CVarDef.Create("infolinks.discord", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to website to show in the launcher.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksForum =
            CVarDef.Create("infolinks.forum", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to GitHub page to show in the launcher.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksGithub =
            CVarDef.Create("infolinks.github", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to website to show in the launcher.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksWebsite =
            CVarDef.Create("infolinks.website", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to wiki to show in the launcher.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksWiki =
            CVarDef.Create("infolinks.wiki", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to Patreon. Not shown in the launcher currently.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksPatreon =
            CVarDef.Create("infolinks.patreon", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to the bug report form.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksBugReport =
            CVarDef.Create("infolinks.bug_report", "", CVar.SERVER | CVar.REPLICATED);

        /// <summary>
        /// Link to site handling ban appeals. Shown in ban disconnect messages.
        /// </summary>
        public static readonly CVarDef<string> InfoLinksAppeal =
            CVarDef.Create("infolinks.appeal", "", CVar.SERVER | CVar.REPLICATED);

        /*
         * CONFIG
         */

        // These are server-only for now since I don't foresee a client use yet,
        // and I don't wanna have to start coming up with like .client suffixes and stuff like that.

        /// <summary>
        /// Configuration presets to load during startup.
        /// Multiple presets can be separated by comma and are loaded in order.
        /// </summary>
        /// <remarks>
        /// Loaded presets must be located under the <c>ConfigPresets/</c> resource directory and end with the <c>.toml</c> extension.
        /// Only the file name (without extension) must be given for this variable.
        /// </remarks>
        public static readonly CVarDef<string> ConfigPresets =
            CVarDef.Create("config.presets", "", CVar.SERVERONLY);

        /// <summary>
        /// Whether to load the preset development CVars.
        /// This disables some things like lobby to make development easier.
        /// Even when true, these are only loaded if the game is compiled with <c>DEVELOPMENT</c> set.
        /// </summary>
        public static readonly CVarDef<bool> ConfigPresetDevelopment =
            CVarDef.Create("config.preset_development", true, CVar.SERVERONLY);

        /// <summary>
        /// Whether to load the preset debug CVars.
        /// Even when true, these are only loaded if the game is compiled with <c>DEBUG</c> set.
        /// </summary>
        public static readonly CVarDef<bool> ConfigPresetDebug =
            CVarDef.Create("config.preset_debug", true, CVar.SERVERONLY);
    }
}