From 429b1d73fe193405b53084978eab41c3cc201dd5 Mon Sep 17 00:00:00 2001 From: cypress Date: Wed, 4 Sep 2024 17:36:03 -0700 Subject: [PATCH] Quakespasm's enhanced cvar system --- source/cmd.c | 46 --- source/cvar.c | 543 ++++++++++++++++++++++++++--- source/cvar.h | 109 ++++-- source/draw.h | 2 +- source/net_dgrm.c | 23 +- source/psp/video_hardware_draw.cpp | 6 +- 6 files changed, 571 insertions(+), 158 deletions(-) diff --git a/source/cmd.c b/source/cmd.c index 751f211..e0c88fe 100644 --- a/source/cmd.c +++ b/source/cmd.c @@ -539,51 +539,6 @@ void Cmd_List_f (void) } // 2000-01-09 CmdList command by Maddes end -// 2000-01-09 CvarList command by Maddes start -/* -========= -Cvar_List -========= -*/ -void Cvar_List_f (void) -{ - cvar_t *cvar; - char *partial; - int len; - int count; - - if (Cmd_Argc() > 1) - { - partial = Cmd_Argv (1); - len = Q_strlen(partial); - } - else - { - partial = NULL; - len = 0; - } - - count=0; - for (cvar=cvar_vars ; cvar ; cvar=cvar->next) - { - if (partial && Q_strncmp (partial,cvar->name, len)) - { - continue; - } - Con_Printf ("\"%s\" is \"%s\"\n", cvar->name, cvar->string); - count++; - } - - Con_Printf ("%i cvar(s)", count); - if (partial) - { - Con_Printf (" beginning with \"%s\"", partial); - } - Con_Printf ("\n"); -} -// 2000-01-09 CvarList command by Maddes end - - /* ============ Cmd_Init @@ -595,7 +550,6 @@ void Cmd_Init (void) // register our commands // Cmd_AddCommand ("cmdlist", Cmd_List_f); // 2000-01-09 CmdList command by Maddes - Cmd_AddCommand ("cvarlist", Cvar_List_f); // 2000-01-09 CvarList command by Maddes Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f); Cmd_AddCommand ("exec",Cmd_Exec_f); Cmd_AddCommand ("echo",Cmd_Echo_f); diff --git a/source/cvar.c b/source/cvar.c index e5c2b8a..0f5cab7 100644 --- a/source/cvar.c +++ b/source/cvar.c @@ -1,5 +1,7 @@ /* -Copyright (C) 1996-1997 Id Software, Inc. +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 @@ -8,7 +10,7 @@ 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. +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -21,34 +23,303 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" -cvar_t *cvar_vars; -char *cvar_null_string = ""; +static cvar_t *cvar_vars; +static char cvar_null_string[] = ""; + +//============================================================================== +// +// USER COMMANDS +// +//============================================================================== + +void Cvar_Reset (const char *name); //johnfitz + +/* +============ +Cvar_List_f -- johnfitz +============ +*/ +void Cvar_List_f (void) +{ + 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 (cvar = cvar_vars ; cvar ; cvar = cvar->next) + { + if (partial && Q_strncmp(partial, cvar->name, len)) + { + continue; + } + Con_SafePrintf ("%s%s %s \"%s\"\n", + (cvar->flags & CVAR_ARCHIVE) ? "*" : " ", + (cvar->flags & CVAR_NOTIFY) ? "s" : " ", + cvar->name, + cvar->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 [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 : 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 (void) +{ + int i; + + if (Cmd_Argc() < 3) + { + Con_Printf("cycle : 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 (void) +{ + switch (Cmd_Argc()) + { + default: + case 1: + Con_Printf ("reset : 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 (var = cvar_vars ; var ; var = var->next) + Cvar_Reset (var->name); +} + +/* +============ +Cvar_ResetCfg_f -- QuakeSpasm +============ +*/ +void Cvar_ResetCfg_f (void) +{ + cvar_t *var; + + for (var = cvar_vars ; var ; var = var->next) + if (var->flags & CVAR_ARCHIVE) Cvar_Reset (var->name); +} + +//============================================================================== +// +// INIT +// +//============================================================================== + +/* +============ +Cvar_Init -- johnfitz +============ +*/ + +void Cvar_Init (void) +{ + 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 ============ */ -cvar_t *Cvar_FindVar (char *var_name) +cvar_t *Cvar_FindVar (const char *var_name) { cvar_t *var; - - for (var=cvar_vars ; var ; var=var->next) - if (!strcmp (var_name, var->name)) + + for (var = cvar_vars ; var ; var = var->next) + { + if (!strcmp(var_name, var->name)) return var; + } return NULL; } +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; +} + +/* +============ +Cvar_LockVar +============ +*/ +void Cvar_LockVar (const char *var_name) +{ + cvar_t *var = Cvar_FindVar (var_name); + if (var) + var->flags |= CVAR_LOCKED; +} + +void Cvar_UnlockVar (const char *var_name) +{ + cvar_t *var = Cvar_FindVar (var_name); + if (var) + var->flags &= ~CVAR_LOCKED; +} + +void Cvar_UnlockAll (void) +{ + cvar_t *var; + + for (var = cvar_vars ; var ; var = var->next) + { + var->flags &= ~CVAR_LOCKED; + } +} + /* ============ Cvar_VariableValue ============ */ -float Cvar_VariableValue (char *var_name) +float Cvar_VariableValue (const char *var_name) { cvar_t *var; - + var = Cvar_FindVar (var_name); if (!var) return 0; @@ -61,10 +332,10 @@ float Cvar_VariableValue (char *var_name) Cvar_VariableString ============ */ -char *Cvar_VariableString (char *var_name) +const char *Cvar_VariableString (const char *var_name) { cvar_t *var; - + var = Cvar_FindVar (var_name); if (!var) return cvar_null_string; @@ -77,35 +348,114 @@ char *Cvar_VariableString (char *var_name) Cvar_CompleteVariable ============ */ -char *Cvar_CompleteVariable (char *partial) +const char *Cvar_CompleteVariable (const char *partial) { - cvar_t *cvar; - int len; - + cvar_t *cvar; + int len; + len = Q_strlen(partial); - if (!len) return NULL; - + // check functions - for (cvar=cvar_vars ; cvar ; cvar=cvar->next) - if (!Q_strncmp (partial,cvar->name, len)) + for (cvar = cvar_vars ; cvar ; cvar = cvar->next) + { + if (!Q_strncmp(partial, cvar->name, len)) return cvar->name; + } return NULL; } +/* +============ +Cvar_Reset -- johnfitz +============ +*/ +void Cvar_Reset (const char *name) +{ + cvar_t *var; + + var = Cvar_FindVar (name); + if (!var) + Con_Printf ("variable \"%s\" not found\n", name); + else + Cvar_SetQuick (var, var->default_string); +} + +void Cvar_SetQuick (cvar_t *var, const char *value) +{ + if (var->flags & (CVAR_ROM|CVAR_LOCKED)) + return; + if (!(var->flags & CVAR_REGISTERED)) + return; + + if (!var->string) + var->string = Z_Strdup (value); + else + { + int len; + + if (!strcmp(var->string, value)) + return; // no change + + var->flags |= CVAR_CHANGED; + len = Q_strlen (value); + if (len != Q_strlen(var->string)) + { + Z_Free ((void *)var->string); + var->string = (char *) Z_Malloc (len + 1); + } + memcpy ((char *)var->string, value, 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)) + snprintf (val, sizeof(val), "%i", (int)value); + else + { + 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 (char *var_name, char *value) +void Cvar_Set (const char *var_name, const char *value) { - cvar_t *var; - qboolean changed; - + cvar_t *var; + var = Cvar_FindVar (var_name); if (!var) { // there is an error in C code if this happens @@ -113,18 +463,7 @@ void Cvar_Set (char *var_name, char *value) return; } - changed = strcmp(var->string, value); - - Z_Free (var->string); // free the old value string - - var->string = Z_Malloc (Q_strlen(value)+1); - Q_strcpy (var->string, value); - var->value = Q_atof (var->string); - if (var->server && changed) - { - if (sv.active) - SV_BroadcastPrintf ("\"%s\" changed to \"%s\"\n", var->name, var->string); - } + Cvar_SetQuick (var, value); } /* @@ -132,14 +471,57 @@ void Cvar_Set (char *var_name, char *value) Cvar_SetValue ============ */ -void Cvar_SetValue (char *var_name, float value) +void Cvar_SetValue (const char *var_name, const float value) { - char val[32]; - - sprintf (val, "%f",value); + char val[32], *ptr = val; + + if (value == (float)((int)value)) + snprintf (val, sizeof(val), "%i", (int)value); + else + { + 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) +{ + cvar_t *var = Cvar_FindVar (var_name); + if (var) + { + var->flags &= ~CVAR_ROM; + Cvar_SetQuick (var, value); + var->flags |= CVAR_ROM; + } +} + +/* +============ +Cvar_SetValueROM +============ +*/ +void Cvar_SetValueROM (const char *var_name, const float value) +{ + cvar_t *var = Cvar_FindVar (var_name); + if (var) + { + var->flags &= ~CVAR_ROM; + Cvar_SetValueQuick (var, value); + var->flags |= CVAR_ROM; + } +} + /* ============ Cvar_RegisterVariable @@ -149,31 +531,76 @@ Adds a freestanding variable to the variable list. */ void Cvar_RegisterVariable (cvar_t *variable) { - char *oldstr; - -// first check to see if it has allready been defined + 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, allready defined\n", 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; } - -// copy the value off, because future sets will Z_Free it - oldstr = variable->string; - variable->string = Z_Malloc (Q_strlen(variable->string)+1); - Q_strcpy (variable->string, oldstr); - variable->value = Q_atof (variable->string); - + // link the variable in - variable->next = cvar_vars; - cvar_vars = variable; + //johnfitz -- insert each entry in alphabetical order + if (cvar_vars == NULL || + strcmp(variable->name, cvar_vars->name) < 0) // insert at front + { + variable->next = cvar_vars; + cvar_vars = variable; + } + else //insert later + { + prev = cvar_vars; + cursor = cvar_vars->next; + while (cursor && (strcmp(variable->name, cursor->name) > 0)) + { + prev = cursor; + cursor = cursor->next; + } + variable->next = prev->next; + prev->next = variable; + } + //johnfitz + variable->flags |= CVAR_REGISTERED; + +// copy the value off, because future sets will Z_Free it + strlcpy (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; } /* @@ -191,7 +618,7 @@ qboolean Cvar_Command (void) v = Cvar_FindVar (Cmd_Argv(0)); if (!v) return false; - + // perform a variable print or set if (Cmd_Argc() == 1) { @@ -215,9 +642,11 @@ with the archive flag set to true. void Cvar_WriteVariables (FILE *f) { cvar_t *var; - + for (var = cvar_vars ; var ; var = var->next) - if (var->archive) + { + if (var->flags & CVAR_ARCHIVE) fprintf (f, "%s \"%s\"\n", var->name, var->string); + } } diff --git a/source/cvar.h b/source/cvar.h index 138fda8..dc5d6f1 100644 --- a/source/cvar.h +++ b/source/cvar.h @@ -1,5 +1,7 @@ /* -Copyright (C) 1996-1997 Id Software, Inc. +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 @@ -17,21 +19,27 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -// cvar.h + +#ifndef __CVAR_H__ +#define __CVAR_H__ /* +cvar_t variables are used to hold scalar or string variables that can +be changed or displayed at the console or prog code as well as accessed +directly in C code. -cvar_t variables are used to hold scalar or string variables that can be changed or displayed at the console or prog code as well as accessed directly -in C code. - -it is sufficient to initialize a cvar_t with just the first two fields, or -you can add a ,true flag for variables that you want saved to the configuration -file when the game is quit: +it is sufficient to initialize a cvar_t with just the first two fields, +or you can add a ,true flag for variables that you want saved to the +configuration file when the game is quit: cvar_t r_draworder = {"r_draworder","1"}; cvar_t scr_screensize = {"screensize","1",true}; -Cvars must be registered before use, or they will have a 0 value instead of the float interpretation of the string. Generally, all cvar_t declarations should be registered in the apropriate init function before any console commands are executed: +Cvars must be registered before use, or they will have a 0 value instead +of the float interpretation of the string. +Generally, all cvar_t declarations should be registered in the apropriate +init function before any console commands are executed: + Cvar_RegisterVariable (&host_framerate); @@ -44,53 +52,92 @@ if (Cvar_VariableValue ("r_draworder")) Interpreted prog code can access cvars with the cvar(name) or cvar_set (name, value) internal functions: teamplay = cvar("teamplay"); +cvar_set ("registered", "1"); The user can access cvars from the console in two ways: -r_draworder prints the current value +r_draworder prints the current value r_draworder 0 sets the current value to 0 + Cvars are restricted from having the same names as commands to keep this interface from being ambiguous. + */ +#define CVAR_NONE 0 +#define CVAR_ARCHIVE (1U << 0) // if set, causes it to be saved to config +#define CVAR_NOTIFY (1U << 1) // changes will be broadcasted to all players (q1) +#define CVAR_SERVERINFO (1U << 2) // added to serverinfo will be sent to clients (q1/net_dgrm.c and qwsv) +#define CVAR_USERINFO (1U << 3) // added to userinfo, will be sent to server (qwcl) +#define CVAR_CHANGED (1U << 4) +#define CVAR_ROM (1U << 6) +#define CVAR_LOCKED (1U << 8) // locked temporarily +#define CVAR_REGISTERED (1U << 10) // the var is added to the list of variables +#define CVAR_CALLBACK (1U << 16) // var has a callback + + +typedef void (*cvarcallback_t) (struct cvar_s *); + typedef struct cvar_s { - char *name; - char *string; - qboolean archive; // set to true to cause it to be saved to vars.rc - qboolean server; // notifies players when changed - float value; - struct cvar_s *next; + const char *name; + const char *string; + unsigned int flags; + float value; + const char *default_string; //johnfitz -- remember defaults for reset function + cvarcallback_t callback; + struct cvar_s *next; } cvar_t; -void Cvar_RegisterVariable (cvar_t *variable); -// registers a cvar that allready has the name, string, and optionally the -// archive elements set. +void Cvar_RegisterVariable (cvar_t *variable); +// registers a cvar that already has the name, string, and optionally +// the archive elements set. -void Cvar_Set (char *var_name, char *value); +void Cvar_SetCallback (cvar_t *var, cvarcallback_t func); +// set a callback function to the var + +void Cvar_Set (const char *var_name, const char *value); // equivelant to " " typed at the console -void Cvar_SetValue (char *var_name, float value); +void Cvar_SetValue (const char *var_name, const float value); // expands value to a string and calls Cvar_Set -float Cvar_VariableValue (char *var_name); +void Cvar_SetROM (const char *var_name, const char *value); +void Cvar_SetValueROM (const char *var_name, const float value); +// sets a CVAR_ROM variable from within the engine + +void Cvar_SetQuick (cvar_t *var, const char *value); +void Cvar_SetValueQuick (cvar_t *var, const float value); +// these two accept a cvar pointer instead of a var name, +// but are otherwise identical to the "non-Quick" versions. +// the cvar MUST be registered. + +float Cvar_VariableValue (const char *var_name); // returns 0 if not defined or non numeric -char *Cvar_VariableString (char *var_name); +const char *Cvar_VariableString (const char *var_name); // returns an empty string if not defined -char *Cvar_CompleteVariable (char *partial); -// attempts to match a partial variable name for command line completion -// returns NULL if nothing fits - qboolean Cvar_Command (void); // called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known // command. Returns true if the command was a variable reference that // was handled. (print or change) -void Cvar_WriteVariables (FILE *f); +void Cvar_WriteVariables (FILE *f); // Writes lines containing "set variable value" for all variables -// with the archive flag set to true. +// with the CVAR_ARCHIVE flag set -cvar_t *Cvar_FindVar (char *var_name); +cvar_t *Cvar_FindVar (const char *var_name); +cvar_t *Cvar_FindVarAfter (const char *prev_name, unsigned int with_flags); + +void Cvar_LockVar (const char *var_name); +void Cvar_UnlockVar (const char *var_name); +void Cvar_UnlockAll (void); + +void Cvar_Init (void); + +const char *Cvar_CompleteVariable (const char *partial); +// attempts to match a partial variable name for command line completion +// returns NULL if nothing fits + +#endif /* __CVAR_H__ */ -extern cvar_t *cvar_vars; diff --git a/source/draw.h b/source/draw.h index b9b5044..4ea3838 100644 --- a/source/draw.h +++ b/source/draw.h @@ -43,7 +43,7 @@ int getTextWidth(char *str, int scale); //other void Clear_LoadingFill (void); -byte *StringToRGB (char *s); +byte *StringToRGB (const char *s); extern float loading_cur_step; extern int loading_step; diff --git a/source/net_dgrm.c b/source/net_dgrm.c index fdfca8a..c62c354 100644 --- a/source/net_dgrm.c +++ b/source/net_dgrm.c @@ -842,31 +842,14 @@ static qsocket_t *_Datagram_CheckNewConnections (void) if (command == CCREQ_RULE_INFO) { - char *prevCvarName; - cvar_t *var; + const char *prevCvarName; + cvar_t *var; // find the search start location prevCvarName = MSG_ReadString(); - if (*prevCvarName) - { - var = Cvar_FindVar (prevCvarName); - if (!var) - return NULL; - var = var->next; - } - else - var = cvar_vars; - - // search for the next server cvar - while (var) - { - if (var->server) - break; - var = var->next; - } + var = Cvar_FindVarAfter (prevCvarName, CVAR_SERVERINFO); // send the response - SZ_Clear(&net_message); // save space for the header, filled in later MSG_WriteLong(&net_message, 0); diff --git a/source/psp/video_hardware_draw.cpp b/source/psp/video_hardware_draw.cpp index 193c438..3576c21 100644 --- a/source/psp/video_hardware_draw.cpp +++ b/source/psp/video_hardware_draw.cpp @@ -1130,12 +1130,12 @@ void Draw_Fill (int x, int y, int w, int h, int c) sceGuEnable(GU_TEXTURE_2D); } -byte *StringToRGB (char *s) +byte *StringToRGB (const char *s) { byte *col; static byte rgb[4]; - Cmd_TokenizeString (s); + Cmd_TokenizeString ((char*)s); if (Cmd_Argc() == 3) { rgb[0] = (byte)Q_atoi(Cmd_Argv(0)); @@ -1144,7 +1144,7 @@ byte *StringToRGB (char *s) } else { - col = (byte *)&d_8to24table[(byte)Q_atoi(s)]; + col = (byte *)&d_8to24table[(byte)Q_atoi((char*)s)]; rgb[0] = col[0]; rgb[1] = col[1]; rgb[2] = col[2];