void Cvar_Set_ex_f (void)
{
cvar_t *var;
char *var_name;
char *st = NULL;
char text_exp[1024];
if (Cmd_Argc() != 3) {
Com_Printf ("usage: set_ex <cvar> <value>\n");
return;
}
var_name = Cmd_Argv (1);
var = Cvar_Find (var_name);
if ( !var ) {
if (Cmd_Exists(var_name)) {
Com_Printf ("\"%s\" is a command\n", var_name);
return;
}
var = Cvar_Create(var_name, "", 0);
}
Cmd_ExpandString( Cmd_Argv(2), text_exp);
st = TP_ParseMacroString( text_exp );
st = TP_ParseFunChars(st, false);
Cvar_Set (var, st );
}
void Cvar_Set_tp_f (void)
{
cvar_t *var;
char *var_name;
if (Cmd_Argc() != 3) {
Com_Printf ("Usage: %s <cvar> <value>\n", Cmd_Argv(0));
return;
}
var_name = Cmd_Argv (1);
var = Cvar_Find (var_name);
if (var) {
if (!var->teamplay) {
Com_Printf("\"%s\" is not a teamplay variable\n", var->name);
return;
} else {
Cvar_Set (var, Cmd_Argv(2));
}
} else {
if (Cmd_Exists(var_name)) {
Com_Printf ("\"%s\" is a command\n", var_name);
return;
}
var = Cvar_Create (var_name, Cmd_Argv(2), 0);
var->teamplay = true;
}
}
/*
============
Cvar_Value
============
*/
float Cvar_Value (const char *name)
{
cvar_t *var = Cvar_Find (name);
if (!var)
return 0;
return Q_atof (var->string);
}
/*
============
Cmd_AddCommand
============
*/
void Cmd_AddCommand (const char *cmd_name, xcommand_t function)
{
cmd_function_t *cmd;
int key;
if (host_initialized) // because hunk allocation would get stomped
Sys_Error ("Cmd_AddCommand after host_initialized");
// fail if the command is a variable name
if (Cvar_Find(cmd_name))
{
Con_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
return;
}
key = Com_HashKey (cmd_name);
// fail if the command already exists
for (cmd=cmd_hash_array[key] ; cmd ; cmd=cmd->hash_next)
{
if (!strcasecmp (cmd_name, cmd->name))
{
Con_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
return;
}
}
cmd = (cmd_function_t *) Hunk_Alloc (sizeof(cmd_function_t));
cmd->name = cmd_name;
cmd->function = function;
cmd->next = cmd_functions;
cmd_functions = cmd;
cmd->hash_next = cmd_hash_array[key];
cmd_hash_array[key] = cmd;
}
/*
* Cvar_String
* Returns an empty string if not defined
*/
const char *Cvar_String( const char *var_name )
{
const cvar_t *const var = Cvar_Find( var_name );
return var
? var->string
: "";
}
cvar_t *Cvar_Create (char *name, char *string, int cvarflags)
{
cvar_t *v;
int key;
if ((v = Cvar_Find(name))) {
v->flags &= ~CVAR_TEMP;
v->flags |= cvarflags;
return v;
}
v = (cvar_t *) Q_malloc(sizeof(cvar_t));
memset(v, 0, sizeof(cvar_t));
// Cvar doesn't exist, so we create it
v->next = cvar_vars;
cvar_vars = v;
key = Com_HashKey (name) % VAR_HASHPOOL_SIZE;
v->hash_next = cvar_hash[key];
cvar_hash[key] = v;
v->name = Q_strdup(name);
v->string = Q_strdup(string);
v->defaultvalue = Q_strdup(string);
v->flags = cvarflags | CVAR_USER_CREATED;
v->value = Q_atof (v->string);
v->integer = Q_atoi (v->string);
StringToRGB_W(v->string, v->color);
v->modified = true;
#ifdef WITH_TCL
TCL_RegisterVariable (v);
#endif
return v;
}
/*
* Cvar_Integer
* Returns 0 if not defined or non numeric
*/
int Cvar_Integer( const char *var_name )
{
const cvar_t *const var = Cvar_Find( var_name );
return var
? var->integer
: 0;
}
/*
============
Cvar_String
============
*/
const char *Cvar_String (const char *name)
{
cvar_t *var = Cvar_Find (name);
if (!var)
return "";
return var->string;
}
void Cvar_Inc_f (void)
{
int c;
cvar_t *var;
float delta;
c = Cmd_Argc();
if (c != 2 && c != 3) {
Com_Printf ("inc <cvar> [value]\n");
return;
}
var = Cvar_Find (Cmd_Argv(1));
if (!var) {
Com_Printf ("Unknown variable \"%s\"\n", Cmd_Argv(1));
return;
}
if (c == 3)
delta = atof (Cmd_Argv(2));
else
delta = 1;
Cvar_SetValue (var, var->value + delta);
}
void Cvar_Set_f (void)
{
cvar_t *var;
const char *name;
if (Cmd_Argc() != 3)
{
Com_Printf ("usage: set <cvar> <value>\n");
return;
}
name = Cmd_Argv (1);
var = Cvar_Find (name);
if (var)
{
Cvar_Set (var, Cmd_Argv(2));
}
else
{
if (Cmd_Exists(name))
{
Com_Printf ("\"%s\" is a command\n", name);
return;
}
var = Cvar_Get (name, Cmd_Argv(2), 0);
}
if (cvar_seta)
var->flags |= CVAR_USER_ARCHIVE;
}
/*
===========
Cvar_Get
===========
*/
cvar_t *Cvar_Get (const char *name, const char *string, int cvarflags)
{
cvar_t *var;
int key;
var = Cvar_Find(name);
if (var) {
var->flags &= ~CVAR_TEMP;
var->flags |= cvarflags;
return var;
}
// allocate a new cvar
var = (cvar_t *) Q_malloc (sizeof(cvar_t));
// link it in
var->next = cvar_vars;
cvar_vars = var;
key = Com_HashKey (name);
var->hash_next = cvar_hash[key];
cvar_hash[key] = var;
// Q_malloc returns unitialized memory, so make sure all fields
// are initialized here
var->name = Q_strdup (name);
var->string = Q_strdup (string);
var->flags = cvarflags | CVAR_DYNAMIC;
var->value = Q_atof (var->string);
var->OnChange = NULL;
// FIXME, check userinfo/serverinfo
return var;
}
/*
* Cvar_Value
* Returns 0 if not defined or non numeric
*/
float Cvar_Value( const char *var_name )
{
const cvar_t *const var = Cvar_Find( var_name );
return var
? atof( var->string )
: 0;
}
/*
============
Cvar_Register
Adds a freestanding variable to the variable list.
If the variable already exists, the value will not be set
The flags will be or'ed in if the variable exists.
============
*/
EXTERNC void Cvar_Register (cvar_t *var)
{
char string[512];
int key;
cvar_t *old;
// first check to see if it has already been defined
old = Cvar_Find (var->name);
if (old && !(old->flags & CVAR_DYNAMIC)) {
if (old == var)
return;
Com_Printf ("Can't register variable %s, already defined\n", var->name);
return;
}
#if 0
// check for overlap with a command
if (Cmd_Exists (var->name)) {
Com_Printf ("Cvar_Register: %s is a command\n", var->name);
return;
}
#endif
if (old)
{
var->flags |= old->flags & ~(CVAR_DYNAMIC|CVAR_TEMP);
strlcpy (string, old->string, sizeof(string));
Cvar_Delete (old->name);
if (!(var->flags & CVAR_ROM))
var->string = Q_strdup (string);
else
var->string = Q_strdup (var->string);
}
else
{
// allocate the string on heap because future sets will Q_free it
var->string = Q_strdup (var->string);
}
var->value = Q_atof (var->string);
// link the variable in
key = Com_HashKey (var->name);
var->hash_next = cvar_hash[key];
cvar_hash[key] = var;
var->next = cvar_vars;
cvar_vars = var;
#ifndef CLIENTONLY
if (var->flags & CVAR_SERVERINFO)
SV_ServerinfoChanged (var->name, var->string);
#endif
#ifndef SERVERONLY
if (var->flags & CVAR_USERINFO)
CL_UserinfoChanged (var->name, var->string);
#endif
}
char *Cvar_String (char *var_name)
{
cvar_t *var = Cvar_Find (var_name);
if (!var)
return "";
return var->string;
}
void MP3_WINAMP_Init(void)
{
if (host_initialized && Cvar_Find(mp3_dir.name))
return;
Cvar_SetCurrentGroup(CVAR_GROUP_MP3);
Cvar_Register(&mp3_dir);
Cvar_ResetCurrentGroup();
}
//Examine or change the serverinfo string
void SV_Serverinfo_f (void) {
cvar_t *var;
char *key, *value;
if (Cmd_Argc() == 1) {
Com_Printf ("Server info settings:\n");
Info_Print (svs.info);
Com_Printf ("[%i/%i]\n", strlen(svs.info), MAX_SERVERINFO_STRING);
return;
}
if (Cmd_Argc() != 3) {
Com_Printf ("Usage: serverinfo [ <key> <value> ]\n");
return;
}
key = Cmd_Argv(1);
value = Cmd_Argv(2);
if (key[0] == '*') {
Com_Printf ("Star variables cannot be changed.\n");
return;
}
if (!strcmp(key, "maxpitch") || !strcmp(Cmd_Argv(1), "minpitch")) {
Cvar_Set (Cvar_Find(va("sv_%s", Cmd_Argv(1))), Cmd_Argv(2));
return; // cvar callbacks will take care of updating serverinfo
}
Info_SetValueForKey (svs.info, key, value, MAX_SERVERINFO_STRING);
// if this is a cvar, change it too
var = Cvar_Find (key);
if (var && (var->flags & CVAR_SERVERINFO)) {
// a hack - strip the serverinfo flag so that the Cvar_Set
// doesn't trigger SV_ServerinfoChanged
var->flags &= ~CVAR_SERVERINFO;
Cvar_Set (var, Cmd_Argv(2));
var->flags |= CVAR_SERVERINFO; // put it back
}
// FIXME, don't send if the key hasn't changed
SV_SendServerInfoChange (key, value);
}
void Cvar_SetByName (char *var_name, char *value)
{
cvar_t *var;
var = Cvar_Find (var_name);
if (!var)
{ // there is an error in C code if this happens
Com_DPrintf ("Cvar_Set: variable %s not found\n", var_name);
return;
}
Cvar_Set (var, value);
}
qbool Cvar_Command (void)
{
cvar_t *v;
// check variables
if (!(v = Cvar_Find (Cmd_Argv(0))))
return false;
if (Cmd_Argc() == 1) {
if (cvar_viewhelp.value)
Help_DescribeCvar (v);
if (cvar_viewdefault.value) {
char *spaces = CreateSpaces(strlen(v->name) + 2);
Com_Printf ("%s : default value is \"%s\"\n", v->name, v->defaultvalue);
Com_Printf ("%s current value is \"%s\"\n", spaces, v->string);
if ((v->flags & CVAR_AUTO) && v->autoString) {
Com_Printf ("%s auto value is \"%s\"\n", spaces, v->autoString);
}
if (cvar_viewlatched.integer && v->latchedString) {
Com_Printf ("%s latched value is \"%s\"\n", spaces, v->latchedString);
}
} else {
Com_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
if ((v->flags & CVAR_AUTO) && v->autoString) {
Com_Printf ("auto: \"%s\"\n", v->autoString);
}
if (cvar_viewlatched.integer && v->latchedString) {
Com_Printf ("latched: \"%s\"\n", v->latchedString);
}
}
} else {
// RestrictTriggers means that advanced (possibly cheaty) scripts are not allowed
// So we will force the usage of user-created variables to go through the set command
if ((v->flags & CVAR_USER_CREATED) && Rulesets_RestrictTriggers()) {
Com_Printf ("Current ruleset requires \"set\" with user created variables\n");
return true;
}
Cvar_Set (v, Cmd_MakeArgs(1));
}
return true;
}
void MS_Console_Add_Content_Slider(void)
{
cvar_t *c = NULL;
c = Cvar_Find(Cmd_Argv(4));
if (!c)
return;
if (strlen(Cmd_Argv(2)))
MS_Add_Content_Slider(Cmd_Argv(1),Cmd_Argv(2),Cmd_Argv(3),1,1,NULL,c,-100,100);
else
MS_Add_Content_Slider(Cmd_Argv(1),NULL,Cmd_Argv(3),1,1,NULL,c,-100,100);
}
void Cvar_Set_Bind_Str_f (void)
{
cvar_t *var;
int keynum;
char *var_name;
char *key_name;
//char str[1024];
//char *v,*s;
if (Cmd_Argc() != 3) {
Com_Printf ("usage: set_bind_str <cvar> <key>\n");
return;
}
var_name = Cmd_Argv (1);
key_name = Cmd_Argv (2);
var = Cvar_Find (var_name);
keynum = Key_StringToKeynum( key_name );
if ( !var) {
if (Cmd_Exists(var_name)) {
Com_Printf ("\"%s\" is a command\n", var_name);
return;
}
var = Cvar_Create(var_name, "", 0);
}
if (!var) {
Com_Printf ("Unknown variable \"%s\"\n", var_name);
return;
} else if (keynum == -1) {
Com_Printf ("Unknown key \"%s\"\n", key_name);
return;
} else {
if (keybindings[keynum]) {
/* s = str; v = keybindings[keynum];
while (*v) {
if (*v == '\"') // " should be escaped
*s++ = '\\';
*s++ = *v++;
}
*s = '\0';
Cvar_Set (var, str);*/
Cvar_Set (var, keybindings[keynum]);
} else
Cvar_Set (var, "");
}
}
// disconnect -->
void Cvar_UnSet (qbool use_regex)
{
cvar_t *var, *next;
char *name;
int i;
qbool re_search = false;
if (Cmd_Argc() < 2) {
Com_Printf ("unset <cvar> [<cvar2>..]: erase user-created variable\n");
return;
}
for (i=1; i<Cmd_Argc(); i++) {
name = Cmd_Argv(i);
if (use_regex && (re_search = IsRegexp(name)))
if(!ReSearchInit(name))
continue;
if (use_regex && re_search) {
for (var = cvar_vars ; var ; var = next) {
next = var->next;
if (ReSearchMatch(var->name)) {
if (var->flags & CVAR_USER_CREATED) {
Cvar_Delete(var->name);
} else {
Com_Printf("Can't delete not user created cvars (\"%s\")\n", var->name);
}
}
}
} else {
if (!(var = Cvar_Find(name))) {
Com_Printf("Can't delete \"%s\": no such cvar\n", name);
continue;
}
if (var->flags & CVAR_USER_CREATED) {
Cvar_Delete(name);
} else {
Com_Printf("Can't delete not user created cvars (\"%s\")\n", name);
}
}
if (use_regex && re_search)
ReSearchDone();
}
}
static void Cvar_Reset_f( void )
{
cvar_t *v;
if( Cmd_Argc() != 2 )
{
Com_Printf( "usage: reset <variable>\n" );
return;
}
v = Cvar_Find( Cmd_Argv( 1 ) );
if( !v )
return;
Cvar_Set( v->name, v->dvalue );
}
void Cvar_Set_Eval_f(void)
{
if (Cmd_Argc() < 3) {
Com_Printf("Usage:\n"
"set_eval <variable> <expression>\n"
"set_eval is similar to set_calc but supports richer expressions\n");
return;
}
else {
const char *expression;
char *var_name;
cvar_t *var;
int errn;
expr_val result;
var_name = Cmd_Argv (1);
var = Cvar_Find (var_name);
if (!var)
var = Cvar_Create (var_name, Cmd_Argv (1), 0);
expression = Cmd_MakeArgs(2);
result = Expr_Eval(expression, NULL, &errn);
if (errn == EXPR_EVAL_SUCCESS) {
switch (result.type) {
case ET_INT:
Cvar_SetValue(var, result.i_val);
break;
case ET_DBL:
Cvar_SetValue(var, result.d_val);
break;
case ET_BOOL:
Cvar_SetValue(var, result.b_val ? 1 : 0);
break;
case ET_STR:
Cvar_Set(var, result.s_val);
free(result.s_val);
break;
}
}
else {
Com_Printf("Error in expression: %s\n", Parser_Error_Description(errn));
}
}
}
/*
============
Cvar_Command
Handles variable inspection and changing from the console
============
*/
qbool Cvar_Command (void)
{
cvar_t *var;
// check variables
var = Cvar_Find (Cmd_Argv(0));
if (!var)
return false;
// perform a variable print or set
if (Cmd_Argc() == 1)
{
Com_Printf ("\"%s\" is \"%s\"\n", var->name, var->string);
return true;
}
Cvar_Set (var, Cmd_MakeArgs(1));
return true;
}
/*
=============
Cvar_Toggle_f
=============
*/
void Cvar_Toggle_f (void)
{
cvar_t *var;
if (Cmd_Argc() != 2)
{
Com_Printf ("toggle <cvar> : toggle a cvar on/off\n");
return;
}
var = Cvar_Find (Cmd_Argv(1));
if (!var)
{
Com_Printf ("Unknown variable \"%s\"\n", Cmd_Argv(1));
return;
}
Cvar_Set (var, var->value ? "0" : "1");
}
void Cvar_Set_Alias_Str_f (void)
{
cvar_t *var;
char *var_name;
char *alias_name;
//char str[1024];
char *v /*,*s*/;
if (Cmd_Argc() != 3) {
Com_Printf ("usage: set_alias_str <cvar> <alias>\n");
return;
}
var_name = Cmd_Argv (1);
alias_name = Cmd_Argv (2);
var = Cvar_Find (var_name);
v = Cmd_AliasString( alias_name );
if ( !var) {
if (Cmd_Exists(var_name)) {
Com_Printf ("\"%s\" is a command\n", var_name);
return;
}
var = Cvar_Create(var_name, "", 0);
}
if (!var) {
Com_Printf ("Unknown variable \"%s\"\n", var_name);
return;
} else if (!v) {
Com_Printf ("Unknown alias \"%s\"\n", alias_name);
return;
} else {
/* s = str;
while (*v) {
if (*v == '\"') // " should be escaped
*s++ = '\\';
*s++ = *v++;
}
*s = '\0';
Cvar_Set (var, str);*/
Cvar_Set (var, v);
}
}
int CvarContainer_RegisterVar(const char *containerClass, const char *varName)
{
cvarContainerClass_t *con;
cvar_t *var;
unsigned int n;
con = CvarContainer_FindClass(containerClass);
if (!con)
{
Console_DPrintf("CvarContainer_RegisterVar: class %s does not exist\n", containerClass);
return 0;
}
if (con->num_vars >= CVAR_CONTAINER_CLASS_MAX_VARS)
{
Console_DPrintf("CvarContainer_RegisterVar: number of vars in %s exceeds CVAR_CONTAINER_CLASS_MAX_VARS\n", containerClass);
return 0;
}
var = Cvar_Find(varName);
if (!var)
{
Console_DPrintf("CvarContainer_RegisterVar: variable %s does not exist\n", varName);
return 0;
}
for (n=0; n<con->num_vars; n++)
{
if (con->vars[n] == var)
{
Console_DPrintf("CvarContainer_RegisterVar: variable %s was already registered with the container class %s\n", varName, containerClass);
return 0;
}
}
con->vars[con->num_vars] = var;
con->num_vars++;
return con->num_vars;
}
static void Cvar_Toggle_f_base (qbool use_regex)
{
qbool re_search = false;
cvar_t *var;
char *name;
int i;
if (Cmd_Argc() < 2) {
Com_Printf("%s <cvar> [<cvar>..]: toggle a cvar on/off\n", Cmd_Argv(0));
return;
}
for (i=1; i<Cmd_Argc(); i++) {
name = Cmd_Argv(i);
if (use_regex && (re_search = IsRegexp(name)))
if(!ReSearchInit(name))
continue;
if (use_regex && re_search) {
for (var = cvar_vars ; var ; var=var->next) {
if (ReSearchMatch(var->name)) {
Cvar_Set (var, var->value ? "0" : "1");
}
}
} else {
var = Cvar_Find (name);
if (!(var)) {
Com_Printf ("Unknown variable \"%s\"\n", Cmd_Argv(1));
continue;
}
Cvar_Set (var, var->value ? "0" : "1");
}
if (use_regex && re_search)
ReSearchDone();
}
}
/*
* Cvar_Toggle_f
*/
static void Cvar_Toggle_f( void )
{
int i;
cvar_t *var;
if( Cmd_Argc() < 2 )
{
Com_Printf( "Usage: toggle <list of variables>\n" );
return;
}
for( i = 1; i < Cmd_Argc(); i++ )
{
var = Cvar_Find( Cmd_Argv( i ) );
if( !var )
{
Com_Printf( "No such variable: \"%s\"\n", Cmd_Argv( i ) );
return;
}
Cvar_Set( var->name, var->integer ? "0" : "1" );
}
}
void Cvar_Reset (qbool use_regex)
{
qbool re_search = false;
cvar_t *var;
char *name;
int i;
if (Cmd_Argc() < 2) {
Com_Printf("%s <cvar> [<cvar2>..]: reset variable to it default value\n", Cmd_Argv(0));
return;
}
for (i=1; i<Cmd_Argc(); i++) {
name = Cmd_Argv(i);
if (use_regex && (re_search = IsRegexp(name)))
if(!ReSearchInit(name))
continue;
if (use_regex && re_search) {
for (var = cvar_vars ; var ; var=var->next) {
if (ReSearchMatch(var->name)) {
Cvar_ResetVar(var);
}
}
} else {
if ((var = Cvar_Find(name)))
Cvar_ResetVar(var);
else
Com_Printf("%s : No variable with name %s\n", Cmd_Argv(0), name);
}
if (use_regex && re_search)
ReSearchDone();
}
}
