quakespasm/Quake/cvar.cpp

/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2010-2014 QuakeSpasm developers

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// cvar.c -- dynamic variable tracking

#include "quakedef.hpp"

#include <map>
#include <string>
#include <ranges>
#include <memory>
#include <cstring>

static cvar_t *cvar_vars;
static char cvar_null_string[] = "";

std::map<std::string, cvar_t* > CLIENT_VARIABLES{};

//==============================================================================
//
//  USER COMMANDS
//
//==============================================================================

void Cvar_Reset(const std::string &name); //johnfitz

/*
============
Cvar_List_f -- johnfitz
============
*/
void Cvar_List_f() {
    cvar_t *cvar;
    const char *partial;
    int len, count;

    if (Cmd_Argc() > 1) {
        partial = Cmd_Argv(1);
        len = Q_strlen(partial);
    } else {
        partial = NULL;
        len = 0;
    }

    count = 0;
    for (const auto &[name, var]: CLIENT_VARIABLES) {
        if (partial && Q_strncmp(partial, name.c_str(), len)) {
            continue;
        }
        Con_SafePrintf("%s%s %s \"%s\"\n",
                       (var->flags & CVAR_ARCHIVE) ? "*" : " ",
                       (var->flags & CVAR_NOTIFY) ? "s" : " ",
                       name.c_str(),
                       var->string);
        count++;
    }

    Con_SafePrintf("%i cvars", count);
    if (partial) {
        Con_SafePrintf(" beginning with \"%s\"", partial);
    }
    Con_SafePrintf("\n");
}

/*
============
Cvar_Inc_f -- johnfitz
============
*/
void Cvar_Inc_f(void) {
    switch (Cmd_Argc()) {
        default:
        case 1:
            Con_Printf("inc <cvar> [amount] : increment cvar\n");
            break;
        case 2:
            Cvar_SetValue(Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + 1);
            break;
        case 3:
            Cvar_SetValue(Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + Q_atof(Cmd_Argv(2)));
            break;
    }
}

/*
============
Cvar_Toggle_f -- johnfitz
============
*/
void Cvar_Toggle_f(void) {
    switch (Cmd_Argc()) {
        default:
        case 1:
            Con_Printf("toggle <cvar> : toggle cvar\n");
            break;
        case 2:
            if (Cvar_VariableValue(Cmd_Argv(1)))
                Cvar_Set(Cmd_Argv(1), "0");
            else
                Cvar_Set(Cmd_Argv(1), "1");
            break;
    }
}

/*
============
Cvar_Cycle_f -- johnfitz
============
*/
void Cvar_Cycle_f() {
    int i;

    if (Cmd_Argc() < 3) {
        Con_Printf("cycle <cvar> <value list>: cycle cvar through a list of values\n");
        return;
    }

    //loop through the args until you find one that matches the current cvar value.
    //yes, this will get stuck on a list that contains the same value twice.
    //it's not worth dealing with, and i'm not even sure it can be dealt with.
    for (i = 2; i < Cmd_Argc(); i++) {
        //zero is assumed to be a string, even though it could actually be zero.  The worst case
        //is that the first time you call this command, it won't match on zero when it should, but after that,
        //it will be comparing strings that all had the same source (the user) so it will work.
        if (Q_atof(Cmd_Argv(i)) == 0) {
            if (!strcmp(Cmd_Argv(i), Cvar_VariableString(Cmd_Argv(1))))
                break;
        } else {
            if (Q_atof(Cmd_Argv(i)) == Cvar_VariableValue(Cmd_Argv(1)))
                break;
        }
    }

    if (i == Cmd_Argc())
        Cvar_Set(Cmd_Argv(1), Cmd_Argv(2)); // no match
    else if (i + 1 == Cmd_Argc())
        Cvar_Set(Cmd_Argv(1), Cmd_Argv(2)); // matched last value in list
    else
        Cvar_Set(Cmd_Argv(1), Cmd_Argv(i + 1)); // matched earlier in list
}

/*
============
Cvar_Reset_f -- johnfitz
============
*/
void Cvar_Reset_f() {
    switch (Cmd_Argc()) {
        default:
        case 1:
            Con_Printf("reset <cvar> : reset cvar to default\n");
            break;
        case 2:
            Cvar_Reset(Cmd_Argv(1));
            break;
    }
}

/*
============
Cvar_ResetAll_f -- johnfitz
============
*/
void Cvar_ResetAll_f(void) {
    cvar_t *var;

    for (auto name: std::views::keys(CLIENT_VARIABLES))
        Cvar_Reset(name);
}

/*
============
Cvar_ResetCfg_f -- QuakeSpasm
============
*/
void Cvar_ResetCfg_f() {
    for (const auto &var: std::views::values(CLIENT_VARIABLES))
        if (var->flags & CVAR_ARCHIVE) Cvar_Reset(var->name);
}

