Return to cvar.h CVS log

Up to [Quake] / quakeworld / client

Annotation of quakeworld/client/cvar.h, revision 1.1.1.1

1.1       root        1: /*
                      2: Copyright (C) 1996-1997 Id Software, Inc.
                      3: 
                      4: This program is free software; you can redistribute it and/or
                      5: modify it under the terms of the GNU General Public License
                      6: as published by the Free Software Foundation; either version 2
                      7: of the License, or (at your option) any later version.
                      8: 
                      9: This program is distributed in the hope that it will be useful,
                     10: but WITHOUT ANY WARRANTY; without even the implied warranty of
                     11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
                     12: 
                     13: See the GNU General Public License for more details.
                     14: 
                     15: You should have received a copy of the GNU General Public License
                     16: along with this program; if not, write to the Free Software
                     17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
                     18: 
                     19: */
                     20: // cvar.h
                     21: 
                     22: /*
                     23: 
                     24: 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
                     25: in C code.
                     26: 
                     27: it is sufficient to initialize a cvar_t with just the first two fields, or
                     28: you can add a ,true flag for variables that you want saved to the configuration
                     29: file when the game is quit:
                     30: 
                     31: cvar_t r_draworder = {"r_draworder","1"};
                     32: cvar_t scr_screensize = {"screensize","1",true};
                     33: 
                     34: 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:
                     35: Cvar_RegisterVariable (&host_framerate);
                     36: 
                     37: 
                     38: C code usually just references a cvar in place:
                     39: if ( r_draworder.value )
                     40: 
                     41: It could optionally ask for the value to be looked up for a string name:
                     42: if (Cvar_VariableValue ("r_draworder"))
                     43: 
                     44: Interpreted prog code can access cvars with the cvar(name) or
                     45: cvar_set (name, value) internal functions:
                     46: teamplay = cvar("teamplay");
                     47: cvar_set ("registered", "1");
                     48: 
                     49: The user can access cvars from the console in two ways:
                     50: r_draworder                    prints the current value
                     51: r_draworder 0          sets the current value to 0
                     52: Cvars are restricted from having the same names as commands to keep this
                     53: interface from being ambiguous.
                     54: */
                     55: 
                     56: typedef struct cvar_s
                     57: {
                     58:        char    *name;
                     59:        char    *string;
                     60:        qboolean archive;               // set to true to cause it to be saved to vars.rc
                     61:        qboolean info;                  // added to serverinfo or userinfo when changed
                     62:        float   value;
                     63:        struct cvar_s *next;
                     64: } cvar_t;
                     65: 
                     66: void   Cvar_RegisterVariable (cvar_t *variable);
                     67: // registers a cvar that allready has the name, string, and optionally the
                     68: // archive elements set.
                     69: 
                     70: void   Cvar_Set (char *var_name, char *value);
                     71: // equivelant to "<name> <variable>" typed at the console
                     72: 
                     73: void   Cvar_SetValue (char *var_name, float value);
                     74: // expands value to a string and calls Cvar_Set
                     75: 
                     76: float  Cvar_VariableValue (char *var_name);
                     77: // returns 0 if not defined or non numeric
                     78: 
                     79: char   *Cvar_VariableString (char *var_name);
                     80: // returns an empty string if not defined
                     81: 
                     82: char   *Cvar_CompleteVariable (char *partial);
                     83: // attempts to match a partial variable name for command line completion
                     84: // returns NULL if nothing fits
                     85: 
                     86: qboolean Cvar_Command (void);
                     87: // called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known
                     88: // command.  Returns true if the command was a variable reference that
                     89: // was handled. (print or change)
                     90: 
                     91: void   Cvar_WriteVariables (FILE *f);
                     92: // Writes lines containing "set variable value" for all variables
                     93: // with the archive flag set to true.
                     94: 
                     95: cvar_t *Cvar_FindVar (char *var_name);
                     96: 
                     97: extern cvar_t  *cvar_vars;

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.