This allows cvars to be renamed, and keep the old cvar by pointing it to
the new one. Pretty much every cvar finding function has been adapted to
return a the aliased cvar or the alias itself depending on context.
For example, if a value is needed, it'll dereference the alias. If the
cvar is needed to be listed somewhere or to check if the cvar merely
exists, it will not. Other than that, it's pretty straightforward.
git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@12643
d7cf8633-e32d-0410-b094-
e92efae38249
15 files changed:
CL_ClientMovement_Physics_Walk(s);
}
CL_ClientMovement_Physics_Walk(s);
}
+extern cvar_t host_timescale;
void CL_UpdateMoveVars(void)
{
if (cls.protocol == PROTOCOL_QUAKEWORLD)
void CL_UpdateMoveVars(void)
{
if (cls.protocol == PROTOCOL_QUAKEWORLD)
- cl.movevars_ticrate = (cls.demoplayback ? 1.0f : slowmo.value) / bound(1.0f, cl_netfps.value, 1000.0f);
- cl.movevars_timescale = (cls.demoplayback ? 1.0f : slowmo.value);
+ cl.movevars_ticrate = (cls.demoplayback ? 1.0f : host_timescale.value) / bound(1.0f, cl_netfps.value, 1000.0f);
+ cl.movevars_timescale = (cls.demoplayback ? 1.0f : host_timescale.value);
cl.movevars_gravity = sv_gravity.value;
cl.movevars_stopspeed = cl_movement_stopspeed.value;
cl.movevars_maxspeed = cl_movement_maxspeed.value;
cl.movevars_gravity = sv_gravity.value;
cl.movevars_stopspeed = cl_movement_stopspeed.value;
cl.movevars_maxspeed = cl_movement_maxspeed.value;
+extern cvar_t host_timescale;
extern cvar_t cl_lerpexcess;
static void CL_NetworkTimeReceived(double newtime)
{
extern cvar_t cl_lerpexcess;
static void CL_NetworkTimeReceived(double newtime)
{
char overridename[MAX_QPATH];
cvar_t *langcvar;
char overridename[MAX_QPATH];
cvar_t *langcvar;
- langcvar = Cvar_FindVar(&cvars_all, "language", CVAR_CLIENT | CVAR_SERVER);
+ langcvar = Cvar_FindVar(&cvars_all, "language", CVAR_CLIENT | CVAR_SERVER, false);
subtitle_text = NULL;
if (langcvar)
{
subtitle_text = NULL;
if (langcvar)
{
else
{ // Correct Arguments Specified
// Acquire Potential CVar
else
{ // Correct Arguments Specified
// Acquire Potential CVar
- cvar_t* cvCVar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 1), cmd->cvars_flagsmask);
+ cvar_t* cvCVar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 1), cmd->cvars_flagsmask, false);
if(cvCVar != NULL)
{ // Valid CVar
if(cvCVar != NULL)
{ // Valid CVar
- if((cvar = Cvar_FindVar(cmd->cvars, varname, cmd->cvars_flagsmask)) && !(cvar->flags & CVAR_PRIVATE))
+ if((cvar = Cvar_FindVar(cmd->cvars, varname, cmd->cvars_flagsmask, false)) && !(cvar->flags & CVAR_PRIVATE))
return cvar->string;
return NULL;
return cvar->string;
return NULL;
cmd_function_t *prev, *current;
// fail if the command is a variable name
cmd_function_t *prev, *current;
// fail if the command is a variable name
- if (Cvar_FindVar(cmd->cvars, cmd_name, ~0))
+ if (Cvar_FindVar(cmd->cvars, cmd_name, ~0, true))
{
Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
return;
{
Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
return;
Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
Cmd_CompleteCommandPrint(cmd, s);
}
Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
Cmd_CompleteCommandPrint(cmd, s);
}
- v = Cvar_CompleteCountPossible(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER);
+ v = Cvar_CompleteCountPossible(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER | CVAR_ALIAS);
if (v)
{
Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
if (v)
{
Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
- Cvar_CompleteCvarPrint(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER);
+ Cvar_CompleteCvarPrint(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER | CVAR_ALIAS);
}
a = Cmd_CompleteAliasCountPossible(cmd, s);
if (a)
}
a = Cmd_CompleteAliasCountPossible(cmd, s);
if (a)
Cvar_FindVar
============
*/
Cvar_FindVar
============
*/
-cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags)
+cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags, qboolean alias)
{
int hashindex;
cvar_t *var;
{
int hashindex;
cvar_t *var;
// use hash lookup to minimize search time
hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
for (var = cvars->hashtable[hashindex];var;var = var->nextonhashchain)
// use hash lookup to minimize search time
hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
for (var = cvars->hashtable[hashindex];var;var = var->nextonhashchain)
- if (!strcmp (var_name, var->name) && (var->flags & neededflags))
+ if (!strcmp (var_name, var->name))
+ {
+ if(!alias && var->alias)
+ return var->alias;
- var = Cvar_FindVar(cvars, prev_var_name, neededflags);
+ var = Cvar_FindVar(cvars, prev_var_name, neededflags, false);
if (!var)
return NULL;
var = var->next;
if (!var)
return NULL;
var = var->next;
- var = Cvar_FindVar(cvars, var_name, neededflags);
+ var = Cvar_FindVar(cvars, var_name, neededflags, false);
if (!var)
return def;
return atof (var->string);
if (!var)
return def;
return atof (var->string);
- var = Cvar_FindVar(cvars, var_name, neededflags);
+ var = Cvar_FindVar(cvars, var_name, neededflags, false);
if (!var)
return def;
return var->string;
if (!var)
return def;
return var->string;
- var = Cvar_FindVar(cvars, var_name, neededflags);
+ var = Cvar_FindVar(cvars, var_name, neededflags, false);
if (!var)
return cvar_null_string;
return var->defstring;
if (!var)
return cvar_null_string;
return var->defstring;
- var = Cvar_FindVar(cvars, var_name, neededflags);
+ var = Cvar_FindVar(cvars, var_name, neededflags, false);
if (!var)
return cvar_null_string;
return var->description;
if (!var)
return cvar_null_string;
return var->description;
void Cvar_PrintHelp(cvar_t *cvar, qboolean full)
{
void Cvar_PrintHelp(cvar_t *cvar, qboolean full)
{
- Con_Printf("^3%s^7 is \"%s\" [\"%s\"] ", cvar->name, ((cvar->flags & CVAR_PRIVATE) ? "********"/*hunter2*/ : cvar->string), cvar->defstring);
+ cvar_t *cvar_actual;
+
+ Con_Printf("^3%s^7", cvar->name);
+ if(cvar->alias) {
+ cvar_actual = cvar->alias;
+ Con_Printf(" (now ^3%s^7)", cvar_actual->name);
+ } else {
+ cvar_actual = cvar;
+ }
+
+ Con_Printf(" is \"%s\" [\"%s\"] ", ((cvar_actual->flags & CVAR_PRIVATE) ? "********"/*hunter2*/ : cvar_actual->string), cvar_actual->defstring);
+
- Con_Printf("%s", cvar->description);
+ Con_Printf("%s", cvar_actual->description);
char vabuf[1024];
char new_value[MAX_INPUTLINE];
char vabuf[1024];
char new_value[MAX_INPUTLINE];
+ if(var->alias)
+ var = var->alias;
+
changed = strcmp(var->string, value) != 0;
// LadyHavoc: don't reallocate when there is no change
if (!changed)
changed = strcmp(var->string, value) != 0;
// LadyHavoc: don't reallocate when there is no change
if (!changed)
void Cvar_Set(cvar_state_t *cvars, const char *var_name, const char *value)
{
cvar_t *var;
void Cvar_Set(cvar_state_t *cvars, const char *var_name, const char *value)
{
cvar_t *var;
- var = Cvar_FindVar(cvars, var_name, ~0);
+ var = Cvar_FindVar(cvars, var_name, ~0, false);
if (var == NULL)
{
Con_Printf("Cvar_Set: variable %s not found\n", var_name);
if (var == NULL)
{
Con_Printf("Cvar_Set: variable %s not found\n", var_name);
Cvar_Set(cvars, var_name, val);
}
Cvar_Set(cvars, var_name, val);
}
-void Cvar_RegisterCallback(cvar_t *variable, void (*callback)(char *))
+void Cvar_RegisterCallback(cvar_t *var, void (*callback)(char *))
- variable->callback = callback;
+ var->callback = callback;
+}
+
+void Cvar_RegisterAlias(cvar_t *alias, cvar_t *target)
+{
+ if(!(alias->flags & CVAR_ALIAS)) {
+ Con_Warnf("Cvar_RegisterAlias: \"%s\" is not declared as an alias\n", alias->name);
+ return;
+ }
+ // We'll want to register it first
+ Cvar_RegisterVariable(alias);
+
+ alias->alias = target;
- switch (variable->flags & (CVAR_CLIENT | CVAR_SERVER))
+ if(!(variable->flags & CVAR_ALIAS))
+ {
+ switch (variable->flags & (CVAR_CLIENT | CVAR_SERVER))
+ {
+ case CVAR_CLIENT:
+ case CVAR_SERVER:
+ case CVAR_CLIENT | CVAR_SERVER:
+ cvars = &cvars_all;
+ break;
+ case 0:
+ Sys_Error("Cvar_RegisterVariable({\"%s\", \"%s\", %i}) with no CVAR_CLIENT | CVAR_SERVER flags\n", variable->name, variable->string, variable->flags);
+ break;
+ default:
+ Sys_Error("Cvar_RegisterVariable({\"%s\", \"%s\", %i}) with weird CVAR_CLIENT | CVAR_SERVER flags\n", variable->name, variable->string, variable->flags);
+ break;
+ }
+ }
+ else
- case CVAR_CLIENT:
- case CVAR_SERVER:
- case CVAR_CLIENT | CVAR_SERVER:
- break;
- case 0:
- Sys_Error("Cvar_RegisterVariable({\"%s\", \"%s\", %i}) with no CVAR_CLIENT | CVAR_SERVER flags\n", variable->name, variable->string, variable->flags);
- break;
- default:
- Sys_Error("Cvar_RegisterVariable({\"%s\", \"%s\", %i}) with weird CVAR_CLIENT | CVAR_SERVER flags\n", variable->name, variable->string, variable->flags);
- break;
if (developer_extra.integer)
Con_DPrintf("Cvar_RegisterVariable({\"%s\", \"%s\", %i});\n", variable->name, variable->string, variable->flags);
// first check to see if it has already been defined
if (developer_extra.integer)
Con_DPrintf("Cvar_RegisterVariable({\"%s\", \"%s\", %i});\n", variable->name, variable->string, variable->flags);
// first check to see if it has already been defined
- cvar = Cvar_FindVar(cvars, variable->name, ~0);
+ cvar = Cvar_FindVar(cvars, variable->name, ~0, true);
if (cvar)
{
if (cvar->flags & CVAR_ALLOCATED)
if (cvar)
{
if (cvar->flags & CVAR_ALLOCATED)
Con_Printf("Cvar_RegisterVariable: %s is a command\n", variable->name);
return;
}
Con_Printf("Cvar_RegisterVariable: %s is a command\n", variable->name);
return;
}
-
-// copy the value off, because future sets will Z_Free it
- oldstr = (char *)variable->string;
- alloclen = strlen(variable->string) + 1;
- variable->string = (char *)Z_Malloc (alloclen);
- memcpy ((char *)variable->string, oldstr, alloclen);
- variable->defstring = (char *)Z_Malloc (alloclen);
- memcpy ((char *)variable->defstring, oldstr, alloclen);
- variable->value = atof (variable->string);
- variable->integer = (int) variable->value;
+ if(!(variable->flags & CVAR_ALIAS))
+ {
+ // copy the value off, because future sets will Z_Free it
+ oldstr = (char *)variable->string;
+ alloclen = strlen(variable->string) + 1;
+ variable->string = (char *)Z_Malloc (alloclen);
+ memcpy ((char *)variable->string, oldstr, alloclen);
+ variable->defstring = (char *)Z_Malloc (alloclen);
+ memcpy ((char *)variable->defstring, oldstr, alloclen);
+ variable->value = atof (variable->string);
+ variable->integer = (int) variable->value;
+ }
// Mark it as not an autocvar.
for (i = 0;i < PRVM_PROG_MAX;i++)
// Mark it as not an autocvar.
for (i = 0;i < PRVM_PROG_MAX;i++)
Con_DPrintf("Cvar_Get(\"%s\", \"%s\", %i);\n", name, value, flags);
// first check to see if it has already been defined
Con_DPrintf("Cvar_Get(\"%s\", \"%s\", %i);\n", name, value, flags);
// first check to see if it has already been defined
- cvar = Cvar_FindVar(cvars, name, ~0);
+ cvar = Cvar_FindVar(cvars, name, ~0, true);
if (cvar)
{
cvar->flags |= flags;
if (cvar)
{
cvar->flags |= flags;
+qboolean Cvar_Readonly (cvar_t *var, const char *cmd_name)
+{
+ if (var->flags & CVAR_READONLY || (var->alias && (var->alias->flags & CVAR_READONLY)))
+ {
+ if(cmd_name)
+ Con_Printf("%s: ",cmd_name);
+ Con_Printf("%s", var->name);
+ if (var->alias && var->alias->name)
+ Con_Printf(" (from %s)",var->alias->name);
+ Con_Printf(" is read-only\n");
+ return true;
+ }
+ return false;
+}
cvar_t *v;
// check variables
cvar_t *v;
// check variables
- v = Cvar_FindVar(cvars, Cmd_Argv(cmd, 0), cmd->cvars_flagsmask);
+ v = Cvar_FindVar(cvars, Cmd_Argv(cmd, 0), (cmd->cvars_flagsmask), true);
if (developer_extra.integer)
Con_DPrint("Cvar_Command: ");
if (developer_extra.integer)
Con_DPrint("Cvar_Command: ");
-
- if (v->flags & CVAR_READONLY)
- {
- Con_Printf("%s is read-only\n", v->name);
+
+ if(Cvar_Readonly(v, NULL))
Cvar_SetQuick(v, Cmd_Argv(cmd, 1));
if (developer_extra.integer)
Con_DPrint("\n");
Cvar_SetQuick(v, Cmd_Argv(cmd, 1));
if (developer_extra.integer)
Con_DPrint("\n");
cvar_t *var;
// unlock the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
cvar_t *var;
// unlock the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
+ {
+ if(var->flags & CVAR_ALIAS)
+ continue;
var->flags &= ~CVAR_DEFAULTSET;
var->flags &= ~CVAR_DEFAULTSET;
// lock in the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
{
// lock in the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
{
+ if(var->flags & CVAR_ALIAS)
+ continue;
if (!(var->flags & CVAR_DEFAULTSET))
{
size_t alloclen;
if (!(var->flags & CVAR_DEFAULTSET))
{
size_t alloclen;
cvar_t *c;
for (c = cvars->vars;c;c = c->next)
{
cvar_t *c;
for (c = cvars->vars;c;c = c->next)
{
+ if(c->flags & CVAR_ALIAS)
+ continue;
c->initstate = true;
c->initflags = c->flags;
c->initdefstring = Mem_strdup(zonemempool, c->defstring);
c->initstate = true;
c->initflags = c->flags;
c->initdefstring = Mem_strdup(zonemempool, c->defstring);
cvar_t *c2, **cp2;
for (cp = &cvars->vars;(c = *cp);)
{
cvar_t *c2, **cp2;
for (cp = &cvars->vars;(c = *cp);)
{
+ if(c->flags & CVAR_ALIAS)
+ continue;
if (c->initstate)
{
// restore this cvar, it existed at init
if (c->initstate)
{
// restore this cvar, it existed at init
cvar_t *var;
// restore the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
cvar_t *var;
// restore the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
+ {
+ if(var->flags & CVAR_ALIAS)
+ continue;
if((var->flags & CVAR_NORESETTODEFAULTS) == 0)
Cvar_SetQuick(var, var->defstring);
if((var->flags & CVAR_NORESETTODEFAULTS) == 0)
Cvar_SetQuick(var, var->defstring);
cvar_t *var;
// restore the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
cvar_t *var;
// restore the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
+ {
+ if(var->flags & CVAR_ALIAS)
+ continue;
if ((var->flags & (CVAR_NORESETTODEFAULTS | CVAR_SAVE)) == 0)
Cvar_SetQuick(var, var->defstring);
if ((var->flags & (CVAR_NORESETTODEFAULTS | CVAR_SAVE)) == 0)
Cvar_SetQuick(var, var->defstring);
cvar_t *var;
// restore the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
cvar_t *var;
// restore the default values of all cvars
for (var = cvars->vars ; var ; var = var->next)
+ {
+ if(var->flags & CVAR_ALIAS)
+ continue;
if ((var->flags & (CVAR_NORESETTODEFAULTS | CVAR_SAVE)) == CVAR_SAVE)
Cvar_SetQuick(var, var->defstring);
if ((var->flags & (CVAR_NORESETTODEFAULTS | CVAR_SAVE)) == CVAR_SAVE)
Cvar_SetQuick(var, var->defstring);
char buf1[MAX_INPUTLINE], buf2[MAX_INPUTLINE];
// don't save cvars that match their default value
char buf1[MAX_INPUTLINE], buf2[MAX_INPUTLINE];
// don't save cvars that match their default value
- for (var = cvars->vars ; var ; var = var->next)
+ for (var = cvars->vars ; var ; var = var->next) {
+ if(var->flags & CVAR_ALIAS)
+ continue;
if ((var->flags & CVAR_SAVE) && (strcmp(var->string, var->defstring) || ((var->flags & CVAR_ALLOCATED) && !(var->flags & CVAR_DEFAULTSET))))
{
Cmd_QuoteString(buf1, sizeof(buf1), var->name, "\"\\$", false);
Cmd_QuoteString(buf2, sizeof(buf2), var->string, "\"\\$", false);
FS_Printf(f, "%s\"%s\" \"%s\"\n", var->flags & CVAR_ALLOCATED ? "seta " : "", buf1, buf2);
}
if ((var->flags & CVAR_SAVE) && (strcmp(var->string, var->defstring) || ((var->flags & CVAR_ALLOCATED) && !(var->flags & CVAR_DEFAULTSET))))
{
Cmd_QuoteString(buf1, sizeof(buf1), var->name, "\"\\$", false);
Cmd_QuoteString(buf2, sizeof(buf2), var->string, "\"\\$", false);
FS_Printf(f, "%s\"%s\" \"%s\"\n", var->flags & CVAR_ALLOCATED ? "seta " : "", buf1, buf2);
}
}
// check if it's read-only
}
// check if it's read-only
- cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0);
- if (cvar && cvar->flags & CVAR_READONLY)
- {
- Con_Printf("Set: %s is read-only\n", cvar->name);
- return;
- }
+ cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0, true);
+ if (cvar)
+ if(Cvar_Readonly(cvar,"Set"))
+ return;
if (developer_extra.integer)
Con_DPrint("Set: ");
if (developer_extra.integer)
Con_DPrint("Set: ");
}
// check if it's read-only
}
// check if it's read-only
- cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0);
- if (cvar && cvar->flags & CVAR_READONLY)
- {
- Con_Printf("SetA: %s is read-only\n", cvar->name);
- return;
- }
+ cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0, true);
+ if (cvar)
+ if(Cvar_Readonly(cvar,"SetA"))
+ return;
if (developer_extra.integer)
Con_DPrint("SetA: ");
if (developer_extra.integer)
Con_DPrint("SetA: ");
Con_Printf("%s: %s is not defined\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, i));
continue;
}
Con_Printf("%s: %s is not defined\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, i));
continue;
}
- if(cvar->flags & CVAR_READONLY)
- {
- Con_Printf("%s: %s is read-only\n", Cmd_Argv(cmd, 0), cvar->name);
+ if(Cvar_Readonly(cvar, Cmd_Argv(cmd, 0)))
if(!(cvar->flags & CVAR_ALLOCATED))
{
Con_Printf("%s: %s is static and cannot be deleted\n", Cmd_Argv(cmd, 0), cvar->name);
if(!(cvar->flags & CVAR_ALLOCATED))
{
Con_Printf("%s: %s is static and cannot be deleted\n", Cmd_Argv(cmd, 0), cvar->name);
parent->nextonhashchain = cvar->nextonhashchain;
else if(link)
*link = cvar->nextonhashchain;
parent->nextonhashchain = cvar->nextonhashchain;
else if(link)
*link = cvar->nextonhashchain;
+ if(!(cvar->flags & CVAR_ALIAS))
+ {
+ if(cvar->description != cvar_dummy_description)
+ Z_Free((char *)cvar->description);
- if(cvar->description != cvar_dummy_description)
- Z_Free((char *)cvar->description);
-
- Z_Free((char *)cvar->name);
- Z_Free((char *)cvar->string);
- Z_Free((char *)cvar->defstring);
+ Z_Free((char *)cvar->name);
+ Z_Free((char *)cvar->string);
+ Z_Free((char *)cvar->defstring);
+ }
buf[n] = 0;
for(var = cvars->vars; var; var = var->next)
{
buf[n] = 0;
for(var = cvars->vars; var; var = var->next)
{
+ if(var->flags & CVAR_ALIAS)
+ continue;
for(i = 0, p = buf, q = var->name; i < n; ++i)
{
*p++ = *q++;
for(i = 0, p = buf, q = var->name; i < n; ++i)
{
*p++ = *q++;
#define CVAR_CLIENT 256
// cvar is accessible in dedicated server
#define CVAR_SERVER 512
#define CVAR_CLIENT 256
// cvar is accessible in dedicated server
#define CVAR_SERVER 512
+// cvar is an alias of another cvar
+#define CVAR_ALIAS 1024
// used to determine if flags is valid
// used to determine if flags is valid
-#define CVAR_MAXFLAGSVAL 1023
+#define CVAR_MAXFLAGSVAL 2047
// for internal use only!
#define CVAR_DEFAULTSET (1<<30)
#define CVAR_ALLOCATED (1<<31)
// for internal use only!
#define CVAR_DEFAULTSET (1<<30)
#define CVAR_ALLOCATED (1<<31)
//menucvar_t menuinfo;
struct cvar_s *next;
struct cvar_s *nextonhashchain;
//menucvar_t menuinfo;
struct cvar_s *next;
struct cvar_s *nextonhashchain;
} cvar_t;
typedef struct cvar_state_s
} cvar_t;
typedef struct cvar_state_s
/// registers a cvar that already has the name, string, and optionally the
/// archive elements set.
/// registers a cvar that already has the name, string, and optionally the
/// archive elements set.
+void Cvar_RegisterAlias(cvar_t *source, cvar_t *target);
+
void Cvar_RegisterCallback(cvar_t *variable, void (*callback)(char *));
void Cvar_RegisterVariable(cvar_t *variable);
void Cvar_RegisterCallback(cvar_t *variable, void (*callback)(char *));
void Cvar_RegisterVariable(cvar_t *variable);
+qboolean Cvar_Readonly (cvar_t *var, const char *cmd_name);
+
/// equivelant to "<name> <variable>" typed at the console
void Cvar_Set (cvar_state_t *cvars, const char *var_name, const char *value);
/// equivelant to "<name> <variable>" typed at the console
void Cvar_Set (cvar_state_t *cvars, const char *var_name, const char *value);
// Writes lines containing "set variable value" for all variables
// with the archive flag set to true.
// Writes lines containing "set variable value" for all variables
// with the archive flag set to true.
-cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags);
+cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags, qboolean alias);
cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int neededflags);
int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int neededflags);
cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int neededflags);
int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int neededflags);
framelimit = cl_maxphysicsframesperserverframe.integer;
aborttime = Sys_DirtyTime() + 0.1;
}
framelimit = cl_maxphysicsframesperserverframe.integer;
aborttime = Sys_DirtyTime() + 0.1;
}
- if(slowmo.value > 0 && slowmo.value < 1)
- advancetime = min(advancetime, 0.1 / slowmo.value);
+ if(host_timescale.value > 0 && host_timescale.value < 1)
+ advancetime = min(advancetime, 0.1 / host_timescale.value);
else
advancetime = min(advancetime, 0.1);
else
advancetime = min(advancetime, 0.1);
// only advance time if not paused
// the game also pauses in singleplayer when menu or console is used
// only advance time if not paused
// the game also pauses in singleplayer when menu or console is used
- sv.frametime = advancetime * slowmo.value;
+ sv.frametime = advancetime * host_timescale.value;
if (host_framerate.value)
sv.frametime = host_framerate.value;
if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
if (host_framerate.value)
sv.frametime = host_framerate.value;
if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
// scale playback speed of demos by slowmo cvar
if (cls.demoplayback)
{
// scale playback speed of demos by slowmo cvar
if (cls.demoplayback)
{
- clframetime *= slowmo.value;
+ clframetime *= host_timescale.value;
// if demo playback is paused, don't advance time at all
if (cls.demopaused)
clframetime = 0;
// if demo playback is paused, don't advance time at all
if (cls.demopaused)
clframetime = 0;
cvarname = Cmd_Argv(cmd, 1);
if (cls.state == ca_connected)
{
cvarname = Cmd_Argv(cmd, 1);
if (cls.state == ca_connected)
{
- c = Cvar_FindVar(&cvars_all, cvarname, CVAR_CLIENT | CVAR_SERVER);
+ c = Cvar_FindVar(&cvars_all, cvarname, CVAR_CLIENT | CVAR_SERVER, false);
// LadyHavoc: if there is no such cvar or if it is private, send a
// reply indicating that it has no value
if(!c || (c->flags & CVAR_PRIVATE))
Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "sentcvar %s", cvarname));
else
// LadyHavoc: if there is no such cvar or if it is private, send a
// reply indicating that it has no value
if(!c || (c->flags & CVAR_PRIVATE))
Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "sentcvar %s", cvarname));
else
- Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "sentcvar %s \"%s\"", c->name, c->string));
+ Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "sentcvar %s \"%s\"", cvarname, c->string));
return;
}
if(!sv.active)// || !PRVM_serverfunction(SV_ParseClientCommand))
return;
}
if(!sv.active)// || !PRVM_serverfunction(SV_ParseClientCommand))
+extern cvar_t host_timescale;
extern dllhandle_t jpeg_dll;
extern cvar_t gl_texture_anisotropy;
extern cvar_t r_textshadow;
extern dllhandle_t jpeg_dll;
extern cvar_t gl_texture_anisotropy;
extern cvar_t r_textshadow;
static qboolean PRVM_Cvar_ReadOk(prvm_prog_t *prog, const char *string)
{
cvar_t *cvar;
static qboolean PRVM_Cvar_ReadOk(prvm_prog_t *prog, const char *string)
{
cvar_t *cvar;
- cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask);
+ cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask, false);
return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0));
}
return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0));
}
VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
VM_VarString(prog, 0, string, sizeof(string));
VM_CheckEmptyString(prog, string);
VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
VM_VarString(prog, 0, string, sizeof(string));
VM_CheckEmptyString(prog, string);
- cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask);
+ cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask, true);
return;
// first check to see if it has already been defined
return;
// first check to see if it has already been defined
- if (Cvar_FindVar (prog->console_cmd->cvars, name, prog->console_cmd->cvars_flagsmask))
+ if (Cvar_FindVar (prog->console_cmd->cvars, name, prog->console_cmd->cvars_flagsmask, true))
return;
// check for overlap with a command
return;
// check for overlap with a command
s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
if(Cmd_Argc(cmd) == 5)
{
s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
if(Cmd_Argc(cmd) == 5)
{
- cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 4), cmd->cvars_flagsmask);
- if (cvar && cvar->flags & CVAR_READONLY)
- {
- Con_Printf("prvm_edictget: %s is read-only\n", cvar->name);
- goto fail;
- }
+ cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 4), cmd->cvars_flagsmask, true);
+ if (cvar)
+ if(Cvar_Readonly(cvar, "prvm_edictget"))
+ goto fail;
+
Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 4), s, cmd->cvars_flagsmask, NULL);
}
else
Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 4), s, cmd->cvars_flagsmask, NULL);
}
else
s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
if(Cmd_Argc(cmd) == 4)
{
s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
if(Cmd_Argc(cmd) == 4)
{
- cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 3), cmd->cvars_flagsmask);
- if (cvar && cvar->flags & CVAR_READONLY)
- {
- Con_Printf("prvm_globalget: %s is read-only\n", cvar->name);
- goto fail;
- }
+ cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 3), cmd->cvars_flagsmask, true);
+ if (cvar)
+ if(Cvar_Readonly(cvar, "prvm_globalget"))
+ goto fail;
Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 3), s, cmd->cvars_flagsmask, NULL);
}
else
Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 3), s, cmd->cvars_flagsmask, NULL);
}
else
)
{
prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs);
)
{
prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs);
- cvar = Cvar_FindVar(prog->console_cmd->cvars, name + 9, prog->console_cmd->cvars_flagsmask);
+ cvar = Cvar_FindVar(prog->console_cmd->cvars, name + 9, prog->console_cmd->cvars_flagsmask, false);
//Con_Printf("PRVM_LoadProgs: autocvar global %s in %s, processing...\n", name, prog->name);
if(!cvar)
{
//Con_Printf("PRVM_LoadProgs: autocvar global %s in %s, processing...\n", name, prog->name);
if(!cvar)
{
extern cvar_t scratch3;
extern cvar_t scratch4;
extern cvar_t skill;
extern cvar_t scratch3;
extern cvar_t scratch4;
extern cvar_t skill;
+extern cvar_t host_timescale;
extern cvar_t sv_accelerate;
extern cvar_t sv_aim;
extern cvar_t sv_airaccel_qw;
extern cvar_t sv_accelerate;
extern cvar_t sv_aim;
extern cvar_t sv_airaccel_qw;
cvar_t pr_checkextension = {CVAR_SERVER | CVAR_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"};
cvar_t samelevel = {CVAR_SERVER | CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
cvar_t skill = {CVAR_SERVER, "skill","1", "difficulty level of game, affects monster layouts in levels, 0 = easy, 1 = normal, 2 = hard, 3 = nightmare (same layout as hard but monsters fire twice)"};
cvar_t pr_checkextension = {CVAR_SERVER | CVAR_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"};
cvar_t samelevel = {CVAR_SERVER | CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
cvar_t skill = {CVAR_SERVER, "skill","1", "difficulty level of game, affects monster layouts in levels, 0 = easy, 1 = normal, 2 = hard, 3 = nightmare (same layout as hard but monsters fire twice)"};
-cvar_t slowmo = {CVAR_CLIENT | CVAR_SERVER, "slowmo", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
+cvar_t host_timescale = {CVAR_CLIENT | CVAR_SERVER, "host_timescale", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
+cvar_t slowmo = {CVAR_ALIAS, "slowmo"};
cvar_t sv_accelerate = {CVAR_SERVER, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
cvar_t sv_aim = {CVAR_SERVER | CVAR_SAVE, "sv_aim", "2", "maximum cosine angle for quake's vertical autoaim, a value above 1 completely disables the autoaim, quake used 0.93"};
cvar_t sv_accelerate = {CVAR_SERVER, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
cvar_t sv_aim = {CVAR_SERVER | CVAR_SAVE, "sv_aim", "2", "maximum cosine angle for quake's vertical autoaim, a value above 1 completely disables the autoaim, quake used 0.93"};
mempool_t *sv_mempool = NULL;
mempool_t *sv_mempool = NULL;
+extern cvar_t host_timescale;
extern float scr_centertime_off;
// MUST match effectnameindex_t in client.h
extern float scr_centertime_off;
// MUST match effectnameindex_t in client.h
#undef PRVM_DECLARE_function
};
#undef PRVM_DECLARE_function
};
-static void SV_Slowmo_c(char *string)
+static void Host_Timescale_c(char *string)
{
double value;
value = atof(string);
{
double value;
value = atof(string);
Cvar_RegisterVariable (&pr_checkextension);
Cvar_RegisterVariable (&samelevel);
Cvar_RegisterVariable (&skill);
Cvar_RegisterVariable (&pr_checkextension);
Cvar_RegisterVariable (&samelevel);
Cvar_RegisterVariable (&skill);
- Cvar_RegisterVariable (&slowmo);
- Cvar_RegisterCallback (&slowmo, SV_Slowmo_c);
+ Cvar_RegisterVariable (&host_timescale);
+ Cvar_RegisterCallback (&host_timescale, Host_Timescale_c);
+ Cvar_RegisterAlias (&slowmo, &host_timescale);
Cvar_RegisterVariable (&sv_accelerate);
Cvar_RegisterVariable (&sv_aim);
Cvar_RegisterVariable (&sv_airaccel_qw);
Cvar_RegisterVariable (&sv_accelerate);
Cvar_RegisterVariable (&sv_aim);
Cvar_RegisterVariable (&sv_airaccel_qw);
| (sv_gameplayfix_gravityunaffectedbyticrate.integer ? MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE : 0)
;
statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
| (sv_gameplayfix_gravityunaffectedbyticrate.integer ? MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE : 0)
;
statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
- statsf[STAT_MOVEVARS_TIMESCALE] = slowmo.value;
+ statsf[STAT_MOVEVARS_TIMESCALE] = host_timescale.value;
statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
// only advance time if not paused
// the game also pauses in singleplayer when menu or console is used
// only advance time if not paused
// the game also pauses in singleplayer when menu or console is used
- sv.frametime = advancetime * slowmo.value;
+ sv.frametime = advancetime * host_timescale.value;
if (host_framerate.value)
sv.frametime = host_framerate.value;
if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
if (host_framerate.value)
sv.frametime = host_framerate.value;
if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
qboolean VID_InitMode(viddef_mode_t *mode)
{
// GAME_STEELSTORM specific
qboolean VID_InitMode(viddef_mode_t *mode)
{
// GAME_STEELSTORM specific
- steelstorm_showing_map = Cvar_FindVar(&cvars_all, "steelstorm_showing_map", ~0);
- steelstorm_showing_mousecursor = Cvar_FindVar(&cvars_all, "steelstorm_showing_mousecursor", ~0);
+ steelstorm_showing_map = Cvar_FindVar(&cvars_all, "steelstorm_showing_map", ~0, false);
+ steelstorm_showing_mousecursor = Cvar_FindVar(&cvars_all, "steelstorm_showing_mousecursor", ~0, false);
if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());
if (!SDL_WasInit(SDL_INIT_VIDEO) && SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
Sys_Error ("Failed to init SDL video subsystem: %s", SDL_GetError());