//==============================================================================
//
//  INIT
//
//==============================================================================

/*
============
Cvar_Init -- johnfitz
============
*/

void Cvar_Init() {
    Cmd_AddCommand("cvarlist", Cvar_List_f);
    Cmd_AddCommand("toggle", Cvar_Toggle_f);
    Cmd_AddCommand("cycle", Cvar_Cycle_f);
    Cmd_AddCommand("inc", Cvar_Inc_f);
    Cmd_AddCommand("reset", Cvar_Reset_f);
    Cmd_AddCommand("resetall", Cvar_ResetAll_f);
    Cmd_AddCommand("resetcfg", Cvar_ResetCfg_f);
}

//==============================================================================
//
//  CVAR FUNCTIONS
//
//==============================================================================

/*
============
Cvar_FindVar
============
*/
std::optional<cvar_t *> Cvar_FindVar(const std::string &desired) {
    for (auto &[name, var]: CLIENT_VARIABLES) {
        if (name == desired)
            return var;
    }

    return std::nullopt;
}

cvar_t *Cvar_FindVarAfter(const char *prev_name, unsigned int with_flags) {
    // cvar_t	*var;
    //
    // if (*prev_name)
    // {
    // 	var = Cvar_FindVar (prev_name);
    // 	if (!var)
    // 		return NULL;
    // 	var = var->next;
    // }
    // else
    // 	var = cvar_vars;
    //
    // // search for the next cvar matching the needed flags
    // while (var)
    // {
    // 	if ((var->flags & with_flags) || !with_flags)
    // 		break;
    // 	var = var->next;
    // }
    // return var;
    return nullptr; // TODO
}

/*
============
Cvar_LockVar
============
*/
void Cvar_LockVar(const std::string &name) {
    if (const auto var = Cvar_FindVar(name); var.has_value())
        var.value()->flags |= CVAR_LOCKED;
}

void Cvar_UnlockVar(const std::string &name) {
    if (const auto var = Cvar_FindVar(name); var.has_value())
        var.value()->flags &= ~CVAR_LOCKED;
}

void Cvar_UnlockAll() {
    for (const auto &var: std::views::values(CLIENT_VARIABLES)) {
        var->flags &= ~CVAR_LOCKED;
    }
}

/*
============
Cvar_VariableValue
============
*/
float Cvar_VariableValue(const char *var_name) {
    const auto var = Cvar_FindVar(var_name);
    if (!var.has_value())
        return 0;
    return std::strtof(var.value()->string, nullptr);
}


/*
============
Cvar_VariableString
============
*/
const char *Cvar_VariableString(const char *var_name) {
    const auto var = Cvar_FindVar(var_name);
    if (!var.has_value())
        return cvar_null_string;
    return var.value()->string;
}


/*
============
Cvar_CompleteVariable
============
*/
std::optional<std::string_view> Cvar_CompleteVariable(const std::string_view &partial) {
    if (!partial.empty())
        return std::nullopt;

    // check functions
    for (const auto &name: CLIENT_VARIABLES | std::views::keys) {
        if (name.contains(name))
            return name;
    }

    return std::nullopt;
}

/*
============
Cvar_Reset -- johnfitz
============
*/
void Cvar_Reset(const std::string &name) {
    if (const auto var = Cvar_FindVar(name); !var.has_value())
        Con_Printf("variable \"%s\" not found\n", name.c_str());
    else
        Cvar_SetQuick(var.value(), var.value()->default_string);
}

void Cvar_SetQuick(cvar_t *var, const std::string &value) {
    if (var->flags & (CVAR_ROM | CVAR_LOCKED))
        return;
    if (!(var->flags & CVAR_REGISTERED))
        return;

    if (!var->string)
        var->string = Z_Strdup(value.c_str());
    else {
        int len;

        if (!strcmp(var->string, value.c_str()))
            return; // no change

        var->flags |= CVAR_CHANGED;
        len = value.length();
        if (len != Q_strlen(var->string)) {
            Z_Free((void *) var->string);
            var->string = (char *) Z_Malloc(len + 1);
        }
        memcpy((char *) var->string, value.c_str(), len + 1);
    }

    var->value = Q_atof(var->string);

    //johnfitz -- save initial value for "reset" command
    if (!var->default_string)
        var->default_string = Z_Strdup(var->string);
        //johnfitz -- during initialization, update default too
    else if (!host_initialized) {
        //	Sys_Printf("changing default of %s: %s -> %s\n",
        //		   var->name, var->default_string, var->string);
        Z_Free((void *) var->default_string);
        var->default_string = Z_Strdup(var->string);
    }
    //johnfitz

    if (var->callback)
        var->callback(var);
}

void Cvar_SetValueQuick(cvar_t *var, const float value) {
    char val[32], *ptr = val;

    if (value == (float) ((int) value))
        q_snprintf(val, sizeof(val), "%i", (int) value);
    else {
        q_snprintf(val, sizeof(val), "%f", value);
        // kill trailing zeroes
        while (*ptr)
            ptr++;
        while (--ptr > val && *ptr == '0' && ptr[-1] != '.')
            *ptr = '\0';
    }

    Cvar_SetQuick(var, val);
}

/*
============
Cvar_Set
============
*/
void Cvar_Set(const std::string &name, const std::string &value) {
    auto var = Cvar_FindVar(name);
    if (!var.has_value()) {
        // there is an error in C code if this happens
        Con_Printf("Cvar_Set: variable %s not found\n", name.c_str());
        return;
    }

    Cvar_SetQuick(var.value(), value);
}

/*
============
Cvar_SetValue
============
*/
void Cvar_SetValue(const char *var_name, const float value) {
    char val[32], *ptr = val;

    if (value == (float) ((int) value))
        q_snprintf(val, sizeof(val), "%i", (int) value);
    else {
        q_snprintf(val, sizeof(val), "%f", value);
        // kill trailing zeroes
        while (*ptr)
            ptr++;
        while (--ptr > val && *ptr == '0' && ptr[-1] != '.')
            *ptr = '\0';
    }

    Cvar_Set(var_name, val);
}

/*
============
Cvar_SetROM
============
*/
void Cvar_SetROM(const char *var_name, const char *value) {
    if (const auto var = Cvar_FindVar(var_name); var.has_value()) {
        var.value()->flags &= ~CVAR_ROM;
        Cvar_SetQuick(var.value(), value);
        var.value()->flags |= CVAR_ROM;
    }
}

/*
============
Cvar_SetValueROM
============
*/
void Cvar_SetValueROM(const char *var_name, const float value) {
    if (const auto var = Cvar_FindVar(var_name); var.has_value()) {
        var.value()->flags &= ~CVAR_ROM;
        Cvar_SetValueQuick(var.value(), value);
        var.value()->flags |= CVAR_ROM;
    }
}

/*
============
Cvar_RegisterVariable

Adds a freestanding variable to the variable list.
============
*/
void Cvar_RegisterVariable(cvar_t *variable) {
    char value[512];
    qboolean set_rom;
    cvar_t *cursor, *prev; //johnfitz -- sorted list insert

    // first check to see if it has already been defined
    if (Cvar_FindVar(variable->name)) {
        Con_Printf("Can't register variable %s, already defined\n", variable->name);
        return;
    }

    // check for overlap with a command
    if (Cmd_Exists(variable->name)) {
        Con_Printf("Cvar_RegisterVariable: %s is a command\n", variable->name);
        return;
    }

   CLIENT_VARIABLES.emplace(std::string(variable->name), variable);

    //johnfitz
    variable->flags |= CVAR_REGISTERED;

    // copy the value off, because future sets will Z_Free it
    std::strncpy(value, variable->string, sizeof(value));
    variable->string = NULL;
    variable->default_string = NULL;

    if (!(variable->flags & CVAR_CALLBACK))
        variable->callback = NULL;

    // set it through the function to be consistent
    set_rom = (variable->flags & CVAR_ROM);
    variable->flags &= ~CVAR_ROM;
    Cvar_SetQuick(variable, value);
    if (set_rom)
        variable->flags |= CVAR_ROM;
}

/*
============
Cvar_SetCallback

Set a callback function to the var
============
*/
void Cvar_SetCallback(cvar_t *var, cvarcallback_t func) {
    var->callback = func;
    if (func)
        var->flags |= CVAR_CALLBACK;
    else var->flags &= ~CVAR_CALLBACK;
}

/*
============
Cvar_Command

Handles variable inspection and changing from the console
============
*/
qboolean Cvar_Command() {
    // check variables
    auto var = Cvar_FindVar(Cmd_Argv(0));
    if (!var.has_value())
        return false;

    // perform a variable print or set
    if (Cmd_Argc() == 1) {
        Con_Printf("\"%s\" is \"%s\"\n", var.value()->name, var.value()->string);
        return true;
    }

    Cvar_Set(var.value()->name, Cmd_Argv(1));
    return true;
}


/*
============
Cvar_WriteVariables

Writes lines containing "set variable value" for all variables
with the archive flag set to true.
============
*/
void Cvar_WriteVariables(FILE *f) {
    for (const auto &[name, var] : CLIENT_VARIABLES) {
        if (var->flags & CVAR_ARCHIVE)
            fprintf(f, "%s \"%s\"\n", name.c_str(), var->string);
    }
}