added description string to all cvars and commands
authorhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Wed, 1 Feb 2006 13:21:06 +0000 (13:21 +0000)
committerhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Wed, 1 Feb 2006 13:21:06 +0000 (13:21 +0000)
modified tab completion to print description by each cvar, instead of just printing names
refactored tab completion code

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@5933 d7cf8633-e32d-0410-b094-e92efae38249

56 files changed:
cd_sdl.c
cd_shared.c
cl_input.c
cl_main.c
cl_parse.c
cl_particles.c
cl_screen.c
cl_video.c
clvm_cmds.c
cmd.c
cmd.h
collision.c
common.c
console.c
cvar.c
cvar.h
fs.c
gl_backend.c
gl_rmain.c
gl_rsurf.c
gl_textures.c
host.c
host_cmd.c
keys.c
menu.c
meshqueue.c
model_alias.c
model_brush.c
model_shared.c
model_sprite.c
netconn.c
prvm_edict.c
r_crosshairs.c
r_explosion.c
r_light.c
r_lightning.c
r_modules.c
r_shadow.c
r_sky.c
sbar.c
server.h
snd_main.c
snd_null.c
sv_main.c
sv_phys.c
sv_user.c
svvm_cmds.c
sys_linux.c
sys_win.c
vid_glx.c
vid_shared.c
vid_wgl.c
view.c
world.c
world_cs.c
zone.c

index 1f98c49..b9a7a75 100644 (file)
--- a/cd_sdl.c
+++ b/cd_sdl.c
@@ -132,7 +132,7 @@ void CDAudio_SysInit (void)
        if( SDL_InitSubSystem( SDL_INIT_CDROM ) == -1 )
                Con_Print( "Failed to init the CDROM SDL subsystem!\n" );
 
-       Cmd_AddCommand( "cddrive", CDAudio_SDL_CDDrive_f );
+       Cmd_AddCommand( "cddrive", CDAudio_SDL_CDDrive_f, "select an SDL-detected CD drive by number" );
 }
 
 static int IsAudioCD( void )
index a4cf1e8..9bca5e5 100644 (file)
@@ -42,7 +42,7 @@ extern int CDAudio_SysStartup (void);
 extern void CDAudio_SysShutdown (void);
 
 // used by menu to ghost CD audio slider
-cvar_t cdaudioinitialized = {CVAR_READONLY,"cdaudioinitialized","0"};
+cvar_t cdaudioinitialized = {CVAR_READONLY,"cdaudioinitialized","0","indicates if CD Audio system is active"};
 
 static qboolean wasPlaying = false;
 static qboolean initialized = false;
@@ -319,6 +319,20 @@ static void CD_f (void)
                Con_Printf("Volume is %f\n", cdvolume);
                return;
        }
+
+       Con_Printf("CD commands:\n");
+       Con_Printf("cd on - enables CD audio system\n");
+       Con_Printf("cd off - stops and disables CD audio system\n");
+       Con_Printf("cd reset - resets CD audio system (clears track remapping and re-reads disc information)");
+       Con_Printf("cd remap <remap1> [remap2] [remap3] [...] - chooses (possibly emulated) CD tracks to play when a map asks for a particular track, this has many uses\n");
+       Con_Printf("cd close - closes CD tray\n");
+       Con_Printf("cd eject - stops playing music and opens CD tray to allow you to change disc\n");
+       Con_Printf("cd play <tracknumber> - plays selected track in remapping table\n");
+       Con_Printf("cd loop <tracknumber> - plays and repeats selected track in remapping table\n");
+       Con_Printf("cd stop - stops playing current CD track\n");
+       Con_Printf("cd pause - pauses CD playback\n");
+       Con_Printf("cd resume - unpauses CD playback\n");
+       Con_Printf("cd info - prints basic disc information (number of tracks, currently playing track, volume level)\n");
 }
 
 void CDAudio_SetVolume (float newvol)
@@ -375,7 +389,7 @@ int CDAudio_Init (void)
        Cvar_SetValueQuick(&cdaudioinitialized, true);
        enabled = true;
 
-       Cmd_AddCommand("cd", CD_f);
+       Cmd_AddCommand("cd", CD_f, "execute a CD drive command (cd on/off/reset/remap/close/play/loop/stop/pause/resume/eject/info) - use cd by itself for usage");
 
        return 0;
 }
index 729e306..41513ec 100644 (file)
@@ -257,35 +257,35 @@ float CL_KeyState (kbutton_t *key)
 
 //==========================================================================
 
-cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400"};
-cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400"};
-cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400"};
-cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350"};
+cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
+cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
+cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
+cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
 
-cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0"};
+cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
 
-cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140"};
-cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150"};
+cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
+cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
 
-cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5"};
+cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
 
-cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0"};
-cvar_t cl_movement_latency = {0, "cl_movement_latency", "0"};
-cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320"};
-cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30"};
-cvar_t cl_movement_stopspeed = {0, "cl_movement_stopspeed", "100"};
-cvar_t cl_movement_friction = {0, "cl_movement_friction", "4"};
-cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "2"};
-cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18"};
-cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10"};
-cvar_t cl_movement_jumpvelocity = {0, "cl_movement_jumpvelocity", "270"};
-cvar_t cl_gravity = {0, "cl_gravity", "800"};
-cvar_t cl_slowmo = {0, "cl_slowmo", "1"};
+cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement"};
+cvar_t cl_movement_latency = {0, "cl_movement_latency", "0", "compensates for this much latency (ping time) on quake servers which do not really support prediction, no effect on darkplaces7 protocol servers"};
+cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
+cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
+cvar_t cl_movement_stopspeed = {0, "cl_movement_stopspeed", "100", "speed below which you will be slowed rapidly to a stop rather than sliding endlessly (should match sv_stopspeed)"};
+cvar_t cl_movement_friction = {0, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
+cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "2", "how much to slow down when you may be about to fall off a ledge (should match edgefriction)"};
+cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
+cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
+cvar_t cl_movement_jumpvelocity = {0, "cl_movement_jumpvelocity", "270", "how fast you move upward when you begin a jump (should match the quakec code)"};
+cvar_t cl_gravity = {0, "cl_gravity", "800", "how much gravity to apply in client physics (should match sv_gravity)"};
+cvar_t cl_slowmo = {0, "cl_slowmo", "1", "speed of game time (should match slowmo)"};
 
-cvar_t in_pitch_min = {0, "in_pitch_min", "-90"}; // quake used -70
-cvar_t in_pitch_max = {0, "in_pitch_max", "90"}; // quake used 80
+cvar_t in_pitch_min = {0, "in_pitch_min", "-90", "how far downward you can aim (quake used -70"}; // quake used -70
+cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (quake used 80"}; // quake used 80
 
-cvar_t m_filter = {CVAR_SAVE, "m_filter","0"};
+cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
 
 
 /*
@@ -1020,73 +1020,73 @@ CL_InitInput
 */
 void CL_InitInput (void)
 {
-       Cmd_AddCommand ("+moveup",IN_UpDown);
-       Cmd_AddCommand ("-moveup",IN_UpUp);
-       Cmd_AddCommand ("+movedown",IN_DownDown);
-       Cmd_AddCommand ("-movedown",IN_DownUp);
-       Cmd_AddCommand ("+left",IN_LeftDown);
-       Cmd_AddCommand ("-left",IN_LeftUp);
-       Cmd_AddCommand ("+right",IN_RightDown);
-       Cmd_AddCommand ("-right",IN_RightUp);
-       Cmd_AddCommand ("+forward",IN_ForwardDown);
-       Cmd_AddCommand ("-forward",IN_ForwardUp);
-       Cmd_AddCommand ("+back",IN_BackDown);
-       Cmd_AddCommand ("-back",IN_BackUp);
-       Cmd_AddCommand ("+lookup", IN_LookupDown);
-       Cmd_AddCommand ("-lookup", IN_LookupUp);
-       Cmd_AddCommand ("+lookdown", IN_LookdownDown);
-       Cmd_AddCommand ("-lookdown", IN_LookdownUp);
-       Cmd_AddCommand ("+strafe", IN_StrafeDown);
-       Cmd_AddCommand ("-strafe", IN_StrafeUp);
-       Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
-       Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
-       Cmd_AddCommand ("+moveright", IN_MoverightDown);
-       Cmd_AddCommand ("-moveright", IN_MoverightUp);
-       Cmd_AddCommand ("+speed", IN_SpeedDown);
-       Cmd_AddCommand ("-speed", IN_SpeedUp);
-       Cmd_AddCommand ("+attack", IN_AttackDown);
-       Cmd_AddCommand ("-attack", IN_AttackUp);
-       Cmd_AddCommand ("+jump", IN_JumpDown);
-       Cmd_AddCommand ("-jump", IN_JumpUp);
-       Cmd_AddCommand ("impulse", IN_Impulse);
-       Cmd_AddCommand ("+klook", IN_KLookDown);
-       Cmd_AddCommand ("-klook", IN_KLookUp);
-       Cmd_AddCommand ("+mlook", IN_MLookDown);
-       Cmd_AddCommand ("-mlook", IN_MLookUp);
+       Cmd_AddCommand ("+moveup",IN_UpDown, "swim upward");
+       Cmd_AddCommand ("-moveup",IN_UpUp, "stop swimming upward");
+       Cmd_AddCommand ("+movedown",IN_DownDown, "swim downward");
+       Cmd_AddCommand ("-movedown",IN_DownUp, "stop swimming downward");
+       Cmd_AddCommand ("+left",IN_LeftDown, "turn left");
+       Cmd_AddCommand ("-left",IN_LeftUp, "stop turning left");
+       Cmd_AddCommand ("+right",IN_RightDown, "turn right");
+       Cmd_AddCommand ("-right",IN_RightUp, "stop turning right");
+       Cmd_AddCommand ("+forward",IN_ForwardDown, "move forward");
+       Cmd_AddCommand ("-forward",IN_ForwardUp, "stop moving forward");
+       Cmd_AddCommand ("+back",IN_BackDown, "move backward");
+       Cmd_AddCommand ("-back",IN_BackUp, "stop moving backward");
+       Cmd_AddCommand ("+lookup", IN_LookupDown, "look upward");
+       Cmd_AddCommand ("-lookup", IN_LookupUp, "stop looking upward");
+       Cmd_AddCommand ("+lookdown", IN_LookdownDown, "look downward");
+       Cmd_AddCommand ("-lookdown", IN_LookdownUp, "stop looking downward");
+       Cmd_AddCommand ("+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)\n");
+       Cmd_AddCommand ("-strafe", IN_StrafeUp, "deactivate strafing mode");
+       Cmd_AddCommand ("+moveleft", IN_MoveleftDown, "strafe left");
+       Cmd_AddCommand ("-moveleft", IN_MoveleftUp, "stop strafing left");
+       Cmd_AddCommand ("+moveright", IN_MoverightDown, "strafe right");
+       Cmd_AddCommand ("-moveright", IN_MoverightUp, "stop strafing right");
+       Cmd_AddCommand ("+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
+       Cmd_AddCommand ("-speed", IN_SpeedUp, "deactivate run mode");
+       Cmd_AddCommand ("+attack", IN_AttackDown, "begin firing");
+       Cmd_AddCommand ("-attack", IN_AttackUp, "stop firing");
+       Cmd_AddCommand ("+jump", IN_JumpDown, "jump");
+       Cmd_AddCommand ("-jump", IN_JumpUp, "end jump (so you can jump again)");
+       Cmd_AddCommand ("impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
+       Cmd_AddCommand ("+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
+       Cmd_AddCommand ("-klook", IN_KLookUp, "deactivate keyboard looking mode");
+       Cmd_AddCommand ("+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
+       Cmd_AddCommand ("-mlook", IN_MLookUp, "deactivate mouse looking mode");
 
        // LordHavoc: added use button
-       Cmd_AddCommand ("+use", IN_UseDown);
-       Cmd_AddCommand ("-use", IN_UseUp);
+       Cmd_AddCommand ("+use", IN_UseDown, "use something (may be used by some mods)");
+       Cmd_AddCommand ("-use", IN_UseUp, "stop using something");
 
        // LordHavoc: added 6 new buttons
-       Cmd_AddCommand ("+button3", IN_Button3Down);
-       Cmd_AddCommand ("-button3", IN_Button3Up);
-       Cmd_AddCommand ("+button4", IN_Button4Down);
-       Cmd_AddCommand ("-button4", IN_Button4Up);
-       Cmd_AddCommand ("+button5", IN_Button5Down);
-       Cmd_AddCommand ("-button5", IN_Button5Up);
-       Cmd_AddCommand ("+button6", IN_Button6Down);
-       Cmd_AddCommand ("-button6", IN_Button6Up);
-       Cmd_AddCommand ("+button7", IN_Button7Down);
-       Cmd_AddCommand ("-button7", IN_Button7Up);
-       Cmd_AddCommand ("+button8", IN_Button8Down);
-       Cmd_AddCommand ("-button8", IN_Button8Up);
-       Cmd_AddCommand ("+button9", IN_Button9Down);
-       Cmd_AddCommand ("-button9", IN_Button9Up);
-       Cmd_AddCommand ("+button10", IN_Button10Down);
-       Cmd_AddCommand ("-button10", IN_Button10Up);
-       Cmd_AddCommand ("+button11", IN_Button11Down);
-       Cmd_AddCommand ("-button11", IN_Button11Up);
-       Cmd_AddCommand ("+button12", IN_Button12Down);
-       Cmd_AddCommand ("-button12", IN_Button12Up);
-       Cmd_AddCommand ("+button13", IN_Button13Down);
-       Cmd_AddCommand ("-button13", IN_Button13Up);
-       Cmd_AddCommand ("+button14", IN_Button14Down);
-       Cmd_AddCommand ("-button14", IN_Button14Up);
-       Cmd_AddCommand ("+button15", IN_Button15Down);
-       Cmd_AddCommand ("-button15", IN_Button15Up);
-       Cmd_AddCommand ("+button16", IN_Button16Down);
-       Cmd_AddCommand ("-button16", IN_Button16Up);
+       Cmd_AddCommand ("+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
+       Cmd_AddCommand ("-button3", IN_Button3Up, "deactivate button3");
+       Cmd_AddCommand ("+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button4", IN_Button4Up, "deactivate button3");
+       Cmd_AddCommand ("+button5", IN_Button5Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button5", IN_Button5Up, "deactivate button3");
+       Cmd_AddCommand ("+button6", IN_Button6Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button6", IN_Button6Up, "deactivate button3");
+       Cmd_AddCommand ("+button7", IN_Button7Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button7", IN_Button7Up, "deactivate button3");
+       Cmd_AddCommand ("+button8", IN_Button8Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button8", IN_Button8Up, "deactivate button3");
+       Cmd_AddCommand ("+button9", IN_Button9Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button9", IN_Button9Up, "deactivate button3");
+       Cmd_AddCommand ("+button10", IN_Button10Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button10", IN_Button10Up, "deactivate button3");
+       Cmd_AddCommand ("+button11", IN_Button11Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button11", IN_Button11Up, "deactivate button3");
+       Cmd_AddCommand ("+button12", IN_Button12Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button12", IN_Button12Up, "deactivate button3");
+       Cmd_AddCommand ("+button13", IN_Button13Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button13", IN_Button13Up, "deactivate button3");
+       Cmd_AddCommand ("+button14", IN_Button14Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button14", IN_Button14Up, "deactivate button3");
+       Cmd_AddCommand ("+button15", IN_Button15Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button15", IN_Button15Up, "deactivate button3");
+       Cmd_AddCommand ("+button16", IN_Button16Down, "activate button4 (behavior depends on mod)");
+       Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button3");
 
        Cvar_RegisterVariable(&cl_movement);
        Cvar_RegisterVariable(&cl_movement_latency);
index 3151111..5299c4d 100644 (file)
--- a/cl_main.c
+++ b/cl_main.c
@@ -29,46 +29,46 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 // we need to declare some mouse variables here, because the menu system
 // references them even when on a unix system.
 
-cvar_t csqc_progname = {0, "csqc_progname","csprogs.dat"};     //[515]: csqc crc check and right csprogs name according to progs.dat
-cvar_t csqc_progcrc = {CVAR_READONLY, "csqc_progcrc","0"};
+cvar_t csqc_progname = {0, "csqc_progname","csprogs.dat","name of csprogs.dat file to load"};  //[515]: csqc crc check and right csprogs name according to progs.dat
+cvar_t csqc_progcrc = {CVAR_READONLY, "csqc_progcrc","0","CRC of csprogs.dat file to load"};
 
-cvar_t cl_shownet = {0, "cl_shownet","0"};
-cvar_t cl_nolerp = {0, "cl_nolerp", "0"};
+cvar_t cl_shownet = {0, "cl_shownet","0","1 = print packet size, 2 = print packet message list"};
+cvar_t cl_nolerp = {0, "cl_nolerp", "0","network update smoothing"};
 
-cvar_t cl_itembobheight = {0, "cl_itembobheight", "0"}; // try 8
-cvar_t cl_itembobspeed = {0, "cl_itembobspeed", "0.5"};
+cvar_t cl_itembobheight = {0, "cl_itembobheight", "0","how much items bob up and down (try 8)"};
+cvar_t cl_itembobspeed = {0, "cl_itembobspeed", "0.5","how frequently items bob up and down"};
 
-cvar_t lookspring = {CVAR_SAVE, "lookspring","0"};
-cvar_t lookstrafe = {CVAR_SAVE, "lookstrafe","0"};
-cvar_t sensitivity = {CVAR_SAVE, "sensitivity","3", 1, 30};
+cvar_t lookspring = {CVAR_SAVE, "lookspring","0","returns pitch to level with the floor when no longer holding a pitch key"};
+cvar_t lookstrafe = {CVAR_SAVE, "lookstrafe","0","move instead of turning"};
+cvar_t sensitivity = {CVAR_SAVE, "sensitivity","3","mouse speed multiplier"};
 
-cvar_t m_pitch = {CVAR_SAVE, "m_pitch","0.022"};
-cvar_t m_yaw = {CVAR_SAVE, "m_yaw","0.022"};
-cvar_t m_forward = {CVAR_SAVE, "m_forward","1"};
-cvar_t m_side = {CVAR_SAVE, "m_side","0.8"};
+cvar_t m_pitch = {CVAR_SAVE, "m_pitch","0.022","mouse pitch speed multiplier"};
+cvar_t m_yaw = {CVAR_SAVE, "m_yaw","0.022","mouse yaw speed multiplier"};
+cvar_t m_forward = {CVAR_SAVE, "m_forward","1","mouse forward speed multiplier"};
+cvar_t m_side = {CVAR_SAVE, "m_side","0.8","mouse side speed multiplier"};
 
-cvar_t freelook = {CVAR_SAVE, "freelook", "1"};
+cvar_t freelook = {CVAR_SAVE, "freelook", "1","mouse controls pitch instead of forward/back"};
 
-cvar_t r_draweffects = {0, "r_draweffects", "1"};
+cvar_t r_draweffects = {0, "r_draweffects", "1","renders temporary sprite effects"};
 
-cvar_t cl_explosions_alpha_start = {CVAR_SAVE, "cl_explosions_alpha_start", "1.5"};
-cvar_t cl_explosions_alpha_end = {CVAR_SAVE, "cl_explosions_alpha_end", "0"};
-cvar_t cl_explosions_size_start = {CVAR_SAVE, "cl_explosions_size_start", "16"};
-cvar_t cl_explosions_size_end = {CVAR_SAVE, "cl_explosions_size_end", "128"};
-cvar_t cl_explosions_lifetime = {CVAR_SAVE, "cl_explosions_lifetime", "0.5"};
+cvar_t cl_explosions_alpha_start = {CVAR_SAVE, "cl_explosions_alpha_start", "1.5","starting alpha of an explosion shell"};
+cvar_t cl_explosions_alpha_end = {CVAR_SAVE, "cl_explosions_alpha_end", "0","end alpha of an explosion shell (just before it disappears)"};
+cvar_t cl_explosions_size_start = {CVAR_SAVE, "cl_explosions_size_start", "16","starting size of an explosion shell"};
+cvar_t cl_explosions_size_end = {CVAR_SAVE, "cl_explosions_size_end", "128","ending alpha of an explosion shell (just before it disappears)"};
+cvar_t cl_explosions_lifetime = {CVAR_SAVE, "cl_explosions_lifetime", "0.5","how long an explosion shell lasts"};
 
-cvar_t cl_stainmaps = {CVAR_SAVE, "cl_stainmaps", "1"};
-cvar_t cl_stainmaps_clearonload = {CVAR_SAVE, "cl_stainmaps_clearonload", "1"};
+cvar_t cl_stainmaps = {CVAR_SAVE, "cl_stainmaps", "1","stains lightmaps, much faster than decals but blurred"};
+cvar_t cl_stainmaps_clearonload = {CVAR_SAVE, "cl_stainmaps_clearonload", "1","clear stainmaps on map restart"};
 
-cvar_t cl_beams_polygons = {CVAR_SAVE, "cl_beams_polygons", "1"};
-cvar_t cl_beams_relative = {CVAR_SAVE, "cl_beams_relative", "1"};
-cvar_t cl_beams_lightatend = {CVAR_SAVE, "cl_beams_lightatend", "0"};
+cvar_t cl_beams_polygons = {CVAR_SAVE, "cl_beams_polygons", "1","use beam polygons instead of models"};
+cvar_t cl_beams_relative = {CVAR_SAVE, "cl_beams_relative", "1","beams are relative to owner (smooth sweeps)"};
+cvar_t cl_beams_lightatend = {CVAR_SAVE, "cl_beams_lightatend", "0","make a light at the end of the beam"};
 
-cvar_t cl_noplayershadow = {CVAR_SAVE, "cl_noplayershadow", "0"};
+cvar_t cl_noplayershadow = {CVAR_SAVE, "cl_noplayershadow", "0","hide player shadow"};
 
-cvar_t cl_prydoncursor = {0, "cl_prydoncursor", "0"};
+cvar_t cl_prydoncursor = {0, "cl_prydoncursor", "0", "enables a mouse pointer which is able to click on entities in the world, useful for point and click mods, see PRYDON_CLIENTCURSOR extension in dpextensions.qc"};
 
-cvar_t cl_deathnoviewmodel = {0, "cl_deathnoviewmodel", "1"};
+cvar_t cl_deathnoviewmodel = {0, "cl_deathnoviewmodel", "1", "hides gun model when dead"};
 
 vec3_t cl_playerstandmins;
 vec3_t cl_playerstandmaxs;
@@ -1671,17 +1671,17 @@ void CL_Init (void)
        Cvar_RegisterVariable (&cl_itembobspeed);
        Cvar_RegisterVariable (&cl_itembobheight);
 
-       Cmd_AddCommand ("entities", CL_PrintEntities_f);
-       Cmd_AddCommand ("disconnect", CL_Disconnect_f);
-       Cmd_AddCommand ("record", CL_Record_f);
-       Cmd_AddCommand ("stop", CL_Stop_f);
-       Cmd_AddCommand ("playdemo", CL_PlayDemo_f);
-       Cmd_AddCommand ("timedemo", CL_TimeDemo_f);
+       Cmd_AddCommand ("entities", CL_PrintEntities_f, "print information on network entities known to client");
+       Cmd_AddCommand ("disconnect", CL_Disconnect_f, "disconnect from server (or disconnect all clients if running a server)");
+       Cmd_AddCommand ("record", CL_Record_f, "record a demo");
+       Cmd_AddCommand ("stop", CL_Stop_f, "stop recording or playing a demo");
+       Cmd_AddCommand ("playdemo", CL_PlayDemo_f, "watch a demo file");
+       Cmd_AddCommand ("timedemo", CL_TimeDemo_f, "play back a demo as fast as possible and save statistics to benchmark.log");
 
-       Cmd_AddCommand ("fog", CL_Fog_f);
+       Cmd_AddCommand ("fog", CL_Fog_f, "set global fog parameters (density red green blue)");
 
        // LordHavoc: added pausedemo
-       Cmd_AddCommand ("pausedemo", CL_PauseDemo_f);
+       Cmd_AddCommand ("pausedemo", CL_PauseDemo_f, "pause demo playback (can also safely pause demo recording if using QUAKE, QUAKEDP or NEHAHRAMOVIE protocol, useful for making movies)");
 
        Cvar_RegisterVariable(&r_draweffects);
        Cvar_RegisterVariable(&cl_explosions_alpha_start);
@@ -1700,7 +1700,7 @@ void CL_Init (void)
 
        Cvar_RegisterVariable(&cl_deathnoviewmodel);
 
-       Cmd_AddCommand("timerefresh", CL_TimeRefresh_f);
+       Cmd_AddCommand("timerefresh", CL_TimeRefresh_f, "turn quickly and print rendering statistcs");
 
        CL_Parse_Init();
        CL_Particles_Init();
index 9021405..6b0c31f 100644 (file)
@@ -97,8 +97,8 @@ char *svc_strings[128] =
 
 //=============================================================================
 
-cvar_t demo_nehahra = {0, "demo_nehahra", "0"};
-cvar_t developer_networkentities = {0, "developer_networkentities", "0"};
+cvar_t demo_nehahra = {0, "demo_nehahra", "0", "reads all quake demos as nehahra movie protocol"};
+cvar_t developer_networkentities = {0, "developer_networkentities", "0", "prints received entities, value is 0-4 (higher for more info)"};
 
 /*
 ==================
index 3fccb93..fcd0a22 100644 (file)
@@ -309,27 +309,27 @@ static int                        cl_numparticles;
 static int                     cl_freeparticle;
 static particle_t      *particles;
 
-cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1"};
-cvar_t cl_particles_quality = {CVAR_SAVE, "cl_particles_quality", "1"};
-cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1"};
-cvar_t cl_particles_quake = {CVAR_SAVE, "cl_particles_quake", "0"};
-cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1"};
-cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1"};
-cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"};
-cvar_t cl_particles_blood_bloodhack = {CVAR_SAVE, "cl_particles_blood_bloodhack", "1"};
-cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"};
-cvar_t cl_particles_explosions_bubbles = {CVAR_SAVE, "cl_particles_explosions_bubbles", "1"};
-cvar_t cl_particles_explosions_smoke = {CVAR_SAVE, "cl_particles_explosions_smokes", "0"};
-cvar_t cl_particles_explosions_sparks = {CVAR_SAVE, "cl_particles_explosions_sparks", "1"};
-cvar_t cl_particles_explosions_shell = {CVAR_SAVE, "cl_particles_explosions_shell", "0"};
-cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"};
-cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5"};
-cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55"};
-cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"};
-cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"};
-cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "0"};
-cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "0"};
-cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "20"};
+cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1", "enables particle effects"};
+cvar_t cl_particles_quality = {CVAR_SAVE, "cl_particles_quality", "1", "multiplies number of particles and reduces their alpha"};
+cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1", "multiplies particle size"};
+cvar_t cl_particles_quake = {CVAR_SAVE, "cl_particles_quake", "0", "makes particle effects look mostly like the ones in Quake"};
+cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1", "enables blood shower effects"};
+cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1", "enables blood effects"};
+cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5", "opacity of blood"};
+cvar_t cl_particles_blood_bloodhack = {CVAR_SAVE, "cl_particles_blood_bloodhack", "1", "make certain quake particle() calls create blood effects instead"};
+cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1", "enables bulletimpact effects"};
+cvar_t cl_particles_explosions_bubbles = {CVAR_SAVE, "cl_particles_explosions_bubbles", "1", "enables bubbles from underwater explosions"};
+cvar_t cl_particles_explosions_smoke = {CVAR_SAVE, "cl_particles_explosions_smokes", "0", "enables smoke from explosions"};
+cvar_t cl_particles_explosions_sparks = {CVAR_SAVE, "cl_particles_explosions_sparks", "1", "enables sparks from explosions"};
+cvar_t cl_particles_explosions_shell = {CVAR_SAVE, "cl_particles_explosions_shell", "0", "enables polygonal shell from explosions"};
+cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1", "enables smoke (used by multiple effects)"};
+cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5", "smoke brightness"};
+cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55", "brightness fade per second"};
+cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1", "enables sparks (used by multiple effects)"};
+cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1", "enables bubbles (used by multiple effects)"};
+cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "0", "enables decals (bullet holes, blood, etc)"};
+cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "0", "how long before decals start to fade away"};
+cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "20", "how long decals take to fade away"};
 
 void CL_Particles_Clear(void)
 {
@@ -360,7 +360,7 @@ void CL_Particles_Init (void)
        else
                cl_maxparticles = MAX_PARTICLES;
 
-       Cmd_AddCommand ("pointfile", CL_ReadPointFile_f);
+       Cmd_AddCommand ("pointfile", CL_ReadPointFile_f, "display point file produced by qbsp when a leak was detected in the map (a line leading through the leak hole, to an entity inside the level)");
 
        Cvar_RegisterVariable (&cl_particles);
        Cvar_RegisterVariable (&cl_particles_quality);
@@ -1709,7 +1709,7 @@ static rtexture_t *particlefonttexture;
 #endif
 static particletexture_t particletexture[MAX_PARTICLETEXTURES];
 
-static cvar_t r_drawparticles = {0, "r_drawparticles", "1"};
+static cvar_t r_drawparticles = {0, "r_drawparticles", "1", "enables drawing of particles"};
 
 #define PARTICLETEXTURESIZE 64
 #define PARTICLEFONTSIZE (PARTICLETEXTURESIZE*8)
index 20f4ac7..d862eaf 100644 (file)
@@ -5,32 +5,32 @@
 #include "cl_collision.h"
 #include "csprogs.h"
 
-cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100"};
-cvar_t scr_fov = {CVAR_SAVE, "fov","90"};      // 1 - 170
-cvar_t scr_conspeed = {CVAR_SAVE, "scr_conspeed","900"}; // LordHavoc: quake used 300
-cvar_t scr_conalpha = {CVAR_SAVE, "scr_conalpha", "1"};
-cvar_t scr_conbrightness = {CVAR_SAVE, "scr_conbrightness", "0.2"};
-cvar_t scr_conforcewhiledisconnected = {CVAR_SAVE, "scr_conforcewhiledisconnected", "1"};
-cvar_t scr_centertime = {0, "scr_centertime","2"};
-cvar_t scr_showram = {CVAR_SAVE, "showram","1"};
-cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0"};
-cvar_t scr_showpause = {CVAR_SAVE, "showpause","1"};
-cvar_t scr_showbrand = {0, "showbrand","0"};
-cvar_t scr_printspeed = {0, "scr_printspeed","8"};
-cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640"};
-cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480"};
-cvar_t vid_pixelheight = {CVAR_SAVE, "vid_pixelheight", "1"};
-cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1"};
-cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9"};
-cvar_t scr_screenshot_gamma = {CVAR_SAVE, "scr_screenshot_gamma","2.2"};
+cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"};
+cvar_t scr_fov = {CVAR_SAVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"};      // 1 - 170
+cvar_t scr_conspeed = {CVAR_SAVE, "scr_conspeed","900", "speed of console open/close"}; // LordHavoc: quake used 300
+cvar_t scr_conalpha = {CVAR_SAVE, "scr_conalpha", "1", "opacity of console background"};
+cvar_t scr_conbrightness = {CVAR_SAVE, "scr_conbrightness", "0.2", "brightness of console background (0 = black, 1 = image)"};
+cvar_t scr_conforcewhiledisconnected = {CVAR_SAVE, "scr_conforcewhiledisconnected", "1", "forces fullscreen console while disconnected"};
+cvar_t scr_centertime = {0, "scr_centertime","2", "how long centerprint messages show"};
+cvar_t scr_showram = {CVAR_SAVE, "showram","1", "show ram icon if low on surface cache memory (not used)"};
+cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0", "show turtle icon when framerate is too low (not used)"};
+cvar_t scr_showpause = {CVAR_SAVE, "showpause","1" "show pause icon when game is paused"};
+cvar_t scr_showbrand = {0, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"};
+cvar_t scr_printspeed = {0, "scr_printspeed","8", "speed of intermission printing (episode end texts)"};
+cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640" "virtual width of 2D graphics system"};
+cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480", "virtual height of 2D graphics system"};
+cvar_t vid_pixelheight = {CVAR_SAVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"};
+cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa"};
+cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"};
+cvar_t scr_screenshot_gamma = {CVAR_SAVE, "scr_screenshot_gamma","2.2", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"};
 // scr_screenshot_name is defined in fs.c
-cvar_t cl_capturevideo = {0, "cl_capturevideo", "0"};
-cvar_t cl_capturevideo_sound = {0, "cl_capturevideo_sound", "0"};
-cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30"};
-cvar_t cl_capturevideo_rawrgb = {0, "cl_capturevideo_rawrgb", "0"};
-cvar_t cl_capturevideo_rawyv12 = {0, "cl_capturevideo_rawyv12", "0"};
-cvar_t r_textshadow = {0, "r_textshadow", "0"};
-cvar_t r_letterbox = {0, "r_letterbox", "0"};
+cvar_t cl_capturevideo = {0, "cl_capturevideo", "0", "enables saving of video to a file or files (default is .tga files, if scr_screenshot_jpeg is on it saves .jpg files (VERY SLOW), if any rawrgb or rawyv12 are on it saves those formats instead, note that scr_screenshot_gamma affects the brightness of the output)"};
+cvar_t cl_capturevideo_sound = {0, "cl_capturevideo_sound", "0", "enables saving of sound to a .wav file (warning: this requires exact sync, if your hard drive can't keep up it will abort, if your graphics can't keep up it will save duplicate frames to maintain sound sync)"};
+cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30", "how many frames per second to save (29.97 for NTSC, 30 for typical PC video, 15 can be useful)"};
+cvar_t cl_capturevideo_rawrgb = {0, "cl_capturevideo_rawrgb", "0", "saves a single .rgb video file containing raw RGB images (you'll need special processing tools to encode this to something more useful)"};
+cvar_t cl_capturevideo_rawyv12 = {0, "cl_capturevideo_rawyv12", "0", "saves a single .yv12 video file containing raw YV12 (luma plane, then half resolution chroma planes, first chroma blue then chroma red, this is the format used internally by many encoders, some tools can read it directly)"};
+cvar_t r_textshadow = {0, "r_textshadow", "0" "draws a shadow on all text to improve readability"};
+cvar_t r_letterbox = {0, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"};
 
 int jpeg_supported = false;
 
@@ -618,10 +618,10 @@ void CL_Screen_Init(void)
        Cvar_RegisterVariable (&r_textshadow);
        Cvar_RegisterVariable (&r_letterbox);
 
-       Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
-       Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
-       Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
-       Cmd_AddCommand ("envmap", R_Envmap_f);
+       Cmd_AddCommand ("sizeup",SCR_SizeUp_f, "increase view size (increases viewsize cvar)");
+       Cmd_AddCommand ("sizedown",SCR_SizeDown_f, "decrease view size (decreases viewsize cvar)");
+       Cmd_AddCommand ("screenshot",SCR_ScreenShot_f, "takes a screenshot of the next rendered frame");
+       Cmd_AddCommand ("envmap", R_Envmap_f, "render a cubemap (skybox) of the current scene");
 
        scr_initialized = true;
 }
index 8433239..c969eaa 100644 (file)
@@ -314,8 +314,8 @@ void CL_Video_Init( void )
        cl_videogmask = BigLong(0x00FF0000);
        cl_videobmask = BigLong(0x0000FF00);
 
-       Cmd_AddCommand( "playvideo", CL_PlayVideo_f );
-       Cmd_AddCommand( "stopvideo", CL_StopVideo_f );
+       Cmd_AddCommand( "playvideo", CL_PlayVideo_f, "play a .dpv video file" );
+       Cmd_AddCommand( "stopvideo", CL_StopVideo_f, "stop playing a .dpv video file" );
 
        R_RegisterModule( "CL_Video", cl_video_start, cl_video_shutdown, cl_video_newmap );
 }
index f6b8ea3..0393f5d 100644 (file)
@@ -1424,10 +1424,10 @@ void VM_CL_registercmd (void)
        {
                t = Z_Malloc(strlen(PRVM_G_STRING(OFS_PARM0))+1);
                strcpy(t, PRVM_G_STRING(OFS_PARM0));
-               Cmd_AddCommand(t, NULL);
+               Cmd_AddCommand(t, NULL, "console command created by QuakeC");
        }
        else
-               Cmd_AddCommand(PRVM_G_STRING(OFS_PARM0), NULL);
+               Cmd_AddCommand(PRVM_G_STRING(OFS_PARM0), NULL, "console command created by QuakeC");
 
 }
 
diff --git a/cmd.c b/cmd.c
index de0a772..a985130 100644 (file)
--- a/cmd.c
+++ b/cmd.c
@@ -386,6 +386,7 @@ typedef struct cmd_function_s
 {
        struct cmd_function_s *next;
        const char *name;
+       const char *description;
        xcommand_t function;
        qboolean csqcfunc;
 } cmd_function_t;
@@ -530,7 +531,7 @@ static void Cmd_List_f (void)
        {
                if (partial && strncmp(partial, cmd->name, len))
                        continue;
-               Con_Printf("%s\n", cmd->name);
+               Con_Printf("%s : %s\n", cmd->name, cmd->description);
                count++;
        }
 
@@ -559,17 +560,19 @@ void Cmd_Init_Commands (void)
 //
 // register our commands
 //
-       Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f);
-       Cmd_AddCommand ("exec",Cmd_Exec_f);
-       Cmd_AddCommand ("echo",Cmd_Echo_f);
-       Cmd_AddCommand ("alias",Cmd_Alias_f);
-       Cmd_AddCommand ("cmd", Cmd_ForwardToServer);
-       Cmd_AddCommand ("wait", Cmd_Wait_f);
-       Cmd_AddCommand ("cmdlist", Cmd_List_f);         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
-       Cmd_AddCommand ("cvarlist", Cvar_List_f);       // 2000-01-09 CmdList, CvarList commands
-                                                                                               // By Matthias "Maddes" Buecher
-       Cmd_AddCommand ("set", Cvar_Set_f);
-       Cmd_AddCommand ("seta", Cvar_SetA_f);
+       Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)");
+       Cmd_AddCommand ("exec",Cmd_Exec_f, "execute a script file");
+       Cmd_AddCommand ("echo",Cmd_Echo_f, "print a message to the console (useful in scripts)");
+       Cmd_AddCommand ("alias",Cmd_Alias_f, "create a script function (parameters are passed in as $1 through $9, and $* for all parameters)");
+       Cmd_AddCommand ("cmd", Cmd_ForwardToServer, "send a console commandline to the server (used by some mods)");
+       Cmd_AddCommand ("wait", Cmd_Wait_f, "make script execution wait for next rendered frame");
+       Cmd_AddCommand ("set", Cvar_Set_f, "create or change the value of a console variable");
+       Cmd_AddCommand ("seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg");
+
+       // 2000-01-09 CmdList, CvarList commands By Matthias "Maddes" Buecher
+       // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
+       Cmd_AddCommand ("cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix");
+       Cmd_AddCommand ("cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix");
 }
 
 /*
@@ -680,7 +683,7 @@ static void Cmd_TokenizeString (const char *text)
 Cmd_AddCommand
 ============
 */
-void Cmd_AddCommand (const char *cmd_name, xcommand_t function)
+void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description)
 {
        cmd_function_t *cmd;
        cmd_function_t *prev, *current;
@@ -713,6 +716,7 @@ void Cmd_AddCommand (const char *cmd_name, xcommand_t function)
        cmd = (cmd_function_t *)Mem_Alloc(cmd_mempool, sizeof(cmd_function_t));
        cmd->name = cmd_name;
        cmd->function = function;
+       cmd->description = description;
        if(!function)                   //[515]: csqc
                cmd->csqcfunc = true;
        cmd->next = cmd_functions;
@@ -762,7 +766,7 @@ const char *Cmd_CompleteCommand (const char *partial)
 
 // check functions
        for (cmd = cmd_functions; cmd; cmd = cmd->next)
-               if (!strncmp(partial, cmd->name, len))
+               if (!strncasecmp(partial, cmd->name, len))
                        return cmd->name;
 
        return NULL;
@@ -825,6 +829,17 @@ const char **Cmd_CompleteBuildList (const char *partial)
        return buf;
 }
 
+// written by LordHavoc
+void Cmd_CompleteCommandPrint (const char *partial)
+{
+       cmd_function_t *cmd;
+       size_t len = strlen(partial);
+       // Loop through the command list and print all matches
+       for (cmd = cmd_functions; cmd; cmd = cmd->next)
+               if (!strncasecmp(partial, cmd->name, len))
+                       Con_Printf("%s : %s\n", cmd->name, cmd->description);
+}
+
 /*
        Cmd_CompleteAlias
 
@@ -852,6 +867,18 @@ const char *Cmd_CompleteAlias (const char *partial)
        return NULL;
 }
 
+// written by LordHavoc
+void Cmd_CompleteAliasPrint (const char *partial)
+{
+       cmdalias_t *alias;
+       size_t len = strlen(partial);
+       // Loop through the alias list and print all matches
+       for (alias = cmd_alias; alias; alias = alias->next)
+               if (!strncasecmp(partial, alias->name, len))
+                       Con_Printf("%s : %s\n", alias->name, alias->value);
+}
+
+
 /*
        Cmd_CompleteAliasCountPossible
 
diff --git a/cmd.h b/cmd.h
index 3ee7865..f7d9d17 100644 (file)
--- a/cmd.h
+++ b/cmd.h
@@ -86,7 +86,7 @@ extern cmd_source_t cmd_source;
 void Cmd_Init (void);
 void Cmd_Shutdown (void);
 
-void Cmd_AddCommand (const char *cmd_name, xcommand_t function);
+void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description);
 // called by the init functions of other parts of the program to
 // register commands and functions to call for them.
 // The cmd_name is referenced later, so it should not be in temp memory
@@ -106,8 +106,12 @@ int Cmd_CompleteCountPossible (const char *partial);
 
 const char **Cmd_CompleteBuildList (const char *partial);
 
+void Cmd_CompleteCommandPrint (const char *partial);
+
 const char *Cmd_CompleteAlias (const char *partial);
 
+void Cmd_CompleteAliasPrint (const char *partial);
+
 // Enhanced console completion by Fett erich@heintz.com
 
 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
index 6800f05..32d5395 100644 (file)
@@ -5,11 +5,11 @@
 #define COLLISION_SNAPSCALE (8.0f)
 #define COLLISION_SNAP (1.0f / COLLISION_SNAPSCALE)
 
-cvar_t collision_impactnudge = {0, "collision_impactnudge", "0.03125"};
-cvar_t collision_startnudge = {0, "collision_startnudge", "0"};
-cvar_t collision_endnudge = {0, "collision_endnudge", "0"};
-cvar_t collision_enternudge = {0, "collision_enternudge", "0"};
-cvar_t collision_leavenudge = {0, "collision_leavenudge", "0"};
+cvar_t collision_impactnudge = {0, "collision_impactnudge", "0.03125", "how much to back off from the impact"};
+cvar_t collision_startnudge = {0, "collision_startnudge", "0", "how much to bias collision trace start"};
+cvar_t collision_endnudge = {0, "collision_endnudge", "0", "how much to bias collision trace end"};
+cvar_t collision_enternudge = {0, "collision_enternudge", "0", "how much to bias collision entry fraction"};
+cvar_t collision_leavenudge = {0, "collision_leavenudge", "0", "how much to bias collision exit fraction"};
 
 void Collision_Init (void)
 {
index e7c5acc..80bd2a4 100644 (file)
--- a/common.c
+++ b/common.c
@@ -27,8 +27,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
-cvar_t registered = {0, "registered","0"};
-cvar_t cmdline = {0, "cmdline","0"};
+cvar_t registered = {0, "registered","0", "indicates if this is running registered quake (whether gfx/qpop.lmp was found)"};
+cvar_t cmdline = {0, "cmdline","0", "contains commandline the engine was launched with"};
 
 extern qboolean fs_modified;   // set true if using non-id files
 
index 6754b08..15fc723 100644 (file)
--- a/console.c
+++ b/console.c
@@ -41,10 +41,9 @@ int con_current;
 int con_x;
 char con_text[CON_TEXTSIZE];
 
-//seconds
-cvar_t con_notifytime = {CVAR_SAVE, "con_notifytime","3"};
-cvar_t con_notify = {CVAR_SAVE, "con_notify","4"};
-cvar_t con_textsize = {CVAR_SAVE, "con_textsize","8"}; //[515]: console text size in pixels
+cvar_t con_notifytime = {CVAR_SAVE, "con_notifytime","3", "how long notify lines last, in seconds"};
+cvar_t con_notify = {CVAR_SAVE, "con_notify","4", "how many notify lines to show (0-32)"};
+cvar_t con_textsize = {CVAR_SAVE, "con_textsize","8", "console text size in virtual 2D pixels"};       //[515]: console text size in pixels
 
 #define MAX_NOTIFYLINES 32
 // cl.time time the line was generated for transparent notify lines
@@ -63,7 +62,7 @@ LOGGING
 ==============================================================================
 */
 
-cvar_t log_file = {0, "log_file",""};
+cvar_t log_file = {0, "log_file","", "filename to log messages to"};
 char crt_log_file [MAX_OSPATH] = "";
 qfile_t* logfile = NULL;
 
@@ -409,11 +408,11 @@ void Con_Init_Commands (void)
        Cvar_RegisterVariable (&con_textsize);
 
        // register our commands
-       Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
-       Cmd_AddCommand ("messagemode", Con_MessageMode_f);
-       Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
-       Cmd_AddCommand ("clear", Con_Clear_f);
-       Cmd_AddCommand ("maps", Con_Maps_f);                                                    // By [515]
+       Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f, "opens or closes the console");
+       Cmd_AddCommand ("messagemode", Con_MessageMode_f, "input a chat message to say to everyone");
+       Cmd_AddCommand ("messagemode2", Con_MessageMode2_f, "input a chat message to say to only your team");
+       Cmd_AddCommand ("clear", Con_Clear_f, "clear console history");
+       Cmd_AddCommand ("maps", Con_Maps_f, "list information about available maps");   // By [515]
 
        con_initialized = true;
        Con_Print("Console initialized.\n");
@@ -1123,10 +1122,25 @@ void Con_CompleteCommandLine (void)
                        }
                }
 
-       // Count number of possible matches
+       // Count number of possible matches and print them
        c = Cmd_CompleteCountPossible(s);
+       if (c)
+       {
+               Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
+               Cmd_CompleteCommandPrint(s);
+       }
        v = Cvar_CompleteCountPossible(s);
+       if (v)
+       {
+               Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
+               Cvar_CompleteCvarPrint(s);
+       }
        a = Cmd_CompleteAliasCountPossible(s);
+       if (a)
+       {
+               Con_Printf("\n%i possible aliases%s\n", a, (a > 1) ? "s: " : ":");
+               Cmd_CompleteAliasPrint(s);
+       }
 
        if (!(c + v + a))       // No possible matches
        {
@@ -1135,76 +1149,48 @@ void Con_CompleteCommandLine (void)
                return;
        }
 
-       if (c + v + a == 1) {
-               if (c)
-                       list[0] = Cmd_CompleteBuildList(s);
-               else if (v)
-                       list[0] = Cvar_CompleteBuildList(s);
-               else
-                       list[0] = Cmd_CompleteAliasBuildList(s);
-               cmd = *list[0];
-               cmd_len = (int)strlen (cmd);
-       } else {
-               if (c)
-                       cmd = *(list[0] = Cmd_CompleteBuildList(s));
-               if (v)
-                       cmd = *(list[1] = Cvar_CompleteBuildList(s));
-               if (a)
-                       cmd = *(list[2] = Cmd_CompleteAliasBuildList(s));
-
-               cmd_len = (int)strlen (s);
-               do {
-                       for (i = 0; i < 3; i++) {
-                               char ch = cmd[cmd_len];
-                               const char **l = list[i];
-                               if (l) {
-                                       while (*l && (*l)[cmd_len] == ch)
-                                               l++;
-                                       if (*l)
-                                               break;
-                               }
-                       }
-                       if (i == 3)
-                               cmd_len++;
-               } while (i == 3);
-               // 'quakebar'
-               Con_Print("\n\35");
-               for (i = 0; i < con_linewidth - 4; i++)
-                       Con_Print("\36");
-               Con_Print("\37\n");
-
-               // Print Possible Commands
-               if (c) {
-                       Con_Printf("%i possible command%s\n", c, (c > 1) ? "s: " : ":");
-                       Con_DisplayList(list[0]);
-               }
-
-               if (v) {
-                       Con_Printf("%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
-                       Con_DisplayList(list[1]);
-               }
+       if (c)
+               cmd = *(list[0] = Cmd_CompleteBuildList(s));
+       if (v)
+               cmd = *(list[1] = Cvar_CompleteBuildList(s));
+       if (a)
+               cmd = *(list[2] = Cmd_CompleteAliasBuildList(s));
 
-               if (a) {
-                       Con_Printf("%i possible aliases%s\n", a, (a > 1) ? "s: " : ":");
-                       Con_DisplayList(list[2]);
+       for (cmd_len = (int)strlen(s);;cmd_len++)
+       {
+               const char **l;
+               for (i = 0; i < 3; i++)
+                       if (list[i])
+                               for (l = list[i];*l;l++)
+                                       if ((*l)[cmd_len] != cmd[cmd_len])
+                                               goto done;
+               // all possible matches share this character, so we continue...
+               if (!cmd[cmd_len])
+               {
+                       // if all matches ended at the same position, stop
+                       // (this means there is only one match)
+                       break;
                }
        }
+done:
 
-       if (cmd) {
-               strncpy(key_lines[edit_line] + pos, cmd, cmd_len);
-               key_linepos = cmd_len + pos;
-               if (c + v + a == 1) {
-                       key_lines[edit_line][key_linepos] = ' ';
-                       key_linepos++;
-               }
-               if(s2[0])
-                       strcpy(&key_lines[edit_line][key_linepos], s2);
-               else
-                       key_lines[edit_line][key_linepos] = 0;
+       // prevent a buffer overrun by limiting cmd_len according to remaining space
+       cmd_len = min(cmd_len, (int)sizeof(key_lines[edit_line]) - 1 - pos);
+       if (cmd)
+       {
+               key_linepos = pos;
+               memcpy(&key_lines[edit_line][key_linepos], cmd, cmd_len);
+               key_linepos += cmd_len;
+               // if there is only one match, add a space after it
+               if (c + v + a == 1 && key_linepos < (int)sizeof(key_lines[edit_line]) - 1)
+                       key_lines[edit_line][key_linepos++] = ' ';
        }
-       else
-               if(s2[0])
-                       strcpy(&key_lines[edit_line][key_linepos], s2);
+
+       // use strlcat to avoid a buffer overrun
+       key_lines[edit_line][key_linepos] = 0;
+       strlcat(key_lines[edit_line], s2, sizeof(key_lines[edit_line]));
+
+       // free the command, cvar, and alias lists
        for (i = 0; i < 3; i++)
                if (list[i])
                        Mem_Free((void *)list[i]);
diff --git a/cvar.c b/cvar.c
index 655d91d..4c91a49 100644 (file)
--- a/cvar.c
+++ b/cvar.c
@@ -191,6 +191,18 @@ const char **Cvar_CompleteBuildList (const char *partial)
        return buf;
 }
 
+// written by LordHavoc
+void Cvar_CompleteCvarPrint (const char *partial)
+{
+       cvar_t *cvar;
+       size_t len = strlen(partial);
+       // Loop through the command list and print all matches
+       for (cvar = cvar_vars; cvar; cvar = cvar->next)
+               if (!strncasecmp(partial, cvar->name, len))
+                       Con_Printf("%s : %s (%s) : %s\n", cvar->name, cvar->value, cvar->defstring, cvar->description);
+}
+
+
 /*
 ============
 Cvar_Set
diff --git a/cvar.h b/cvar.h
index ef56415..fbf3b96 100644 (file)
--- a/cvar.h
+++ b/cvar.h
@@ -109,6 +109,7 @@ typedef struct cvar_s
        char *name;
 
        char *string;
+       char *description;
        int integer;
        float value;
        float vector[3];
@@ -154,6 +155,8 @@ const char *Cvar_CompleteVariable (const char *partial);
 // attempts to match a partial variable name for command line completion
 // returns NULL if nothing fits
 
+void Cvar_CompleteCvarPrint (const char *partial);
+
 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
diff --git a/fs.c b/fs.c
index 0b03310..a0fdcde 100644 (file)
--- a/fs.c
+++ b/fs.c
@@ -273,7 +273,7 @@ char fs_basedir[MAX_OSPATH];
 
 qboolean fs_modified;   // set true if using non-id files
 
-cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp"};
+cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running)"};
 
 
 /*
@@ -1058,9 +1058,9 @@ void FS_Init_Commands(void)
 {
        Cvar_RegisterVariable (&scr_screenshot_name);
 
-       Cmd_AddCommand ("path", FS_Path_f);
-       Cmd_AddCommand ("dir", FS_Dir_f);
-       Cmd_AddCommand ("ls", FS_Ls_f);
+       Cmd_AddCommand ("path", FS_Path_f, "print searchpath (game directories and archives)");
+       Cmd_AddCommand ("dir", FS_Dir_f, "list files in searchpath matching an * filename pattern, one per line");
+       Cmd_AddCommand ("ls", FS_Ls_f, "list files in searchpath matching an * filename pattern, multiple per line");
 
        // set the default screenshot name to either the mod name or the
        // gamemode screenshot name
index 9e12d56..13efbd3 100644 (file)
@@ -4,22 +4,22 @@
 #include "jpeg.h"
 #include "cl_collision.h"
 
-cvar_t gl_mesh_drawrangeelements = {0, "gl_mesh_drawrangeelements", "1"};
-cvar_t gl_mesh_testarrayelement = {0, "gl_mesh_testarrayelement", "0"};
-cvar_t gl_mesh_testmanualfeeding = {0, "gl_mesh_testmanualfeeding", "0"};
-cvar_t gl_paranoid = {0, "gl_paranoid", "0"};
-cvar_t gl_printcheckerror = {0, "gl_printcheckerror", "0"};
-cvar_t r_stereo_separation = {0, "r_stereo_separation", "4"};
-cvar_t r_stereo_sidebyside = {0, "r_stereo_sidebyside", "0"};
-cvar_t r_stereo_redblue = {0, "r_stereo_redblue", "0"};
-cvar_t r_stereo_redcyan = {0, "r_stereo_redcyan", "0"};
-cvar_t r_stereo_redgreen = {0, "r_stereo_redgreen", "0"};
-
-cvar_t r_render = {0, "r_render", "1"};
-cvar_t r_waterwarp = {CVAR_SAVE, "r_waterwarp", "1"};
-cvar_t gl_polyblend = {CVAR_SAVE, "gl_polyblend", "1"};
-cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1"}; // whether or not to use dithering
-cvar_t gl_lockarrays = {0, "gl_lockarrays", "1"};
+cvar_t gl_mesh_drawrangeelements = {0, "gl_mesh_drawrangeelements", "1", "use glDrawRangeElements function if available instead of glDrawElements (for performance comparisons or bug testing)"};
+cvar_t gl_mesh_testarrayelement = {0, "gl_mesh_testarrayelement", "0", "use glBegin(GL_TRIANGLES);glArrayElement();glEnd(); primitives instead of glDrawElements (useful to test for driver bugs with glDrawElements)"};
+cvar_t gl_mesh_testmanualfeeding = {0, "gl_mesh_testmanualfeeding", "0", "use glBegin(GL_TRIANGLES);glTexCoord2f();glVertex3f();glEnd(); primitives instead of glDrawElements (useful to test for driver bugs with glDrawElements)"};
+cvar_t gl_paranoid = {0, "gl_paranoid", "0", "enables OpenGL error checking and other tests"};
+cvar_t gl_printcheckerror = {0, "gl_printcheckerror", "0", "prints all OpenGL error checks, useful to identify location of driver crashes"};
+cvar_t r_stereo_separation = {0, "r_stereo_separation", "4", "separation of eyes in the world (try negative values too)"};
+cvar_t r_stereo_sidebyside = {0, "r_stereo_sidebyside", "0", "side by side views (for those who can't afford glasses but can afford eye strain)"};
+cvar_t r_stereo_redblue = {0, "r_stereo_redblue", "0", "red/blue anaglyph stereo glasses (note: most of these glasses are actually red/cyan, try that one too)"};
+cvar_t r_stereo_redcyan = {0, "r_stereo_redcyan", "0", "red/cyan anaglyph stereo glasses, the kind given away at drive-in movies like Creature From The Black Lagoon In 3D"};
+cvar_t r_stereo_redgreen = {0, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"};
+
+cvar_t r_render = {0, "r_render", "1", "enables rendering calls (you want this on!)"};
+cvar_t r_waterwarp = {CVAR_SAVE, "r_waterwarp", "1", "warp view while underwater"};
+cvar_t gl_polyblend = {CVAR_SAVE, "gl_polyblend", "1", "tints view while underwater, hurt, etc"};
+cvar_t gl_dither = {CVAR_SAVE, "gl_dither", "1", "enables OpenGL dithering (16bit looks bad with this off)"};
+cvar_t gl_lockarrays = {0, "gl_lockarrays", "1", "enables use of glLockArraysEXT, may cause glitches with some broken drivers"};
 
 int gl_maxdrawrangeelementsvertices;
 int gl_maxdrawrangeelementsindices;
@@ -210,10 +210,10 @@ static void gl_backend_newmap(void)
 {
 }
 
-cvar_t scr_zoomwindow = {CVAR_SAVE, "scr_zoomwindow", "0"};
-cvar_t scr_zoomwindow_viewsizex = {CVAR_SAVE, "scr_zoomwindow_viewsizex", "20"};
-cvar_t scr_zoomwindow_viewsizey = {CVAR_SAVE, "scr_zoomwindow_viewsizey", "20"};
-cvar_t scr_zoomwindow_fov = {CVAR_SAVE, "scr_zoomwindow_fov", "20"};
+cvar_t scr_zoomwindow = {CVAR_SAVE, "scr_zoomwindow", "0", "displays a zoomed in overlay window"};
+cvar_t scr_zoomwindow_viewsizex = {CVAR_SAVE, "scr_zoomwindow_viewsizex", "20", "horizontal viewsize of zoom window"};
+cvar_t scr_zoomwindow_viewsizey = {CVAR_SAVE, "scr_zoomwindow_viewsizey", "20", "vertical viewsize of zoom window"};
+cvar_t scr_zoomwindow_fov = {CVAR_SAVE, "scr_zoomwindow_fov", "20", "fov of zoom window"};
 
 void gl_backend_init(void)
 {
index c821610..991690c 100644 (file)
@@ -69,44 +69,44 @@ matrix4x4_t r_view_matrix;
 //
 refdef_t r_refdef;
 
-cvar_t r_showtris = {0, "r_showtris", "0"};
-cvar_t r_shownormals = {0, "r_shownormals", "0"};
-cvar_t r_drawentities = {0, "r_drawentities","1"};
-cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
-cvar_t r_speeds = {0, "r_speeds","0"};
-cvar_t r_fullbright = {0, "r_fullbright","0"};
-cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1"};
-cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1"};
-cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1"};
-cvar_t r_drawcollisionbrushes = {0, "r_drawcollisionbrushes", "0"};
-
-cvar_t gl_fogenable = {0, "gl_fogenable", "0"};
-cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25"};
-cvar_t gl_fogred = {0, "gl_fogred","0.3"};
-cvar_t gl_foggreen = {0, "gl_foggreen","0.3"};
-cvar_t gl_fogblue = {0, "gl_fogblue","0.3"};
-cvar_t gl_fogstart = {0, "gl_fogstart", "0"};
-cvar_t gl_fogend = {0, "gl_fogend","0"};
-
-cvar_t r_textureunits = {0, "r_textureunits", "32"};
-
-cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1"};
-cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1"};
-cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1"};
-
-cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0"};
-cvar_t r_bloom_intensity = {CVAR_SAVE, "r_bloom_intensity", "1.5"};
-cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4"};
-cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320"};
-cvar_t r_bloom_power = {CVAR_SAVE, "r_bloom_power", "2"};
-
-cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1"};
-
-cvar_t developer_texturelogging = {0, "developer_texturelogging", "0"};
-
-cvar_t gl_lightmaps = {0, "gl_lightmaps", "0"};
-
-cvar_t r_test = {0, "r_test", "0"}; // used for testing renderer code changes, otherwise does nothing
+cvar_t r_showtris = {0, "r_showtris", "0", "shows triangle outlines, value controls brightness (can be above 1)"};
+cvar_t r_shownormals = {0, "r_shownormals", "0", "shows per-vertex surface normals and tangent vectors for bumpmapped lighting"};
+cvar_t r_drawentities = {0, "r_drawentities","1", "draw entities (doors, players, projectiles, etc)"};
+cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1", "draw your weapon model"};
+cvar_t r_speeds = {0, "r_speeds","0", "displays rendering statistics and per-subsystem timings"};
+cvar_t r_fullbright = {0, "r_fullbright","0", "make everything bright cheat (not allowed in multiplayer)"};
+cvar_t r_wateralpha = {CVAR_SAVE, "r_wateralpha","1", "opacity of water polygons"};
+cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1", "enables dynamic lights (rocket glow and such)"};
+cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};
+cvar_t r_drawcollisionbrushes = {0, "r_drawcollisionbrushes", "0", "draws collision brushes in quake3 maps (mode 1), mode 2 disables rendering of world (trippy!)"};
+
+cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"};
+cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"};
+cvar_t gl_fogred = {0, "gl_fogred","0.3", "nehahra fog color red value (for Nehahra compatibility only)"};
+cvar_t gl_foggreen = {0, "gl_foggreen","0.3", "nehahra fog color green value (for Nehahra compatibility only)"};
+cvar_t gl_fogblue = {0, "gl_fogblue","0.3", "nehahra fog color blue value (for Nehahra compatibility only)"};
+cvar_t gl_fogstart = {0, "gl_fogstart", "0", "nehahra fog start distance (for Nehahra compatibility only)"};
+cvar_t gl_fogend = {0, "gl_fogend","0", "nehahra fog end distance (for Nehahra compatibility only)"};
+
+cvar_t r_textureunits = {0, "r_textureunits", "32", "number of hardware texture units reported by driver (note: setting this to 1 turns off gl_combine)"};
+
+cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"};
+cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"};
+cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1", "makes water scroll around, value controls how much"};
+
+cvar_t r_bloom = {CVAR_SAVE, "r_bloom", "0", "enables bloom effect (makes bright pixels affect neighboring pixels)"};
+cvar_t r_bloom_intensity = {CVAR_SAVE, "r_bloom_intensity", "1.5", "how bright the glow is"};
+cvar_t r_bloom_blur = {CVAR_SAVE, "r_bloom_blur", "4", "how large the glow is"};
+cvar_t r_bloom_resolution = {CVAR_SAVE, "r_bloom_resolution", "320", "what resolution to perform the bloom effect at (independent of screen resolution)"};
+cvar_t r_bloom_power = {CVAR_SAVE, "r_bloom_power", "2", "how much to darken the image before blurring to make the bloom effect"};
+
+cvar_t r_smoothnormals_areaweighting = {0, "r_smoothnormals_areaweighting", "1", "uses significantly faster (and supposedly higher quality) area-weighted vertex normals and tangent vectors rather than summing normalized triangle normals and tangents"};
+
+cvar_t developer_texturelogging = {0, "developer_texturelogging", "0", "produces a textures.log file containing names of skins and map textures the engine tried to load"};
+
+cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture (for level designers)"};
+
+cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"}; // used for testing renderer code changes, otherwise does nothing
 
 rtexturepool_t *r_main_texturepool;
 rtexture_t *r_bloom_texture_screen;
index 412536a..292f1e7 100644 (file)
@@ -25,14 +25,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #define MAX_LIGHTMAP_SIZE 256
 
-cvar_t r_ambient = {0, "r_ambient", "0"};
-cvar_t r_drawportals = {0, "r_drawportals", "0"};
-cvar_t r_lockpvs = {0, "r_lockpvs", "0"};
-cvar_t r_lockvisibility = {0, "r_lockvisibility", "0"};
-cvar_t r_useportalculling = {0, "r_useportalculling", "1"};
-cvar_t r_drawcollisionbrushes_polygonfactor = {0, "r_drawcollisionbrushes_polygonfactor", "-1"};
-cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "0"};
-cvar_t r_q3bsp_renderskydepth = {0, "r_q3bsp_renderskydepth", "0"};
+cvar_t r_ambient = {0, "r_ambient", "0", "brighter world cheat (not allowed in multiplayer), value is 0-128"};
+cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"};
+cvar_t r_lockpvs = {0, "r_lockpvs", "0", "disables pvs switching, allows you to walk around and inspect what is visible from a given location in the map (anything not visible from your current location will not be drawn)"};
+cvar_t r_lockvisibility = {0, "r_lockvisibility", "0", "disables visibility updates, allows you to walk around and inspect what is visible from a given viewpoint in the map (anything offscreen at the moment this is enabled will not be drawn)"};
+cvar_t r_useportalculling = {0, "r_useportalculling", "1", "use advanced portal culling visibility method to improve performance over just Potentially Visible Set, provides an even more significant speed improvement in unvised maps"};
+cvar_t r_drawcollisionbrushes_polygonfactor = {0, "r_drawcollisionbrushes_polygonfactor", "-1", "expands outward the brush polygons a little bit, used to make collision brushes appear infront of walls"};
+cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "0", "nudges brush polygon depth in hardware depth units, used to make collision brushes appear infront of walls"};
+cvar_t r_q3bsp_renderskydepth = {0, "r_q3bsp_renderskydepth", "0", "draws sky depth masking in q3 maps (as in q1 maps), this means for example that sky polygons can hide other things"};
 
 // flag arrays used for visibility checking on world model
 // (all other entities have no per-surface/per-leaf visibility checks)
@@ -950,8 +950,8 @@ void GL_Surf_Init(void)
        Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonoffset);
        Cvar_RegisterVariable(&r_q3bsp_renderskydepth);
 
-       Cmd_AddCommand ("r_replacemaptexture", R_ReplaceWorldTexture);          // By [515]
-       Cmd_AddCommand ("r_listmaptextures", R_ListWorldTextures);                      // By [515]
+       Cmd_AddCommand ("r_replacemaptexture", R_ReplaceWorldTexture, "override a map texture for testing purposes");   // By [515]
+       Cmd_AddCommand ("r_listmaptextures", R_ListWorldTextures, "list all textures used by the current map"); // By [515]
 
        //R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap);
 }
index b59ff81..0e5812b 100644 (file)
@@ -4,12 +4,12 @@
 #include "jpeg.h"
 #include "image_png.h"
 
-cvar_t gl_max_size = {CVAR_SAVE, "gl_max_size", "2048"};
-cvar_t gl_max_scrapsize = {CVAR_SAVE, "gl_max_scrapsize", "256"};
-cvar_t gl_picmip = {CVAR_SAVE, "gl_picmip", "0"};
-cvar_t r_lerpimages = {CVAR_SAVE, "r_lerpimages", "1"};
-cvar_t r_precachetextures = {CVAR_SAVE, "r_precachetextures", "1"};
-cvar_t  gl_texture_anisotropy = {CVAR_SAVE, "gl_texture_anisotropy", "1"};
+cvar_t gl_max_size = {CVAR_SAVE, "gl_max_size", "2048", "maximum allowed texture size, can be used to reduce video memory usage, note: this is automatically reduced to match video card capabilities (such as 256 on 3Dfx cards before Voodoo4/5)"};
+cvar_t gl_max_scrapsize = {CVAR_SAVE, "gl_max_scrapsize", "256", "size of scrap textures used to combine lightmaps"};
+cvar_t gl_picmip = {CVAR_SAVE, "gl_picmip", "0", "reduces resolution of textures by powers of 2, for example 1 will halve width/height, reducing texture memory usage by 75%"};
+cvar_t r_lerpimages = {CVAR_SAVE, "r_lerpimages", "1", "bilinear filters images when scaling them up to power of 2 size (mode 1), looks better than glquake (mode 0)"};
+cvar_t r_precachetextures = {CVAR_SAVE, "r_precachetextures", "1", "0 = never upload textures until used, 1 = upload most textures before use (exceptions: rarely used skin colormap layers), 2 = upload all textures before use (can increase texture memory usage significantly)"};
+cvar_t gl_texture_anisotropy = {CVAR_SAVE, "gl_texture_anisotropy", "1", "anisotropic filtering quality (if supported by hardware), 1 sample (no anisotropy) and 8 sample (8 tap anisotropy) are recommended values"};
 
 int            gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
 int            gl_filter_mag = GL_LINEAR;
@@ -537,8 +537,8 @@ static void r_textures_newmap(void)
 
 void R_Textures_Init (void)
 {
-       Cmd_AddCommand("gl_texturemode", &GL_TextureMode_f);
-       Cmd_AddCommand("r_texturestats", R_TextureStats_f);
+       Cmd_AddCommand("gl_texturemode", &GL_TextureMode_f, "set texture filtering mode (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, etc)");
+       Cmd_AddCommand("r_texturestats", R_TextureStats_f, "print information about all loaded textures and some statistics");
        Cvar_RegisterVariable (&gl_max_scrapsize);
        Cvar_RegisterVariable (&gl_max_size);
        Cvar_RegisterVariable (&gl_picmip);
diff --git a/host.c b/host.c
index 1064e9c..3d52666 100644 (file)
--- a/host.c
+++ b/host.c
@@ -60,41 +60,41 @@ client_t *host_client;
 jmp_buf host_abortframe;
 
 // pretend frames take this amount of time (in seconds), 0 = realtime
-cvar_t host_framerate = {0, "host_framerate","0"};
+cvar_t host_framerate = {0, "host_framerate","0", "locks frame timing to this value in seconds, 0.05 is 20fps for example, note that this can easily run too fast, use host_maxfps if you want to limit your framerate instead, or sys_ticrate to limit server speed"};
 // shows time used by certain subsystems
-cvar_t host_speeds = {0, "host_speeds","0"};
+cvar_t host_speeds = {0, "host_speeds","0", "reports how much time is used in server/graphics/sound"};
 // LordHavoc: framerate independent slowmo
-cvar_t slowmo = {0, "slowmo", "1.0"};
+cvar_t slowmo = {0, "slowmo", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
 // LordHavoc: framerate upper cap
-cvar_t cl_maxfps = {CVAR_SAVE, "cl_maxfps", "1000"};
+cvar_t cl_maxfps = {CVAR_SAVE, "cl_maxfps", "1000", "maximum fps cap, if game is running faster than this it will wait before running another frame (useful to make cpu time available to other programs)"};
 
 // print broadcast messages in dedicated mode
-cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1"};
+cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1", "prints gamecode bprint() calls to server console"};
 
-cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.05"};
-cvar_t sv_fixedframeratesingleplayer = {0, "sv_fixedframeratesingleplayer", "0"};
-cvar_t serverprofile = {0, "serverprofile","0"};
+cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.05", "how long a server frame is in seconds, 0.05 is 20fps server rate, 0.1 is 10fps (can not be set higher than 0.1), 0 runs as many server frames as possible (makes games against bots a little smoother, overwhelms network players)"};
+cvar_t sv_fixedframeratesingleplayer = {0, "sv_fixedframeratesingleplayer", "0", "allows you to use server-style timing system in singleplayer (don't run faster than sys_ticrate)"};
+cvar_t serverprofile = {0, "serverprofile","0", "print some timings on server code"};
 
-cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0"};
-cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0"};
-cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0"};
+cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};
+cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};
+cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0", "teamplay mode, values depend on mod but typically 0 = no teams, 1 = no team damage no self damage, 2 = team damage and self damage, some mods support 3 = no team damage but can damage self"};
 
-cvar_t samelevel = {0, "samelevel","0"};
-cvar_t noexit = {CVAR_NOTIFY, "noexit","0"};
+cvar_t samelevel = {CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
+cvar_t noexit = {CVAR_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};
 
-cvar_t developer = {0, "developer","0"};
-cvar_t developer_entityparsing = {0, "developer_entityparsing", "0"};
+cvar_t developer = {0, "developer","0", "prints additional debugging messages and information (recommended for modders and level designers)"};
+cvar_t developer_entityparsing = {0, "developer_entityparsing", "0", "prints detailed network entities information each time a packet is received"};
 
-cvar_t skill = {0, "skill","1"};
-cvar_t deathmatch = {0, "deathmatch","0"};
-cvar_t coop = {0, "coop","0"};
+cvar_t skill = {0, "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 deathmatch = {0, "deathmatch","0", "deathmatch mode, values depend on mod but typically 0 = no deathmatch, 1 = normal deathmatch with respawning weapons, 2 = weapons stay (players can only pick up new weapons)"};
+cvar_t coop = {0, "coop","0", "coop mode, 0 = no coop, 1 = coop mode, multiple players playing through the singleplayer game (coop mode also shuts off deathmatch)"};
 
-cvar_t pausable = {0, "pausable","1"};
+cvar_t pausable = {0, "pausable","1", "allow players to pause or not"};
 
-cvar_t temp1 = {0, "temp1","0"};
+cvar_t temp1 = {0, "temp1","0", "general cvar for mods to use, in stock id1 this selects which death animation to use on players (0 = random death, other values select specific death scenes)"};
 
-cvar_t timestamps = {CVAR_SAVE, "timestamps", "0"};
-cvar_t timeformat = {CVAR_SAVE, "timeformat", "[%b %e %X] "};
+cvar_t timestamps = {CVAR_SAVE, "timestamps", "0", "prints timestamps on console messages"};
+cvar_t timeformat = {CVAR_SAVE, "timeformat", "[%b %e %X] ", "time format to use on timestamped console messages"};
 
 /*
 ================
@@ -218,7 +218,7 @@ Host_InitLocal
 void Host_SaveConfig_f(void);
 void Host_InitLocal (void)
 {
-       Cmd_AddCommand("saveconfig", Host_SaveConfig_f);
+       Cmd_AddCommand("saveconfig", Host_SaveConfig_f, "save settings to config.cfg immediately (also automatic when quitting)");
 
        Cvar_RegisterVariable (&host_framerate);
        Cvar_RegisterVariable (&host_speeds);
index e0fbfe0..f2db17f 100644 (file)
@@ -21,7 +21,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "quakedef.h"
 
 int current_skill;
-cvar_t sv_cheats = {0, "sv_cheats", "0"};
+cvar_t sv_cheats = {0, "sv_cheats", "0", "enables cheat commands in any game, and cheat impulses in dpmod"};
 qboolean allowcheats = false;
 
 /*
@@ -725,7 +725,7 @@ void Host_Loadgame_f (void)
 Host_Name_f
 ======================
 */
-cvar_t cl_name = {CVAR_SAVE, "_cl_name", "player"};
+cvar_t cl_name = {CVAR_SAVE, "_cl_name", "player", "internal storage cvar for current player name (changed by name command)"};
 void Host_Name_f (void)
 {
        int i, j;
@@ -783,7 +783,7 @@ void Host_Name_f (void)
 Host_Playermodel_f
 ======================
 */
-cvar_t cl_playermodel = {CVAR_SAVE, "_cl_playermodel", ""};
+cvar_t cl_playermodel = {CVAR_SAVE, "_cl_playermodel", "", "internal storage cvar for current player model in Nexuiz (changed by playermodel command)"};
 // the old cl_playermodel in cl_main has been renamed to __cl_playermodel
 void Host_Playermodel_f (void)
 {
@@ -843,7 +843,7 @@ void Host_Playermodel_f (void)
 Host_Playerskin_f
 ======================
 */
-cvar_t cl_playerskin = {CVAR_SAVE, "_cl_playerskin", ""};
+cvar_t cl_playerskin = {CVAR_SAVE, "_cl_playerskin", "", "internal storage cvar for current player skin in Nexuiz (changed by playerskin command)"};
 void Host_Playerskin_f (void)
 {
        int i, j;
@@ -1048,7 +1048,7 @@ void Host_Tell_f(void)
 Host_Color_f
 ==================
 */
-cvar_t cl_color = {CVAR_SAVE, "_cl_color", "0"};
+cvar_t cl_color = {CVAR_SAVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"};
 void Host_Color_f(void)
 {
        int             top, bottom;
@@ -1119,7 +1119,7 @@ void Host_Color_f(void)
        }
 }
 
-cvar_t cl_rate = {CVAR_SAVE, "_cl_rate", "10000"};
+cvar_t cl_rate = {CVAR_SAVE, "_cl_rate", "10000", "internal storage cvar for current rate (changed by rate command)"};
 void Host_Rate_f(void)
 {
        int rate;
@@ -1201,7 +1201,7 @@ LordHavoc: only supported for Nehahra, I personally think this is dumb, but Mind
 LordHavoc: correction, Mindcrime will be removing pmodel in the future, but it's still stuck here for compatibility.
 ======================
 */
-cvar_t cl_pmodel = {CVAR_SAVE, "_cl_pmodel", "0"};
+cvar_t cl_pmodel = {CVAR_SAVE, "_cl_pmodel", "0", "internal storage cvar for current player model number in nehahra (changed by pmodel command)"};
 static void Host_PModel_f (void)
 {
        int i;
@@ -1940,73 +1940,73 @@ Host_InitCommands
 */
 void Host_InitCommands (void)
 {
-       Cmd_AddCommand ("status", Host_Status_f);
-       Cmd_AddCommand ("quit", Host_Quit_f);
+       Cmd_AddCommand ("status", Host_Status_f, "print server status information");
+       Cmd_AddCommand ("quit", Host_Quit_f, "quit the game");
        if (gamemode == GAME_NEHAHRA)
        {
-               Cmd_AddCommand ("max", Host_God_f);
-               Cmd_AddCommand ("monster", Host_Notarget_f);
-               Cmd_AddCommand ("scrag", Host_Fly_f);
-               Cmd_AddCommand ("wraith", Host_Noclip_f);
-               Cmd_AddCommand ("gimme", Host_Give_f);
+               Cmd_AddCommand ("max", Host_God_f, "god mode (invulnerability)");
+               Cmd_AddCommand ("monster", Host_Notarget_f, "notarget mode (monsters do not see you)");
+               Cmd_AddCommand ("scrag", Host_Fly_f, "fly mode (flight)");
+               Cmd_AddCommand ("wraith", Host_Noclip_f, "noclip mode (flight without collisions, move through walls)");
+               Cmd_AddCommand ("gimme", Host_Give_f, "alter inventory");
        }
        else
        {
-               Cmd_AddCommand ("god", Host_God_f);
-               Cmd_AddCommand ("notarget", Host_Notarget_f);
-               Cmd_AddCommand ("fly", Host_Fly_f);
-               Cmd_AddCommand ("noclip", Host_Noclip_f);
-               Cmd_AddCommand ("give", Host_Give_f);
-       }
-       Cmd_AddCommand ("map", Host_Map_f);
-       Cmd_AddCommand ("restart", Host_Restart_f);
-       Cmd_AddCommand ("changelevel", Host_Changelevel_f);
-       Cmd_AddCommand ("connect", Host_Connect_f);
-       Cmd_AddCommand ("reconnect", Host_Reconnect_f);
-       Cmd_AddCommand ("version", Host_Version_f);
-       Cmd_AddCommand ("say", Host_Say_f);
-       Cmd_AddCommand ("say_team", Host_Say_Team_f);
-       Cmd_AddCommand ("tell", Host_Tell_f);
-       Cmd_AddCommand ("kill", Host_Kill_f);
-       Cmd_AddCommand ("pause", Host_Pause_f);
-       Cmd_AddCommand ("kick", Host_Kick_f);
-       Cmd_AddCommand ("ping", Host_Ping_f);
-       Cmd_AddCommand ("load", Host_Loadgame_f);
-       Cmd_AddCommand ("save", Host_Savegame_f);
-
-       Cmd_AddCommand ("startdemos", Host_Startdemos_f);
-       Cmd_AddCommand ("demos", Host_Demos_f);
-       Cmd_AddCommand ("stopdemo", Host_Stopdemo_f);
-
-       Cmd_AddCommand ("viewmodel", Host_Viewmodel_f);
-       Cmd_AddCommand ("viewframe", Host_Viewframe_f);
-       Cmd_AddCommand ("viewnext", Host_Viewnext_f);
-       Cmd_AddCommand ("viewprev", Host_Viewprev_f);
+               Cmd_AddCommand ("god", Host_God_f, "god mode (invulnerability)");
+               Cmd_AddCommand ("notarget", Host_Notarget_f, "notarget mode (monsters do not see you)");
+               Cmd_AddCommand ("fly", Host_Fly_f, "fly mode (flight)");
+               Cmd_AddCommand ("noclip", Host_Noclip_f, "noclip mode (flight without collisions, move through walls)");
+               Cmd_AddCommand ("give", Host_Give_f, "alter inventory");
+       }
+       Cmd_AddCommand ("map", Host_Map_f, "kick everyone off the server and start a new level");
+       Cmd_AddCommand ("restart", Host_Restart_f, "restart current level");
+       Cmd_AddCommand ("changelevel", Host_Changelevel_f, "change to another level, bringing along all connected clients");
+       Cmd_AddCommand ("connect", Host_Connect_f, "connect to a server by IP address or hostname");
+       Cmd_AddCommand ("reconnect", Host_Reconnect_f, "reset signon level in preparation for a new level (do not use)");
+       Cmd_AddCommand ("version", Host_Version_f, "print engine version");
+       Cmd_AddCommand ("say", Host_Say_f, "send a chat message to everyone on the server");
+       Cmd_AddCommand ("say_team", Host_Say_Team_f, "send a chat message to your team on the server");
+       Cmd_AddCommand ("tell", Host_Tell_f, "send a chat message to only one person on the server");
+       Cmd_AddCommand ("kill", Host_Kill_f, "die instantly");
+       Cmd_AddCommand ("pause", Host_Pause_f, "pause the game (if the server allows pausing)");
+       Cmd_AddCommand ("kick", Host_Kick_f, "kick a player off the server by number or name");
+       Cmd_AddCommand ("ping", Host_Ping_f, "print ping times of all players on the server");
+       Cmd_AddCommand ("load", Host_Loadgame_f, "load a saved game file");
+       Cmd_AddCommand ("save", Host_Savegame_f, "save the game to a file");
+
+       Cmd_AddCommand ("startdemos", Host_Startdemos_f, "start playing back the selected demos sequentially (used at end of startup script)");
+       Cmd_AddCommand ("demos", Host_Demos_f, "restart looping demos defined by the last startdemos command");
+       Cmd_AddCommand ("stopdemo", Host_Stopdemo_f, "stop playing or recording demo (like stop command) and return to looping demos");
+
+       Cmd_AddCommand ("viewmodel", Host_Viewmodel_f, "change model of viewthing entity in current level");
+       Cmd_AddCommand ("viewframe", Host_Viewframe_f, "change animation frame of viewthing entity in current level");
+       Cmd_AddCommand ("viewnext", Host_Viewnext_f, "change to next animation frame of viewthing entity in current level");
+       Cmd_AddCommand ("viewprev", Host_Viewprev_f, "change to previous animation frame of viewthing entity in current level");
 
        Cvar_RegisterVariable (&cl_name);
-       Cmd_AddCommand ("name", Host_Name_f);
+       Cmd_AddCommand ("name", Host_Name_f, "change your player name");
        Cvar_RegisterVariable (&cl_color);
-       Cmd_AddCommand ("color", Host_Color_f);
+       Cmd_AddCommand ("color", Host_Color_f, "change your player shirt and pants colors");
        Cvar_RegisterVariable (&cl_rate);
-       Cmd_AddCommand ("rate", Host_Rate_f);
+       Cmd_AddCommand ("rate", Host_Rate_f, "change your network connection speed");
        if (gamemode == GAME_NEHAHRA)
        {
                Cvar_RegisterVariable (&cl_pmodel);
-               Cmd_AddCommand ("pmodel", Host_PModel_f);
+               Cmd_AddCommand ("pmodel", Host_PModel_f, "change your player model choice (Nehahra specific)");
        }
 
        // BLACK: This isnt game specific anymore (it was GAME_NEXUIZ at first)
        Cvar_RegisterVariable (&cl_playermodel);
-       Cmd_AddCommand ("playermodel", Host_Playermodel_f);
+       Cmd_AddCommand ("playermodel", Host_Playermodel_f, "change your player model");
        Cvar_RegisterVariable (&cl_playerskin);
-       Cmd_AddCommand ("playerskin", Host_Playerskin_f);
+       Cmd_AddCommand ("playerskin", Host_Playerskin_f, "change your player skin number");
 
-       Cmd_AddCommand ("prespawn", Host_PreSpawn_f);
-       Cmd_AddCommand ("spawn", Host_Spawn_f);
-       Cmd_AddCommand ("begin", Host_Begin_f);
-       Cmd_AddCommand ("maxplayers", MaxPlayers_f);
+       Cmd_AddCommand ("prespawn", Host_PreSpawn_f, "signon 1 (client acknowledges that server information has been received)");
+       Cmd_AddCommand ("spawn", Host_Spawn_f, "signon 2 (client has sent player information, and is asking server to send scoreboard rankings)");
+       Cmd_AddCommand ("begin", Host_Begin_f, "signon 3 (client asks server to start sending entities, and will go to signon 4 (playing) when the first entity update is received)");
+       Cmd_AddCommand ("maxplayers", MaxPlayers_f, "sets limit on how many players (or bots) may be connected to the server at once");
 
-       Cmd_AddCommand ("sendcvar", Host_SendCvar_f);                                   // By [515]
+       Cmd_AddCommand ("sendcvar", Host_SendCvar_f, "sends the value of a cvar to the server as a sentcvar command, for use by QuakeC");       // By [515]
 
        Cvar_RegisterVariable(&sv_cheats);
 }
diff --git a/keys.c b/keys.c
index b311d1e..2d6fd69 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -811,13 +811,13 @@ Key_Init (void)
 //
 // register our functions
 //
-       Cmd_AddCommand ("in_bind", Key_In_Bind_f);
-       Cmd_AddCommand ("in_unbind", Key_In_Unbind_f);
-       Cmd_AddCommand ("in_bindmap", Key_In_Bindmap_f);
+       Cmd_AddCommand ("in_bind", Key_In_Bind_f, "binds a command to the specified key in the selected bindmap");
+       Cmd_AddCommand ("in_unbind", Key_In_Unbind_f, "removes command on the specified key in the selected bindmap");
+       Cmd_AddCommand ("in_bindmap", Key_In_Bindmap_f, "selects active foreground and background (used only if a key is not bound in the foreground) bindmaps for typing");
 
-       Cmd_AddCommand ("bind", Key_Bind_f);
-       Cmd_AddCommand ("unbind", Key_Unbind_f);
-       Cmd_AddCommand ("unbindall", Key_Unbindall_f);
+       Cmd_AddCommand ("bind", Key_Bind_f, "binds a command to the specified key in bindmap 0");
+       Cmd_AddCommand ("unbind", Key_Unbind_f, "removes a command on the specified key in bindmap 0");
+       Cmd_AddCommand ("unbindall", Key_Unbindall_f, "removes all commands from all keys in all bindmaps (leaving only shift-escape and escape)");
 }
 
 const char *Key_GetBind (int key)
diff --git a/menu.c b/menu.c
index 52e6b9f..3f6b73b 100644 (file)
--- a/menu.c
+++ b/menu.c
@@ -2056,7 +2056,7 @@ void M_Options_Graphics_Key (int k, char ascii)
 int            options_colorcontrol_cursor;
 
 // intensity value to match up to 50% dither to 'correct' quake
-cvar_t menu_options_colorcontrol_correctionvalue = {0, "menu_options_colorcontrol_correctionvalue", "0.25"};
+cvar_t menu_options_colorcontrol_correctionvalue = {0, "menu_options_colorcontrol_correctionvalue", "0.25", "intensity value that matches up to white/black dither pattern, due to Quake's grey level being quite dark this is 0.25, other games may use other values"};
 
 void M_Menu_Options_ColorControl_f (void)
 {
@@ -4367,24 +4367,24 @@ void M_Init (void)
        menuplyr_load = true;
        menuplyr_pixels = NULL;
 
-       Cmd_AddCommand ("menu_main", M_Menu_Main_f);
-       Cmd_AddCommand ("menu_singleplayer", M_Menu_SinglePlayer_f);
-       Cmd_AddCommand ("menu_load", M_Menu_Load_f);
-       Cmd_AddCommand ("menu_save", M_Menu_Save_f);
-       Cmd_AddCommand ("menu_multiplayer", M_Menu_MultiPlayer_f);
-       Cmd_AddCommand ("menu_setup", M_Menu_Setup_f);
-       Cmd_AddCommand ("menu_options", M_Menu_Options_f);
-       Cmd_AddCommand ("menu_options_effects", M_Menu_Options_Effects_f);
-       Cmd_AddCommand ("menu_options_graphics", M_Menu_Options_Graphics_f);
-       Cmd_AddCommand ("menu_options_colorcontrol", M_Menu_Options_ColorControl_f);
-       Cmd_AddCommand ("menu_keys", M_Menu_Keys_f);
-       Cmd_AddCommand ("menu_video", M_Menu_Video_f);
-       Cmd_AddCommand ("menu_reset", M_Menu_Reset_f);
-       Cmd_AddCommand ("help", M_Menu_Help_f);
-       Cmd_AddCommand ("menu_quit", M_Menu_Quit_f);
-       Cmd_AddCommand ("menu_transfusion_episode", M_Menu_Transfusion_Episode_f);
-       Cmd_AddCommand ("menu_transfusion_skill", M_Menu_Transfusion_Skill_f);
-       Cmd_AddCommand ("menu_credits", M_Menu_Credits_f);
+       Cmd_AddCommand ("menu_main", M_Menu_Main_f, "open the main menu");
+       Cmd_AddCommand ("menu_singleplayer", M_Menu_SinglePlayer_f, "open the singleplayer menu");
+       Cmd_AddCommand ("menu_load", M_Menu_Load_f, "open the loadgame menu");
+       Cmd_AddCommand ("menu_save", M_Menu_Save_f, "open the savegame menu");
+       Cmd_AddCommand ("menu_multiplayer", M_Menu_MultiPlayer_f, "open the multiplayer menu");
+       Cmd_AddCommand ("menu_setup", M_Menu_Setup_f, "open the player setup menu");
+       Cmd_AddCommand ("menu_options", M_Menu_Options_f, "open the options menu");
+       Cmd_AddCommand ("menu_options_effects", M_Menu_Options_Effects_f, "open the effects options menu");
+       Cmd_AddCommand ("menu_options_graphics", M_Menu_Options_Graphics_f, "open the graphics options menu");
+       Cmd_AddCommand ("menu_options_colorcontrol", M_Menu_Options_ColorControl_f, "open the color control menu");
+       Cmd_AddCommand ("menu_keys", M_Menu_Keys_f, "open the key binding menu");
+       Cmd_AddCommand ("menu_video", M_Menu_Video_f, "open the video options menu");
+       Cmd_AddCommand ("menu_reset", M_Menu_Reset_f, "open the reset to defaults menu");
+       Cmd_AddCommand ("help", M_Menu_Help_f, "open the help menu");
+       Cmd_AddCommand ("menu_quit", M_Menu_Quit_f, "open the quit menu");
+       Cmd_AddCommand ("menu_transfusion_episode", M_Menu_Transfusion_Episode_f, "open the transfusion episode select menu");
+       Cmd_AddCommand ("menu_transfusion_skill", M_Menu_Transfusion_Skill_f, "open the transfusion skill select menu");
+       Cmd_AddCommand ("menu_credits", M_Menu_Credits_f, "open the credits menu");
 
        if (gamemode == GAME_TRANSFUSION)
        {
@@ -4881,7 +4881,7 @@ void MP_Restart(void)
 //============================================================================
 // Menu router
 
-static cvar_t forceqmenu = { 0, "forceqmenu", "0" };
+static cvar_t forceqmenu = { 0, "forceqmenu", "0", "enables the quake menu instead of the quakec menu.dat (if present)" };
 
 void (*MR_Keydown) (int key, char ascii);
 void (*MR_Draw) (void);
@@ -4947,9 +4947,9 @@ void MR_Init_Commands(void)
        Cvar_RegisterVariable (&forceqmenu);
        Cvar_RegisterVariable (&menu_options_colorcontrol_correctionvalue);
        if (gamemode == GAME_NETHERWORLD)
-               Cmd_AddCommand ("menu_fallback", MP_Fallback); //Force to old-style menu
-       Cmd_AddCommand ("menu_restart",MR_Restart);
-       Cmd_AddCommand ("togglemenu", Call_MR_ToggleMenu_f);
+               Cmd_AddCommand ("menu_fallback", MP_Fallback, "switch to engine menu (unload menu.dat)"); //Force to old-style menu
+       Cmd_AddCommand ("menu_restart",MR_Restart, "restart menu system (reloads menu.dat");
+       Cmd_AddCommand ("togglemenu", Call_MR_ToggleMenu_f, "opens or closes menu");
 }
 
 void MR_Init(void)
index a9b7ac0..6228d6d 100644 (file)
@@ -2,9 +2,9 @@
 #include "quakedef.h"
 #include "meshqueue.h"
 
-cvar_t r_meshqueue_entries = {CVAR_SAVE, "r_meshqueue_entries", "16"};
-cvar_t r_meshqueue_immediaterender = {0, "r_meshqueue_immediaterender", "0"};
-cvar_t r_meshqueue_sort = {0, "r_meshqueue_sort", "0"};
+cvar_t r_meshqueue_entries = {CVAR_SAVE, "r_meshqueue_entries", "16", "maximum number of meshes to batch together and sort before issuing render calls (unused)"};
+cvar_t r_meshqueue_immediaterender = {0, "r_meshqueue_immediaterender", "0", "immediately render non-transparent meshes rather than batching"};
+cvar_t r_meshqueue_sort = {0, "r_meshqueue_sort", "0", "whether to sort meshes in a batch before issuing calls"};
 
 typedef struct meshqueue_s
 {
index f0653b9..b27d805 100644 (file)
@@ -22,12 +22,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "image.h"
 #include "r_shadow.h"
 
-cvar_t r_skeletal_debugbone = {0, "r_skeletal_debugbone", "-1"};
-cvar_t r_skeletal_debugbonecomponent = {0, "r_skeletal_debugbonecomponent", "3"};
-cvar_t r_skeletal_debugbonevalue = {0, "r_skeletal_debugbonevalue", "100"};
-cvar_t r_skeletal_debugtranslatex = {0, "r_skeletal_debugtranslatex", "1"};
-cvar_t r_skeletal_debugtranslatey = {0, "r_skeletal_debugtranslatey", "1"};
-cvar_t r_skeletal_debugtranslatez = {0, "r_skeletal_debugtranslatez", "1"};
+cvar_t r_skeletal_debugbone = {0, "r_skeletal_debugbone", "-1", "development cvar for testing skeletal model code"};
+cvar_t r_skeletal_debugbonecomponent = {0, "r_skeletal_debugbonecomponent", "3", "development cvar for testing skeletal model code"};
+cvar_t r_skeletal_debugbonevalue = {0, "r_skeletal_debugbonevalue", "100", "development cvar for testing skeletal model code"};
+cvar_t r_skeletal_debugtranslatex = {0, "r_skeletal_debugtranslatex", "1", "development cvar for testing skeletal model code"};
+cvar_t r_skeletal_debugtranslatey = {0, "r_skeletal_debugtranslatey", "1", "development cvar for testing skeletal model code"};
+cvar_t r_skeletal_debugtranslatez = {0, "r_skeletal_debugtranslatez", "1", "development cvar for testing skeletal model code"};
 
 void Mod_AliasInit (void)
 {
index f37de5b..fb12604 100644 (file)
@@ -26,24 +26,24 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "wad.h"
 
 
-//cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128"};
-cvar_t halflifebsp = {0, "halflifebsp", "0"};
-cvar_t mcbsp = {0, "mcbsp", "0"};
-cvar_t r_novis = {0, "r_novis", "0"};
-cvar_t r_miplightmaps = {CVAR_SAVE, "r_miplightmaps", "0"};
-cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1"};
-cvar_t r_nosurftextures = {0, "r_nosurftextures", "0"};
-cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4"};
-cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1"};
-cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024"};
-cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536"};
-cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15"};
-cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1"};
-cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024"};
-cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225"};
-cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1"};
-cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1"};
-cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0"};
+//cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"};
+cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
+cvar_t mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp format (useful to know because of different bounding box sizes)"};
+cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};
+cvar_t r_miplightmaps = {CVAR_SAVE, "r_miplightmaps", "0", "mipmaps lightmaps on upload, also expanding them to power of 2 sizes, this runs slower"};
+cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"};
+cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"};
+cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"};
+cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
+cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"};
+cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"};
+cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
+cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
+cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
+cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
+cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"};
+cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"};
 
 void Mod_BrushInit(void)
 {
index 0565f20..2b9f947 100644 (file)
@@ -26,7 +26,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "image.h"
 #include "r_shadow.h"
 
-cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0"};
+cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0", "mipmaps skins (so they become blurrier in the distance), disabled by default because it tends to blur with strange border colors from the skin"};
 
 model_t *loadmodel;
 
@@ -95,8 +95,8 @@ void Mod_Init (void)
        Mod_SpriteInit();
 
        Cvar_RegisterVariable(&r_mipskins);
-       Cmd_AddCommand ("modellist", Mod_Print);
-       Cmd_AddCommand ("modelprecache", Mod_Precache);
+       Cmd_AddCommand ("modellist", Mod_Print, "prints a list of loaded models");
+       Cmd_AddCommand ("modelprecache", Mod_Precache, "load a model");
 }
 
 void Mod_RenderInit(void)
index 367d9e9..13b0798 100644 (file)
@@ -25,7 +25,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "quakedef.h"
 #include "image.h"
 
-cvar_t r_mipsprites = {CVAR_SAVE, "r_mipsprites", "1"};
+cvar_t r_mipsprites = {CVAR_SAVE, "r_mipsprites", "1", "mipmaps skins (so they become blurrier in the distance), unlike skins the sprites do not have strange border colors"};
 
 /*
 ===============
index 75f4a3d..baa77b6 100755 (executable)
--- a/netconn.c
+++ b/netconn.c
@@ -26,21 +26,21 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #define MASTER_PORT 27950
 
 // note this defaults on for dedicated servers, off for listen servers
-cvar_t sv_public = {0, "sv_public", "0"};
-static cvar_t sv_heartbeatperiod = {CVAR_SAVE, "sv_heartbeatperiod", "120"};
+cvar_t sv_public = {0, "sv_public", "0", "advertises this server on the master server (so that players can find it in the server browser)"};
+static cvar_t sv_heartbeatperiod = {CVAR_SAVE, "sv_heartbeatperiod", "120", "how often to send heartbeat in seconds (only used if sv_public is 1)"};
 
 // FIXME: resolve DNS on masters whenever their value changes and cache it (to avoid major delays in active servers when they heartbeat)
 static cvar_t sv_masters [] =
 {
-       {CVAR_SAVE, "sv_master1", ""},
-       {CVAR_SAVE, "sv_master2", ""},
-       {CVAR_SAVE, "sv_master3", ""},
-       {CVAR_SAVE, "sv_master4", ""},
-       {0, "sv_masterextra1", "ghdigital.com"}, // admin: LordHavoc
-       {0, "sv_masterextra2", "dpmaster.deathmask.net"}, // admin: Willis
-       {0, "sv_masterextra3", "12.166.196.192"}, // admin: Venim
-       {0, "sv_masterextra4", "excalibur.nvg.ntnu.no"}, // admin: tChr
-       {0, NULL, NULL}
+       {CVAR_SAVE, "sv_master1", "", "user-chosen master server 1"},
+       {CVAR_SAVE, "sv_master2", "", "user-chosen master server 2"},
+       {CVAR_SAVE, "sv_master3", "", "user-chosen master server 3"},
+       {CVAR_SAVE, "sv_master4", "", "user-chosen master server 4"},
+       {0, "sv_masterextra1", "ghdigital.com", "default master server 1 (admin: LordHavoc)"}, // admin: LordHavoc
+       {0, "sv_masterextra2", "dpmaster.deathmask.net", "default master server 2 (admin: Willis)"}, // admin: Willis
+       {0, "sv_masterextra3", "12.166.196.192", "default master server 3 (admin: Venim)"}, // admin: Venim
+       {0, "sv_masterextra4", "excalibur.nvg.ntnu.no", "default master server 4 (admin: tChr)"}, // admin: tChr
+       {0, NULL, NULL, NULL}
 };
 
 static double nextheartbeattime = 0;
@@ -48,18 +48,18 @@ static double nextheartbeattime = 0;
 sizebuf_t net_message;
 static unsigned char net_message_buf[NET_MAXMESSAGE];
 
-cvar_t net_messagetimeout = {0, "net_messagetimeout","300"};
-cvar_t net_messagerejointimeout = {0, "net_messagerejointimeout","10"};
-cvar_t net_connecttimeout = {0, "net_connecttimeout","10"};
-cvar_t hostname = {CVAR_SAVE, "hostname", "UNNAMED"};
-cvar_t developer_networking = {0, "developer_networking", "0"};
+cvar_t net_messagetimeout = {0, "net_messagetimeout","300", "drops players who have not sent any packets for this many seconds"};
+cvar_t net_messagerejointimeout = {0, "net_messagerejointimeout","10", "give a player this much time in seconds to rejoin and continue playing (not losing frags and such)"};
+cvar_t net_connecttimeout = {0, "net_connecttimeout","10", "after requesting a connection, the client must reply within this many seconds or be dropped (cuts down on connect floods)"};
+cvar_t hostname = {CVAR_SAVE, "hostname", "UNNAMED", "server message to show in server browser"};
+cvar_t developer_networking = {0, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"};
 
-cvar_t cl_netlocalping = {0, "cl_netlocalping","0"};
-static cvar_t cl_netpacketloss = {0, "cl_netpacketloss","0"};
-static cvar_t net_slist_queriespersecond = {0, "net_slist_queriespersecond", "20"};
-static cvar_t net_slist_queriesperframe = {0, "net_slist_queriesperframe", "4"};
-static cvar_t net_slist_timeout = {0, "net_slist_timeout", "4"};
-static cvar_t net_slist_maxtries = {0, "net_slist_maxtries", "3"};
+cvar_t cl_netlocalping = {0, "cl_netlocalping","0", "lags local loopback connection by this much ping time (useful to play more fairly on your own server with people with higher pings)"};
+static cvar_t cl_netpacketloss = {0, "cl_netpacketloss","0", "drops this percentage of packets (incoming and outgoing), useful for testing network protocol robustness (effects failing to start, sounds failing to play, etc)"};
+static cvar_t net_slist_queriespersecond = {0, "net_slist_queriespersecond", "20", "how many server information requests to send per second"};
+static cvar_t net_slist_queriesperframe = {0, "net_slist_queriesperframe", "4", "maximum number of server information requests to send each rendered frame (guards against low framerates causing problems)"};
+static cvar_t net_slist_timeout = {0, "net_slist_timeout", "4", "how long to listen for a server information response before giving up"};
+static cvar_t net_slist_maxtries = {0, "net_slist_maxtries", "3", "how many times to ask the same server for information (more times gives better ping reports but takes longer)"};
 
 /* statistic counters */
 static int packetsSent = 0;
@@ -93,10 +93,10 @@ lhnetsocket_t *sv_sockets[16];
 netconn_t *netconn_list = NULL;
 mempool_t *netconn_mempool = NULL;
 
-cvar_t cl_netport = {0, "cl_port", "0"};
-cvar_t sv_netport = {0, "port", "26000"};
-cvar_t net_address = {0, "net_address", "0.0.0.0"};
-//cvar_t net_netaddress_ipv6 = {0, "net_address_ipv6", "[0:0:0:0:0:0:0:0]"};
+cvar_t cl_netport = {0, "cl_port", "0", "forces client to use chosen port number if not 0"};
+cvar_t sv_netport = {0, "port", "26000", "server port for players to connect to"};
+cvar_t net_address = {0, "net_address", "0.0.0.0", "network address to open ports on"};
+//cvar_t net_netaddress_ipv6 = {0, "net_address_ipv6", "[0:0:0:0:0:0:0:0]", "network address to open ipv6 ports on"};
 
 // ServerList interface
 serverlist_mask_t serverlist_andmasks[SERVERLIST_ANDMASKCOUNT];
@@ -2015,9 +2015,9 @@ void NetConn_Init(void)
        int i;
        lhnetaddress_t tempaddress;
        netconn_mempool = Mem_AllocPool("network connections", 0, NULL);
-       Cmd_AddCommand("net_stats", Net_Stats_f);
-       Cmd_AddCommand("net_slist", Net_Slist_f);
-       Cmd_AddCommand("heartbeat", Net_Heartbeat_f);
+       Cmd_AddCommand("net_stats", Net_Stats_f, "print network statistics");
+       Cmd_AddCommand("net_slist", Net_Slist_f, "query master series and print all server information");
+       Cmd_AddCommand("heartbeat", Net_Heartbeat_f, "send a heartbeat to the master server (updates your server information)");
        Cvar_RegisterVariable(&net_slist_queriespersecond);
        Cvar_RegisterVariable(&net_slist_queriesperframe);
        Cvar_RegisterVariable(&net_slist_timeout);
index 1dec266..ed300f6 100644 (file)
@@ -32,9 +32,9 @@ ddef_t *PRVM_ED_FieldAtOfs(int ofs);
 qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s);
 
 // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
-cvar_t prvm_boundscheck = {0, "prvm_boundscheck", "1"};
+cvar_t prvm_boundscheck = {0, "prvm_boundscheck", "1", "enables detection of out of bounds memory access in the QuakeC code being run (in other words, prevents really exceedingly bad QuakeC code from doing nasty things to your computer)"};
 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
-cvar_t prvm_traceqc = {0, "prvm_traceqc", "0"};
+cvar_t prvm_traceqc = {0, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"};
 
 //============================================================================
 // mempool handling
@@ -1744,15 +1744,15 @@ PRVM_Init
 */
 void PRVM_Init (void)
 {
-       Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f);
-       Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f);
-       Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f);
-       Cmd_AddCommand ("prvm_profile", PRVM_Profile_f);
-       Cmd_AddCommand ("prvm_fields", PRVM_Fields_f);
-       Cmd_AddCommand ("prvm_globals", PRVM_Globals_f);
-       Cmd_AddCommand ("prvm_global", PRVM_Global_f);
-       Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f);
-       Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f);
+       Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "set a property on an entity number in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
+       Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)");
        // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
        Cvar_RegisterVariable (&prvm_boundscheck);
        Cvar_RegisterVariable (&prvm_traceqc);
index aeec219..4ec42f3 100644 (file)
@@ -2,12 +2,12 @@
 #include "quakedef.h"
 #include "cl_collision.h"
 
-cvar_t crosshair_brightness = {CVAR_SAVE, "crosshair_brightness", "1"};
-cvar_t crosshair_alpha = {CVAR_SAVE, "crosshair_alpha", "1"};
-cvar_t crosshair_flashspeed = {CVAR_SAVE, "crosshair_flashspeed", "2"};
-cvar_t crosshair_flashrange = {CVAR_SAVE, "crosshair_flashrange", "0.1"};
-cvar_t crosshair_size = {CVAR_SAVE, "crosshair_size", "1"};
-cvar_t crosshair_static = {CVAR_SAVE, "crosshair_static", "1"};
+cvar_t crosshair_brightness = {CVAR_SAVE, "crosshair_brightness", "1", "how bright the crosshair should be"};
+cvar_t crosshair_alpha = {CVAR_SAVE, "crosshair_alpha", "1", "how opaque the crosshair should be"};
+cvar_t crosshair_flashspeed = {CVAR_SAVE, "crosshair_flashspeed", "2", "speed at which the crosshair flashes"};
+cvar_t crosshair_flashrange = {CVAR_SAVE, "crosshair_flashrange", "0.1", "how much the crosshair flashes"};
+cvar_t crosshair_size = {CVAR_SAVE, "crosshair_size", "1", "adjusts size of the crosshair on the screen"};
+cvar_t crosshair_static = {CVAR_SAVE, "crosshair_static", "1", "if 1 the crosshair is a 2D overlay, if 0 it is a sprite in the world indicating where your weapon will hit in standard quake mods (if the mod has the weapon somewhere else this won't be accurate)"};
 
 // must match NUMCROSSHAIRS in gl_draw.c
 #define NUMCROSSHAIRS 6
index 000fc69..d1e51b9 100644 (file)
@@ -52,8 +52,8 @@ static rtexture_t     *explosiontexturefog;
 
 static rtexturepool_t  *explosiontexturepool;
 
-cvar_t r_explosionclip = {CVAR_SAVE, "r_explosionclip", "1"};
-static cvar_t r_drawexplosions = {0, "r_drawexplosions", "1"};
+cvar_t r_explosionclip = {CVAR_SAVE, "r_explosionclip", "1", "enables collision detection for explosion shell (so that it flattens against walls and floors)"};
+static cvar_t r_drawexplosions = {0, "r_drawexplosions", "1", "enables rendering of explosion shells (see also cl_particles_explosions_shell)"};
 
 static void r_explosion_start(void)
 {
index 69b5097..ec50a8d 100644 (file)
--- a/r_light.c
+++ b/r_light.c
@@ -23,9 +23,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "cl_collision.h"
 #include "r_shadow.h"
 
-cvar_t r_modellights = {CVAR_SAVE, "r_modellights", "4"};
-cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1"};
-cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0"};
+cvar_t r_modellights = {CVAR_SAVE, "r_modellights", "4", "how many lights from a .lights file (produced by hlight) are worthy of directional shading on a model (others are applied to the whole model as ambient lighting)"};
+cvar_t r_coronas = {CVAR_SAVE, "r_coronas", "1", "brightness of corona flare effects around certain lights, 0 disables corona effects"};
+cvar_t gl_flashblend = {CVAR_SAVE, "gl_flashblend", "0", "render bright coronas for dynamic lights instead of actual lighting, fast but ugly"};
 
 static rtexture_t *lightcorona;
 static rtexturepool_t *lighttexturepool;
index 4309170..7226b8a 100644 (file)
@@ -2,13 +2,13 @@
 #include "quakedef.h"
 #include "image.h"
 
-cvar_t r_lightningbeam_thickness = {CVAR_SAVE, "r_lightningbeam_thickness", "4"};
-cvar_t r_lightningbeam_scroll = {CVAR_SAVE, "r_lightningbeam_scroll", "5"};
-cvar_t r_lightningbeam_repeatdistance = {CVAR_SAVE, "r_lightningbeam_repeatdistance", "128"};
-cvar_t r_lightningbeam_color_red = {CVAR_SAVE, "r_lightningbeam_color_red", "1"};
-cvar_t r_lightningbeam_color_green = {CVAR_SAVE, "r_lightningbeam_color_green", "1"};
-cvar_t r_lightningbeam_color_blue = {CVAR_SAVE, "r_lightningbeam_color_blue", "1"};
-cvar_t r_lightningbeam_qmbtexture = {CVAR_SAVE, "r_lightningbeam_qmbtexture", "0"};
+cvar_t r_lightningbeam_thickness = {CVAR_SAVE, "r_lightningbeam_thickness", "4", "thickness of the lightning beam effect"};
+cvar_t r_lightningbeam_scroll = {CVAR_SAVE, "r_lightningbeam_scroll", "5", "speed of texture scrolling on the lightning beam effect"};
+cvar_t r_lightningbeam_repeatdistance = {CVAR_SAVE, "r_lightningbeam_repeatdistance", "128", "how far to stretch the texture along the lightning beam effect"};
+cvar_t r_lightningbeam_color_red = {CVAR_SAVE, "r_lightningbeam_color_red", "1", "color of the lightning beam effect"};
+cvar_t r_lightningbeam_color_green = {CVAR_SAVE, "r_lightningbeam_color_green", "1", "color of the lightning beam effect"};
+cvar_t r_lightningbeam_color_blue = {CVAR_SAVE, "r_lightningbeam_color_blue", "1", "color of the lightning beam effect"};
+cvar_t r_lightningbeam_qmbtexture = {CVAR_SAVE, "r_lightningbeam_qmbtexture", "0", "load the qmb textures/particles/lightning.pcx texture instead of generating one, can look better"};
 
 rtexture_t *r_lightningbeamtexture;
 rtexture_t *r_lightningbeamqmbtexture;
index 56b2d23..b190968 100644 (file)
@@ -17,7 +17,7 @@ rendermodule_t rendermodule[MAXRENDERMODULES];
 
 void R_Modules_Init(void)
 {
-       Cmd_AddCommand("r_restart", R_Modules_Restart);
+       Cmd_AddCommand("r_restart", R_Modules_Restart, "restarts renderer");
 }
 
 void R_RegisterModule(char *name, void(*start)(void), void(*shutdown)(void), void(*newmap)(void))
index d3894d5..5b76b07 100644 (file)
@@ -193,46 +193,45 @@ char r_shadow_mapname[MAX_QPATH];
 // used only for light filters (cubemaps)
 rtexturepool_t *r_shadow_filters_texturepool;
 
-cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0"};
-cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4"};
-cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1"};
-cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1"};
-cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.25"};
-cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1"};
-cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "0.5"};
-cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "1"};
-cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1"};
-cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1"};
-cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000"};
-cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1"};
-cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1"};
-cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0"};
-cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0"};
-cvar_t r_shadow_realtime_world_dlightshadows = {CVAR_SAVE, "r_shadow_realtime_world_dlightshadows", "1"};
-cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0"};
-cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1"};
-cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1"};
-cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1"};
-cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1"};
-cvar_t r_shadow_shadow_polygonfactor = {0, "r_shadow_shadow_polygonfactor", "0"};
-cvar_t r_shadow_shadow_polygonoffset = {0, "r_shadow_shadow_polygonoffset", "1"};
-cvar_t r_shadow_singlepassvolumegeneration = {0, "r_shadow_singlepassvolumegeneration", "1"};
-cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1"};
-cvar_t r_shadow_visiblelighting = {0, "r_shadow_visiblelighting", "0"};
-cvar_t r_shadow_visiblevolumes = {0, "r_shadow_visiblevolumes", "0"};
-cvar_t r_shadow_glsl = {0, "r_shadow_glsl", "1"};
-cvar_t r_shadow_glsl_offsetmapping = {0, "r_shadow_glsl_offsetmapping", "0"};
-cvar_t r_shadow_glsl_offsetmapping_scale = {0, "r_shadow_glsl_offsetmapping_scale", "-0.04"};
-cvar_t r_shadow_glsl_offsetmapping_bias = {0, "r_shadow_glsl_offsetmapping_bias", "0.04"};
-cvar_t r_shadow_glsl_usehalffloat = {0, "r_shadow_glsl_usehalffloat", "0"};
-cvar_t r_shadow_glsl_surfacenormalize = {0, "r_shadow_glsl_surfacenormalize", "1"};
-cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1"};
-cvar_t r_editlights = {0, "r_editlights", "0"};
-cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024"};
-cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0"};
-cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4"};
-cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4"};
-cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "0.8"};
+cvar_t r_shadow_bumpscale_basetexture = {0, "r_shadow_bumpscale_basetexture", "0", "generate fake bumpmaps from diffuse textures at this bumpyness, try 4 to match tenebrae, higher values increase depth, requires r_restart to take effect"};
+cvar_t r_shadow_bumpscale_bumpmap = {0, "r_shadow_bumpscale_bumpmap", "4", "what magnitude to interpret _bump.tga textures as, higher values increase depth, requires r_restart to take effect"};
+cvar_t r_shadow_debuglight = {0, "r_shadow_debuglight", "-1", "renders only one light, for level design purposes or debugging"};
+cvar_t r_shadow_gloss = {CVAR_SAVE, "r_shadow_gloss", "1", "0 disables gloss (specularity) rendering, 1 uses gloss if textures are found, 2 forces a flat metallic specular effect on everything without textures (similar to tenebrae)"};
+cvar_t r_shadow_gloss2intensity = {0, "r_shadow_gloss2intensity", "0.25", "how bright the forced flat gloss should look if r_shadow_gloss is 2"};
+cvar_t r_shadow_glossintensity = {0, "r_shadow_glossintensity", "1", "how bright textured glossmaps should look if r_shadow_gloss is 1 or 2"};
+cvar_t r_shadow_lightattenuationpower = {0, "r_shadow_lightattenuationpower", "0.5", "changes attenuation texture generation (does not affect r_shadow_glsl lighting)"};
+cvar_t r_shadow_lightattenuationscale = {0, "r_shadow_lightattenuationscale", "1", "changes attenuation texture generation (does not affect r_shadow_glsl lighting)"};
+cvar_t r_shadow_lightintensityscale = {0, "r_shadow_lightintensityscale", "1", "renders all world lights brighter or darker"};
+cvar_t r_shadow_portallight = {0, "r_shadow_portallight", "1", "use portal culling to exactly determine lit triangles when compiling world lights"};
+cvar_t r_shadow_projectdistance = {0, "r_shadow_projectdistance", "1000000", "how far to cast shadows"};
+cvar_t r_shadow_realtime_dlight = {CVAR_SAVE, "r_shadow_realtime_dlight", "1", "enables rendering of dynamic lights such as explosions and rocket light"};
+cvar_t r_shadow_realtime_dlight_shadows = {CVAR_SAVE, "r_shadow_realtime_dlight_shadows", "1", "enables rendering of shadows from dynamic lights"};
+cvar_t r_shadow_realtime_dlight_portalculling = {0, "r_shadow_realtime_dlight_portalculling", "0", "enables portal culling optimizations on dynamic lights (slow!  you probably don't want this!)"};
+cvar_t r_shadow_realtime_world = {CVAR_SAVE, "r_shadow_realtime_world", "0", "enables rendering of full world lighting (whether loaded from the map, or a .rtlights file, or a .ent file, or a .lights file produced by hlight)"};
+cvar_t r_shadow_realtime_world_dlightshadows = {CVAR_SAVE, "r_shadow_realtime_world_dlightshadows", "1", "enables shadows from dynamic lights when using full world lighting"};
+cvar_t r_shadow_realtime_world_lightmaps = {CVAR_SAVE, "r_shadow_realtime_world_lightmaps", "0", "brightness to render lightmaps when using full world lighting, try 0.5 for a tenebrae-like appearance"};
+cvar_t r_shadow_realtime_world_shadows = {CVAR_SAVE, "r_shadow_realtime_world_shadows", "1", "enables rendering of shadows from world lights"};
+cvar_t r_shadow_realtime_world_compile = {0, "r_shadow_realtime_world_compile", "1", "enables compilation of world lights for higher performance rendering"};
+cvar_t r_shadow_realtime_world_compileshadow = {0, "r_shadow_realtime_world_compileshadow", "1", "enables compilation of shadows from world lights for higher performance rendering"};
+cvar_t r_shadow_scissor = {0, "r_shadow_scissor", "1", "use scissor optimization of light rendering (restricts rendering to the portion of the screen affected by the light)"};
+cvar_t r_shadow_shadow_polygonfactor = {0, "r_shadow_shadow_polygonfactor", "0", "how much to enlarge shadow volume polygons when rendering (should be 0!)"};
+cvar_t r_shadow_shadow_polygonoffset = {0, "r_shadow_shadow_polygonoffset", "1", "how much to push shadow volumes into the distance when rendering, to reduce chances of zfighting artifacts (should not be less than 0)"};
+cvar_t r_shadow_texture3d = {0, "r_shadow_texture3d", "1", "use 3D voxel textures for spherical attenuation rather than cylindrical (does not affect r_shadow_glsl lighting)"};
+cvar_t r_shadow_visiblelighting = {0, "r_shadow_visiblelighting", "0", "shows areas lit by lights, useful for finding out why some areas of a map render slowly (bright orange = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
+cvar_t r_shadow_visiblevolumes = {0, "r_shadow_visiblevolumes", "0", "shows areas shadowed by lights, useful for finding out why some areas of a map render slowly (bright blue = lots of passes = slow), a value of 2 disables depth testing which can be interesting but not very useful"};
+cvar_t r_shadow_glsl = {0, "r_shadow_glsl", "1", "enables use of OpenGL 2.0 pixel shaders for lighting"};
+cvar_t r_shadow_glsl_offsetmapping = {0, "r_shadow_glsl_offsetmapping", "0", "enables offset mapping effect (also known as parallax mapping or sometimes as virtual displacement mapping, not as good as relief mapping or silohuette mapping but much faster), can cause strange artifacts on many textures, requires bumpmaps for depth information (normalmaps can have depth information as alpha channel, but most do not)"};
+cvar_t r_shadow_glsl_offsetmapping_scale = {0, "r_shadow_glsl_offsetmapping_scale", "-0.04", "how deep the offset mapping effect is, and whether it is inward or outward"};
+cvar_t r_shadow_glsl_offsetmapping_bias = {0, "r_shadow_glsl_offsetmapping_bias", "0.04", "pushes the effect closer/further"};
+cvar_t r_shadow_glsl_usehalffloat = {0, "r_shadow_glsl_usehalffloat", "0", "use half and hvec variables in GLSL shader for a speed gain (NVIDIA only)"};
+cvar_t r_shadow_glsl_surfacenormalize = {0, "r_shadow_glsl_surfacenormalize", "1", "normalize bumpmap texels in GLSL shader, produces a more rounded look on small bumps and dents"};
+cvar_t gl_ext_stenciltwoside = {0, "gl_ext_stenciltwoside", "1", "make use of GL_EXT_stenciltwoside extension (NVIDIA only)"};
+cvar_t r_editlights = {0, "r_editlights", "0", "enables .rtlights file editing mode"};
+cvar_t r_editlights_cursordistance = {0, "r_editlights_cursordistance", "1024", "maximum distance of cursor from eye"};
+cvar_t r_editlights_cursorpushback = {0, "r_editlights_cursorpushback", "0", "how far to pull the cursor back toward the eye"};
+cvar_t r_editlights_cursorpushoff = {0, "r_editlights_cursorpushoff", "4", "how far to push the cursor off the impacted surface"};
+cvar_t r_editlights_cursorgrid = {0, "r_editlights_cursorgrid", "4", "snaps cursor to this grid size"};
+cvar_t r_editlights_quakelightsizescale = {CVAR_SAVE, "r_editlights_quakelightsizescale", "1", "changes size of light entities loaded from a map"};
 
 float r_shadow_attenpower, r_shadow_attenscale;
 
@@ -646,7 +645,6 @@ void R_Shadow_Help_f(void)
 "r_shadow_scissor : use scissor optimization\n"
 "r_shadow_shadow_polygonfactor : nudge shadow volumes closer/further\n"
 "r_shadow_shadow_polygonoffset : nudge shadow volumes closer/further\n"
-"r_shadow_singlepassvolumegeneration : selects shadow volume algorithm\n"
 "r_shadow_texture3d : use 3d attenuation texture (if hardware supports)\n"
 "r_shadow_visiblelighting : useful for performance testing; bright = slow!\n"
 "r_shadow_visiblevolumes : useful for performance testing; bright = slow!\n"
@@ -680,7 +678,6 @@ void R_Shadow_Init(void)
        Cvar_RegisterVariable(&r_shadow_scissor);
        Cvar_RegisterVariable(&r_shadow_shadow_polygonfactor);
        Cvar_RegisterVariable(&r_shadow_shadow_polygonoffset);
-       Cvar_RegisterVariable(&r_shadow_singlepassvolumegeneration);
        Cvar_RegisterVariable(&r_shadow_texture3d);
        Cvar_RegisterVariable(&r_shadow_visiblelighting);
        Cvar_RegisterVariable(&r_shadow_visiblevolumes);
@@ -696,7 +693,7 @@ void R_Shadow_Init(void)
                Cvar_SetValue("r_shadow_gloss", 2);
                Cvar_SetValue("r_shadow_bumpscale_basetexture", 4);
        }
-       Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f);
+       Cmd_AddCommand("r_shadow_help", R_Shadow_Help_f, "prints documentation on console commands and variables used by realtime lighting and shadowing system");
        R_Shadow_EditLights_Init();
        r_shadow_mempool = Mem_AllocPool("R_Shadow", 0, NULL);
        r_shadow_worldlightchain = NULL;
@@ -4284,19 +4281,19 @@ void R_Shadow_EditLights_Init(void)
        Cvar_RegisterVariable(&r_editlights_cursorpushoff);
        Cvar_RegisterVariable(&r_editlights_cursorgrid);
        Cvar_RegisterVariable(&r_editlights_quakelightsizescale);
-       Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f);
-       Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f);
-       Cmd_AddCommand("r_editlights_reload", R_Shadow_EditLights_Reload_f);
-       Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f);
-       Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f);
-       Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f);
-       Cmd_AddCommand("r_editlights_editall", R_Shadow_EditLights_EditAll_f);
-       Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f);
-       Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f);
-       Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f);
-       Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f);
-       Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f);
-       Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f);
-       Cmd_AddCommand("r_editlights_pasteinfo", R_Shadow_EditLights_PasteInfo_f);
+       Cmd_AddCommand("r_editlights_help", R_Shadow_EditLights_Help_f, "prints documentation on console commands and variables in rtlight editing system");
+       Cmd_AddCommand("r_editlights_clear", R_Shadow_EditLights_Clear_f, "removes all world lights (let there be darkness!)");
+       Cmd_AddCommand("r_editlights_reload", R_Shadow_EditLights_Reload_f, "reloads rtlights file (or imports from .lights file or .ent file or the map itself)");
+       Cmd_AddCommand("r_editlights_save", R_Shadow_EditLights_Save_f, "save .rtlights file for current level");
+       Cmd_AddCommand("r_editlights_spawn", R_Shadow_EditLights_Spawn_f, "creates a light with default properties (let there be light!)");
+       Cmd_AddCommand("r_editlights_edit", R_Shadow_EditLights_Edit_f, "changes a property on the selected light");
+       Cmd_AddCommand("r_editlights_editall", R_Shadow_EditLights_EditAll_f, "changes a property on ALL lights at once (tip: use radiusscale and colorscale to alter these properties)");
+       Cmd_AddCommand("r_editlights_remove", R_Shadow_EditLights_Remove_f, "remove selected light");
+       Cmd_AddCommand("r_editlights_toggleshadow", R_Shadow_EditLights_ToggleShadow_f, "toggle on/off the shadow option on the selected light");
+       Cmd_AddCommand("r_editlights_togglecorona", R_Shadow_EditLights_ToggleCorona_f, "toggle on/off the corona option on the selected light");
+       Cmd_AddCommand("r_editlights_importlightentitiesfrommap", R_Shadow_EditLights_ImportLightEntitiesFromMap_f, "load lights from .ent file or map entities (ignoring .rtlights or .lights file)");
+       Cmd_AddCommand("r_editlights_importlightsfile", R_Shadow_EditLights_ImportLightsFile_f, "load lights from .lights file (ignoring .rtlights or .ent files and map entities)");
+       Cmd_AddCommand("r_editlights_copyinfo", R_Shadow_EditLights_CopyInfo_f, "store a copy of all properties (except origin) of the selected light");
+       Cmd_AddCommand("r_editlights_pasteinfo", R_Shadow_EditLights_PasteInfo_f, "apply the stored properties onto the selected light (making it exactly identical except for origin)");
 }
 
diff --git a/r_sky.c b/r_sky.c
index 981ba57..2d6ac57 100644 (file)
--- a/r_sky.c
+++ b/r_sky.c
@@ -3,9 +3,9 @@
 #include "image.h"
 
 // FIXME: fix skybox after vid_restart
-cvar_t r_sky = {CVAR_SAVE, "r_sky", "1"};
-cvar_t r_skyscroll1 = {CVAR_SAVE, "r_skyscroll1", "1"};
-cvar_t r_skyscroll2 = {CVAR_SAVE, "r_skyscroll2", "2"};
+cvar_t r_sky = {CVAR_SAVE, "r_sky", "1", "enables sky rendering (black otherwise)"};
+cvar_t r_skyscroll1 = {CVAR_SAVE, "r_skyscroll1", "1", "speed at which upper clouds layer scrolls in quake sky"};
+cvar_t r_skyscroll2 = {CVAR_SAVE, "r_skyscroll2", "2", "speed at which lower clouds layer scrolls in quake sky"};
 int skyrendernow;
 int skyrendermasked;
 
@@ -463,7 +463,7 @@ static void r_sky_newmap(void)
 
 void R_Sky_Init(void)
 {
-       Cmd_AddCommand ("loadsky", &LoadSky_f);
+       Cmd_AddCommand ("loadsky", &LoadSky_f, "load a skybox by basename (for example loadsky mtnsun_ loads mtnsun_ft.tga and so on)");
        Cvar_RegisterVariable (&r_sky);
        Cvar_RegisterVariable (&r_skyscroll1);
        Cvar_RegisterVariable (&r_skyscroll2);
diff --git a/sbar.c b/sbar.c
index 9501a26..e983418 100644 (file)
--- a/sbar.c
+++ b/sbar.c
@@ -99,15 +99,15 @@ sbarpic_t *zymsb_crosshair_left1;
 sbarpic_t *zymsb_crosshair_left2;
 sbarpic_t *zymsb_crosshair_right;
 
-cvar_t showfps = {CVAR_SAVE, "showfps", "0"};
-cvar_t showtime = {CVAR_SAVE, "showtime", "0"};
-cvar_t showtime_format = {CVAR_SAVE, "showtime_format", "%H:%M:%S"};
-cvar_t showdate = {CVAR_SAVE, "showdate", "0"};
-cvar_t showdate_format = {CVAR_SAVE, "showdate_format", "%Y-%m-%d"};
-cvar_t sbar_alpha_bg = {CVAR_SAVE, "sbar_alpha_bg", "0.4"};
-cvar_t sbar_alpha_fg = {CVAR_SAVE, "sbar_alpha_fg", "1"};
+cvar_t showfps = {CVAR_SAVE, "showfps", "0", "shows your rendered fps (frames per second)"};
+cvar_t showtime = {CVAR_SAVE, "showtime", "0", "shows current time of day (useful on screenshots)"};
+cvar_t showtime_format = {CVAR_SAVE, "showtime_format", "%H:%M:%S", "format string for time of day"};
+cvar_t showdate = {CVAR_SAVE, "showdate", "0", "shows current date (useful on screenshots)"};
+cvar_t showdate_format = {CVAR_SAVE, "showdate_format", "%Y-%m-%d", "format string for date"};
+cvar_t sbar_alpha_bg = {CVAR_SAVE, "sbar_alpha_bg", "0.4", "opacity value of the statusbar background image"};
+cvar_t sbar_alpha_fg = {CVAR_SAVE, "sbar_alpha_fg", "1", "opacity value of the statusbar weapon/item icons and numbers"};
 
-cvar_t cl_deathscoreboard = {0, "cl_deathscoreboard", "1"};
+cvar_t cl_deathscoreboard = {0, "cl_deathscoreboard", "1", "shows scoreboard (+showscores) while dead"};
 
 void Sbar_MiniDeathmatchOverlay (int x, int y);
 void Sbar_DeathmatchOverlay (void);
@@ -347,8 +347,8 @@ void sbar_newmap(void)
 
 void Sbar_Init (void)
 {
-       Cmd_AddCommand ("+showscores", Sbar_ShowScores);
-       Cmd_AddCommand ("-showscores", Sbar_DontShowScores);
+       Cmd_AddCommand ("+showscores", Sbar_ShowScores, "show scoreboard");
+       Cmd_AddCommand ("-showscores", Sbar_DontShowScores, "hide scoreboard");
        Cvar_RegisterVariable (&showfps);
        Cvar_RegisterVariable (&showtime);
        Cvar_RegisterVariable (&showtime_format);
index f76e0f8..6db16c4 100644 (file)
--- a/server.h
+++ b/server.h
@@ -250,7 +250,6 @@ extern cvar_t coop;
 extern cvar_t fraglimit;
 extern cvar_t timelimit;
 extern cvar_t pausable;
-extern cvar_t sv_deltacompress;
 extern cvar_t sv_maxvelocity;
 extern cvar_t sv_gravity;
 extern cvar_t sv_nostep;
index 26f048d..4030d38 100644 (file)
@@ -60,8 +60,8 @@ channel_t channels[MAX_CHANNELS];
 unsigned int total_channels;
 
 int snd_blocked = 0;
-cvar_t snd_initialized = { CVAR_READONLY, "snd_initialized", "0"};
-cvar_t snd_streaming = { CVAR_SAVE, "snd_streaming", "1"};
+cvar_t snd_initialized = { CVAR_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"};
+cvar_t snd_streaming = { CVAR_SAVE, "snd_streaming", "1", "enables keeping compressed ogg sound files compressed, decompressing them only as needed, otherwise they will be decompressed completely at load (may use a lot of memory)"};
 
 volatile dma_t *shm = 0;
 volatile dma_t sn;
@@ -83,19 +83,19 @@ qboolean sound_spatialized = false;
 // isolating performance in the renderer.
 qboolean fakedma = false;
 
-cvar_t bgmvolume = {CVAR_SAVE, "bgmvolume", "1"};
-cvar_t volume = {CVAR_SAVE, "volume", "0.7"};
-cvar_t snd_staticvolume = {CVAR_SAVE, "snd_staticvolume", "1"};
+cvar_t bgmvolume = {CVAR_SAVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"};
+cvar_t volume = {CVAR_SAVE, "volume", "0.7", "volume of sound effects"};
+cvar_t snd_staticvolume = {CVAR_SAVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"};
 
-cvar_t nosound = {0, "nosound", "0"};
-cvar_t snd_precache = {0, "snd_precache", "1"};
-cvar_t bgmbuffer = {0, "bgmbuffer", "4096"};
-cvar_t ambient_level = {0, "ambient_level", "0.3"};
-cvar_t ambient_fade = {0, "ambient_fade", "100"};
-cvar_t snd_noextraupdate = {0, "snd_noextraupdate", "0"};
-cvar_t snd_show = {0, "snd_show", "0"};
-cvar_t _snd_mixahead = {CVAR_SAVE, "_snd_mixahead", "0.1"};
-cvar_t snd_swapstereo = {CVAR_SAVE, "snd_swapstereo", "0"};
+cvar_t nosound = {0, "nosound", "0", "disables sound"};
+cvar_t snd_precache = {0, "snd_precache", "1", "loads sounds before they are used"};
+//cvar_t bgmbuffer = {0, "bgmbuffer", "4096", "unused quake cvar"};
+cvar_t ambient_level = {0, "ambient_level", "0.3", "volume of environment noises (water and wind)"};
+cvar_t ambient_fade = {0, "ambient_fade", "100", "rate of volume fading when moving from one environment to another"};
+cvar_t snd_noextraupdate = {0, "snd_noextraupdate", "0", "disables extra sound mixer calls that are meant to reduce the chance of sound breakup at very low framerates"};
+cvar_t snd_show = {0, "snd_show", "0", "shows some statistics about sound mixing"};
+cvar_t _snd_mixahead = {CVAR_SAVE, "_snd_mixahead", "0.1", "how much sound to mix ahead of time"};
+cvar_t snd_swapstereo = {CVAR_SAVE, "snd_swapstereo", "0", "swaps left/right speakers for old ISA soundblaster cards"};
 
 // Ambient sounds
 sfx_t* ambient_sfxs [2] = { NULL, NULL };
@@ -205,19 +205,19 @@ void S_Init(void)
        if (COM_CheckParm("-simsound"))
                fakedma = true;
 
-       Cmd_AddCommand("play", S_Play);
-       Cmd_AddCommand("play2", S_Play2);
-       Cmd_AddCommand("playvol", S_PlayVol);
-       Cmd_AddCommand("stopsound", S_StopAllSounds);
-       Cmd_AddCommand("soundlist", S_SoundList);
-       Cmd_AddCommand("soundinfo", S_SoundInfo_f);
-       Cmd_AddCommand("snd_restart", S_Restart_f);
+       Cmd_AddCommand("play", S_Play, "play a sound at your current location (not heard by anyone else)");
+       Cmd_AddCommand("play2", S_Play2, "play a sound globally throughout the level (not heard by anyone else)");
+       Cmd_AddCommand("playvol", S_PlayVol, "play a sound at the specified volume level at your current location (not heard by anyone else)");
+       Cmd_AddCommand("stopsound", S_StopAllSounds, "silence");
+       Cmd_AddCommand("soundlist", S_SoundList, "list loaded sounds");
+       Cmd_AddCommand("soundinfo", S_SoundInfo_f, "print sound system information (such as channels and speed)");
+       Cmd_AddCommand("snd_restart", S_Restart_f, "restart sound system");
 
        Cvar_RegisterVariable(&nosound);
        Cvar_RegisterVariable(&snd_precache);
        Cvar_RegisterVariable(&snd_initialized);
        Cvar_RegisterVariable(&snd_streaming);
-       Cvar_RegisterVariable(&bgmbuffer);
+       //Cvar_RegisterVariable(&bgmbuffer);
        Cvar_RegisterVariable(&ambient_level);
        Cvar_RegisterVariable(&ambient_fade);
        Cvar_RegisterVariable(&snd_noextraupdate);
index aa4ebd1..5ed2999 100755 (executable)
@@ -22,17 +22,20 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
-cvar_t bgmvolume = {CVAR_SAVE, "bgmvolume", "1"};
-cvar_t volume = {CVAR_SAVE, "volume", "0.7"};
-cvar_t snd_staticvolume = {CVAR_SAVE, "snd_staticvolume", "1"};
-
-cvar_t snd_initialized = { CVAR_READONLY, "snd_initialized", "0"};
+cvar_t bgmvolume = {CVAR_SAVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"};
+cvar_t volume = {CVAR_SAVE, "volume", "0.7", "volume of sound effects"};
+cvar_t snd_staticvolume = {CVAR_SAVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"};
+cvar_t _snd_mixahead = {CVAR_SAVE, "_snd_mixahead", "0.1", "how much sound to mix ahead of time"};
+cvar_t snd_swapstereo = {CVAR_SAVE, "snd_swapstereo", "0", "swaps left/right speakers for old ISA soundblaster cards"};
+cvar_t snd_initialized = { CVAR_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"};
 
 void S_Init (void)
 {
        Cvar_RegisterVariable(&bgmvolume);
        Cvar_RegisterVariable(&volume);
        Cvar_RegisterVariable(&snd_staticvolume);
+       Cvar_RegisterVariable(&_snd_mixahead);
+       Cvar_RegisterVariable(&snd_swapstereo);
        Cvar_RegisterVariable(&snd_initialized);
 }
 
index 05e19c1..af1a39e 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -32,25 +32,25 @@ void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_sta
 
 
 // select which protocol to host, this is fed to Protocol_EnumForName
-cvar_t sv_protocolname = {0, "sv_protocolname", "DP7"};
-cvar_t sv_ratelimitlocalplayer = {0, "sv_ratelimitlocalplayer", "0"};
-cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "10000"};
-
-static cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1"}; // fast but loose
-static cvar_t sv_cullentities_trace = {0, "sv_cullentities_trace", "0"}; // tends to get false negatives, uses a timeout to keep entities visible a short time after becoming hidden
-static cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0"};
-static cvar_t sv_entpatch = {0, "sv_entpatch", "1"};
-
-cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1"};
-cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1"};
-cvar_t sv_gameplayfix_stepdown = {0, "sv_gameplayfix_stepdown", "1"};
-cvar_t sv_gameplayfix_stepwhilejumping = {0, "sv_gameplayfix_stepwhilejumping", "1"};
-cvar_t sv_gameplayfix_swiminbmodels = {0, "sv_gameplayfix_swiminbmodels", "1"};
-cvar_t sv_gameplayfix_setmodelrealbox = {0, "sv_gameplayfix_setmodelrealbox", "1"};
-cvar_t sv_gameplayfix_blowupfallenzombies = {0, "sv_gameplayfix_blowupfallenzombies", "1"};
-cvar_t sv_gameplayfix_findradiusdistancetobox = {0, "sv_gameplayfix_findradiusdistancetobox", "1"};
-
-cvar_t sv_progs = {0, "sv_progs", "progs.dat" };
+cvar_t sv_protocolname = {0, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
+cvar_t sv_ratelimitlocalplayer = {0, "sv_ratelimitlocalplayer", "0", "whether to apply rate limiting to the local player in a listen server (only useful for testing)"};
+cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "10000", "upper limit on client rate cvar, should reflect your network connection quality"};
+
+static cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"}; // fast but loose
+static cvar_t sv_cullentities_trace = {0, "sv_cullentities_trace", "0", "somewhat slow but very tight culling of hidden entities, minimizes network traffic and makes wallhack cheats useless"}; // tends to get false negatives, uses a timeout to keep entities visible a short time after becoming hidden
+static cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
+static cvar_t sv_entpatch = {0, "sv_entpatch", "1", "enables loading of .ent files to override entities in the bsp (for example Threewave CTF server pack contains .ent patch files enabling play of CTF on id1 maps)"};
+
+cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
+cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1", "causes entities (corpses) sitting ontop of moving entities (players) to fall when the moving entity (player) is no longer supporting them"};
+cvar_t sv_gameplayfix_stepdown = {0, "sv_gameplayfix_stepdown", "1", "attempts to step down stairs, not just up them (prevents the familiar thud..thud..thud.. when running down stairs and slopes)"};
+cvar_t sv_gameplayfix_stepwhilejumping = {0, "sv_gameplayfix_stepwhilejumping", "1", "applies step-up onto a ledge even while airborn, useful if you would otherwise just-miss the floor when running across small areas with gaps (for instance running across the moving platforms in dm2, or jumping to the megahealth and red armor in dm2 rather than using the bridge)"};
+cvar_t sv_gameplayfix_swiminbmodels = {0, "sv_gameplayfix_swiminbmodels", "1", "causes pointcontents (used to determine if you are in a liquid) to check bmodel entities as well as the world model, so you can swim around in (possibly moving) water bmodel entities"};
+cvar_t sv_gameplayfix_setmodelrealbox = {0, "sv_gameplayfix_setmodelrealbox", "1", "fixes a bug in Quake that made setmodel always set the entity box to ('-16 -16 -16', '16 16 16') rather than properly checking the model box, breaks some poorly coded mods"};
+cvar_t sv_gameplayfix_blowupfallenzombies = {0, "sv_gameplayfix_blowupfallenzombies", "1", "causes findradius to detect SOLID_NOT entities such as zombies and corpses on the floor, allowing splash damage to apply to them"};
+cvar_t sv_gameplayfix_findradiusdistancetobox = {0, "sv_gameplayfix_findradiusdistancetobox", "1", "causes findradius to check the distance to the corner of a box rather than the center of the box, makes findradius detect bmodels such as very large doors that would otherwise be unaffected by splash damage"};
+
+cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
 
 server_t sv;
 server_static_t svs;
@@ -70,7 +70,7 @@ SV_Init
 */
 void SV_Init (void)
 {
-       Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f);
+       Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
        Cvar_RegisterVariable (&sv_maxvelocity);
        Cvar_RegisterVariable (&sv_gravity);
        Cvar_RegisterVariable (&sv_friction);
@@ -82,7 +82,6 @@ void SV_Init (void)
        Cvar_RegisterVariable (&sv_idealpitchscale);
        Cvar_RegisterVariable (&sv_aim);
        Cvar_RegisterVariable (&sv_nostep);
-       Cvar_RegisterVariable (&sv_deltacompress);
        Cvar_RegisterVariable (&sv_cullentities_pvs);
        Cvar_RegisterVariable (&sv_cullentities_trace);
        Cvar_RegisterVariable (&sv_cullentities_stats);
@@ -2097,30 +2096,39 @@ qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
        return true;
 }
 
-cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1"};
-cvar_t nomonsters = {0, "nomonsters", "0"};
-cvar_t gamecfg = {0, "gamecfg", "0"};
-cvar_t scratch1 = {0, "scratch1", "0"};
-cvar_t scratch2 = {0,"scratch2", "0"};
-cvar_t scratch3 = {0, "scratch3", "0"};
-cvar_t scratch4 = {0, "scratch4", "0"};
-cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0"};
-cvar_t saved1 = {CVAR_SAVE, "saved1", "0"};
-cvar_t saved2 = {CVAR_SAVE, "saved2", "0"};
-cvar_t saved3 = {CVAR_SAVE, "saved3", "0"};
-cvar_t saved4 = {CVAR_SAVE, "saved4", "0"};
-cvar_t decors = {0, "decors", "0"};
-cvar_t nehx00 = {0, "nehx00", "0"};cvar_t      nehx01 = {0, "nehx01", "0"};
-cvar_t nehx02 = {0, "nehx02", "0"};cvar_t      nehx03 = {0, "nehx03", "0"};
-cvar_t nehx04 = {0, "nehx04", "0"};cvar_t      nehx05 = {0, "nehx05", "0"};
-cvar_t nehx06 = {0, "nehx06", "0"};cvar_t      nehx07 = {0, "nehx07", "0"};
-cvar_t nehx08 = {0, "nehx08", "0"};cvar_t      nehx09 = {0, "nehx09", "0"};
-cvar_t nehx10 = {0, "nehx10", "0"};cvar_t      nehx11 = {0, "nehx11", "0"};
-cvar_t nehx12 = {0, "nehx12", "0"};cvar_t      nehx13 = {0, "nehx13", "0"};
-cvar_t nehx14 = {0, "nehx14", "0"};cvar_t      nehx15 = {0, "nehx15", "0"};
-cvar_t nehx16 = {0, "nehx16", "0"};cvar_t      nehx17 = {0, "nehx17", "0"};
-cvar_t nehx18 = {0, "nehx18", "0"};cvar_t      nehx19 = {0, "nehx19", "0"};
-cvar_t cutscene = {0, "cutscene", "1"};
+cvar_t pr_checkextension = {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 nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
+cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
+cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"};
+cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"};
+cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"};
+cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"};
+cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
+cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
+cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
+cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
+cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
+cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
+cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
 
 void SV_VM_Init(void)
 {
@@ -2136,21 +2144,29 @@ void SV_VM_Init(void)
        Cvar_RegisterVariable (&saved2);
        Cvar_RegisterVariable (&saved3);
        Cvar_RegisterVariable (&saved4);
-       // LordHavoc: for DarkPlaces, this overrides the number of decors (shell casings, gibs, etc)
-       Cvar_RegisterVariable (&decors);
        // LordHavoc: Nehahra uses these to pass data around cutscene demos
        if (gamemode == GAME_NEHAHRA)
        {
-               Cvar_RegisterVariable (&nehx00);Cvar_RegisterVariable (&nehx01);
-               Cvar_RegisterVariable (&nehx02);Cvar_RegisterVariable (&nehx03);
-               Cvar_RegisterVariable (&nehx04);Cvar_RegisterVariable (&nehx05);
-               Cvar_RegisterVariable (&nehx06);Cvar_RegisterVariable (&nehx07);
-               Cvar_RegisterVariable (&nehx08);Cvar_RegisterVariable (&nehx09);
-               Cvar_RegisterVariable (&nehx10);Cvar_RegisterVariable (&nehx11);
-               Cvar_RegisterVariable (&nehx12);Cvar_RegisterVariable (&nehx13);
-               Cvar_RegisterVariable (&nehx14);Cvar_RegisterVariable (&nehx15);
-               Cvar_RegisterVariable (&nehx16);Cvar_RegisterVariable (&nehx17);
-               Cvar_RegisterVariable (&nehx18);Cvar_RegisterVariable (&nehx19);
+               Cvar_RegisterVariable (&nehx00);
+               Cvar_RegisterVariable (&nehx01);
+               Cvar_RegisterVariable (&nehx02);
+               Cvar_RegisterVariable (&nehx03);
+               Cvar_RegisterVariable (&nehx04);
+               Cvar_RegisterVariable (&nehx05);
+               Cvar_RegisterVariable (&nehx06);
+               Cvar_RegisterVariable (&nehx07);
+               Cvar_RegisterVariable (&nehx08);
+               Cvar_RegisterVariable (&nehx09);
+               Cvar_RegisterVariable (&nehx10);
+               Cvar_RegisterVariable (&nehx11);
+               Cvar_RegisterVariable (&nehx12);
+               Cvar_RegisterVariable (&nehx13);
+               Cvar_RegisterVariable (&nehx14);
+               Cvar_RegisterVariable (&nehx15);
+               Cvar_RegisterVariable (&nehx16);
+               Cvar_RegisterVariable (&nehx17);
+               Cvar_RegisterVariable (&nehx18);
+               Cvar_RegisterVariable (&nehx19);
        }
        Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
 }
index 9873eb2..d37dbbb 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -39,17 +39,17 @@ solid_edge items only clip against bsp models.
 
 */
 
-cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4"};
-cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100"};
-cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800"};
-cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000"};
-cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0"};
-cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18"};
-cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1"};
-cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1"};
-cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0"};
-cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0"};
-cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1"};
+cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4", "how fast you slow down"};
+cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
+cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
+cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
+cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
+cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
+cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "1", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
+cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
+cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0", "enables simpler/buggier player physics (not recommended)"};
+cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
+cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
 
 #define        MOVE_EPSILON    0.01
 
index ff4ee73..5b28fea 100644 (file)
--- a/sv_user.c
+++ b/sv_user.c
@@ -21,12 +21,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
-cvar_t sv_edgefriction = {0, "edgefriction", "2"};
-cvar_t sv_deltacompress = {0, "sv_deltacompress", "1"};
-cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8"};
-cvar_t sv_maxspeed = {CVAR_NOTIFY, "sv_maxspeed", "320"};
-cvar_t sv_maxairspeed = {0, "sv_maxairspeed", "30"};
-cvar_t sv_accelerate = {0, "sv_accelerate", "10"};
+cvar_t sv_edgefriction = {0, "edgefriction", "2", "how much you slow down when nearing a ledge you might fall off"};
+cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};
+cvar_t sv_maxspeed = {CVAR_NOTIFY, "sv_maxspeed", "320", "maximum speed a player can accelerate to when on ground (can be exceeded by tricks)"};
+cvar_t sv_maxairspeed = {0, "sv_maxairspeed", "30", "maximum speed a player can accelerate to when airborn (note that it is possible to completely stop by moving the opposite direction)"};
+cvar_t sv_accelerate = {0, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
 
 static usercmd_t cmd;
 
index e62b251..110234b 100644 (file)
@@ -4,7 +4,7 @@
 // Server
 
 #define PF_WARNING(s) do{Con_Printf(s);PRVM_PrintState();return;}while(0)
-cvar_t sv_aim = {CVAR_SAVE, "sv_aim", "2"}; //"0.93"}; // LordHavoc: disabled autoaim by default
+cvar_t sv_aim = {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"}; //"0.93"}; // LordHavoc: disabled autoaim by default
 
 
 char *vm_sv_extensions =
index 9b6aa09..0515c93 100644 (file)
@@ -13,7 +13,7 @@
 
 
 #ifdef WIN32
-cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1"};
+cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1", "use windows timeGetTime function (which has issues on some motherboards) for timing rather than QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power)"};
 #endif
 
 
index b9b4cd3..d3da31c 100644 (file)
--- a/sys_win.c
+++ b/sys_win.c
@@ -29,7 +29,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 extern void S_BlockSound (void);
 
-cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1"};
+cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1", "use windows timeGetTime function (which has issues on some motherboards) for timing rather than QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power)"};
 
 HANDLE                         hinput, houtput;
 
index ebb7f49..bb4ea07 100644 (file)
--- a/vid_glx.c
+++ b/vid_glx.c
@@ -97,8 +97,9 @@ static float  mouse_x, mouse_y;
 static int p_mouse_x, p_mouse_y;
 
 #if !defined(__APPLE__) && !defined(SUNOS)
-cvar_t vid_dga = {CVAR_SAVE, "vid_dga", "1"};
-cvar_t vid_dga_mouseaccel = {0, "vid_dga_mouseaccel", "1"};
+// FIXME: vid_dga_mouseaccel is poorly named, it is actually the multiplier for mouse movement, not an acceleration (which would be a power function or something)
+cvar_t vid_dga = {CVAR_SAVE, "vid_dga", "1", "make use of DGA mouse input"};
+cvar_t vid_dga_mouseaccel = {0, "vid_dga_mouseaccel", "1", "speed of mouse when using DGA mouse input"};
 #endif
 
 qboolean vidmode_ext = false;
index b47348e..61e506a 100644 (file)
@@ -62,41 +62,41 @@ qboolean vid_hidden = true;
 qboolean vid_activewindow = true;
 
 // we don't know until we try it!
-cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1"};
+cvar_t vid_hardwaregammasupported = {CVAR_READONLY,"vid_hardwaregammasupported","1", "indicates whether hardware gamma is supported (updated by attempts to set hardware gamma ramps)"};
 // whether hardware gamma ramps are currently in effect
 qboolean vid_usinghwgamma = false;
 
 unsigned short vid_gammaramps[768];
 unsigned short vid_systemgammaramps[768];
 
-cvar_t vid_fullscreen = {CVAR_SAVE, "vid_fullscreen", "1"};
-cvar_t vid_width = {CVAR_SAVE, "vid_width", "640"};
-cvar_t vid_height = {CVAR_SAVE, "vid_height", "480"};
-cvar_t vid_bitsperpixel = {CVAR_SAVE, "vid_bitsperpixel", "32"};
-cvar_t vid_refreshrate = {CVAR_SAVE, "vid_refreshrate", "60"};
-
-cvar_t vid_vsync = {CVAR_SAVE, "vid_vsync", "0"};
-cvar_t vid_mouse = {CVAR_SAVE, "vid_mouse", "1"};
-cvar_t vid_minwidth = {0, "vid_minwidth", "0"};
-cvar_t vid_minheight = {0, "vid_minheight", "0"};
-cvar_t gl_combine = {0, "gl_combine", "1"};
-cvar_t gl_finish = {0, "gl_finish", "0"};
-
-cvar_t v_gamma = {CVAR_SAVE, "v_gamma", "1"};
-cvar_t v_contrast = {CVAR_SAVE, "v_contrast", "1"};
-cvar_t v_brightness = {CVAR_SAVE, "v_brightness", "0"};
-cvar_t v_color_enable = {CVAR_SAVE, "v_color_enable", "0"};
-cvar_t v_color_black_r = {CVAR_SAVE, "v_color_black_r", "0"};
-cvar_t v_color_black_g = {CVAR_SAVE, "v_color_black_g", "0"};
-cvar_t v_color_black_b = {CVAR_SAVE, "v_color_black_b", "0"};
-cvar_t v_color_grey_r = {CVAR_SAVE, "v_color_grey_r", "0.5"};
-cvar_t v_color_grey_g = {CVAR_SAVE, "v_color_grey_g", "0.5"};
-cvar_t v_color_grey_b = {CVAR_SAVE, "v_color_grey_b", "0.5"};
-cvar_t v_color_white_r = {CVAR_SAVE, "v_color_white_r", "1"};
-cvar_t v_color_white_g = {CVAR_SAVE, "v_color_white_g", "1"};
-cvar_t v_color_white_b = {CVAR_SAVE, "v_color_white_b", "1"};
-cvar_t v_hwgamma = {CVAR_SAVE, "v_hwgamma", "1"};
-cvar_t v_psycho = {0, "v_psycho", "0"};
+cvar_t vid_fullscreen = {CVAR_SAVE, "vid_fullscreen", "1", "use fullscreen (1) or windowed (0)"};
+cvar_t vid_width = {CVAR_SAVE, "vid_width", "640", "resolution"};
+cvar_t vid_height = {CVAR_SAVE, "vid_height", "480", "resolution"};
+cvar_t vid_bitsperpixel = {CVAR_SAVE, "vid_bitsperpixel", "32", "how many bits per pixel to render at (32 or 16, 32 is recommended)"};
+cvar_t vid_refreshrate = {CVAR_SAVE, "vid_refreshrate", "60", "refresh rate to use, in hz (higher values flicker less, if supported by your monitor)"};
+
+cvar_t vid_vsync = {CVAR_SAVE, "vid_vsync", "0", "sync to vertical blank, prevents 'tearing' (seeing part of one frame and part of another on the screen at the same time), automatically disabled when doing timedemo benchmarks"};
+cvar_t vid_mouse = {CVAR_SAVE, "vid_mouse", "1", "whether to use the mouse in windowed mode (fullscreen always does)"};
+cvar_t vid_minwidth = {0, "vid_minwidth", "0", "minimum vid_width that is acceptable (to be set in default.cfg in mods)"};
+cvar_t vid_minheight = {0, "vid_minheight", "0", "minimum vid_height that is acceptable (to be set in default.cfg in mods)"};
+cvar_t gl_combine = {0, "gl_combine", "1", "faster rendering by using GL_ARB_texture_env_combine extension (part of OpenGL 1.3 and above)"};
+cvar_t gl_finish = {0, "gl_finish", "0", "make the cpu wait for the graphics processor at the end of each frame render (can help with strange input or video lag problems on some machines)"};
+
+cvar_t v_gamma = {CVAR_SAVE, "v_gamma", "1", "inverse gamma correction value, a brightness effect that does not affect white or black, and tends to make the image grey and dull"};
+cvar_t v_contrast = {CVAR_SAVE, "v_contrast", "1", "brightness of white (values above 1 give a brighter image with increased color saturation, unlike v_gamma)"};
+cvar_t v_brightness = {CVAR_SAVE, "v_brightness", "0", "brightness of black, useful for monitors that are too dark"};
+cvar_t v_color_enable = {CVAR_SAVE, "v_color_enable", "0", "enables black-grey-white color correction curve controls"};
+cvar_t v_color_black_r = {CVAR_SAVE, "v_color_black_r", "0", "desired color of black"};
+cvar_t v_color_black_g = {CVAR_SAVE, "v_color_black_g", "0", "desired color of black"};
+cvar_t v_color_black_b = {CVAR_SAVE, "v_color_black_b", "0", "desired color of black"};
+cvar_t v_color_grey_r = {CVAR_SAVE, "v_color_grey_r", "0.5", "desired color of grey"};
+cvar_t v_color_grey_g = {CVAR_SAVE, "v_color_grey_g", "0.5", "desired color of grey"};
+cvar_t v_color_grey_b = {CVAR_SAVE, "v_color_grey_b", "0.5", "desired color of grey"};
+cvar_t v_color_white_r = {CVAR_SAVE, "v_color_white_r", "1", "desired color of white"};
+cvar_t v_color_white_g = {CVAR_SAVE, "v_color_white_g", "1", "desired color of white"};
+cvar_t v_color_white_b = {CVAR_SAVE, "v_color_white_b", "1", "desired color of white"};
+cvar_t v_hwgamma = {CVAR_SAVE, "v_hwgamma", "1", "enables use of hardware gamma correction ramps if available (note: does not work very well on Windows2000 and above)"};
+cvar_t v_psycho = {0, "v_psycho", "0", "easter egg (does not work on Windows2000 or above)"};
 
 // brand of graphics chip
 const char *gl_vendor;
@@ -911,8 +911,8 @@ void VID_Shared_Init(void)
        Cvar_RegisterVariable(&vid_minheight);
        Cvar_RegisterVariable(&gl_combine);
        Cvar_RegisterVariable(&gl_finish);
-       Cmd_AddCommand("force_centerview", Force_CenterView_f);
-       Cmd_AddCommand("vid_restart", VID_Restart_f);
+       Cmd_AddCommand("force_centerview", Force_CenterView_f, "recenters view (stops looking up/down)");
+       Cmd_AddCommand("vid_restart", VID_Restart_f, "restarts video system (closes and reopens the window, restarts renderer)");
        if (gamemode == GAME_GOODVSBAD2)
                Cvar_Set("gl_combine", "0");
 }
index 859fdc1..22f4652 100644 (file)
--- a/vid_wgl.c
+++ b/vid_wgl.c
@@ -186,25 +186,25 @@ static PDWORD     pdwRawValue[JOY_MAX_AXES];
 // each time.  this avoids any problems with getting back to a default usage
 // or when changing from one controller to another.  this way at least something
 // works.
-static cvar_t  in_joystick = {CVAR_SAVE, "joystick","0"};
-static cvar_t  joy_name = {0, "joyname", "joystick"};
-static cvar_t  joy_advanced = {0, "joyadvanced", "0"};
-static cvar_t  joy_advaxisx = {0, "joyadvaxisx", "0"};
-static cvar_t  joy_advaxisy = {0, "joyadvaxisy", "0"};
-static cvar_t  joy_advaxisz = {0, "joyadvaxisz", "0"};
-static cvar_t  joy_advaxisr = {0, "joyadvaxisr", "0"};
-static cvar_t  joy_advaxisu = {0, "joyadvaxisu", "0"};
-static cvar_t  joy_advaxisv = {0, "joyadvaxisv", "0"};
-static cvar_t  joy_forwardthreshold = {0, "joyforwardthreshold", "0.15"};
-static cvar_t  joy_sidethreshold = {0, "joysidethreshold", "0.15"};
-static cvar_t  joy_pitchthreshold = {0, "joypitchthreshold", "0.15"};
-static cvar_t  joy_yawthreshold = {0, "joyyawthreshold", "0.15"};
-static cvar_t  joy_forwardsensitivity = {0, "joyforwardsensitivity", "-1.0"};
-static cvar_t  joy_sidesensitivity = {0, "joysidesensitivity", "-1.0"};
-static cvar_t  joy_pitchsensitivity = {0, "joypitchsensitivity", "1.0"};
-static cvar_t  joy_yawsensitivity = {0, "joyyawsensitivity", "-1.0"};
-static cvar_t  joy_wwhack1 = {0, "joywwhack1", "0.0"};
-static cvar_t  joy_wwhack2 = {0, "joywwhack2", "0.0"};
+static cvar_t in_joystick = {CVAR_SAVE, "joystick","0", "enables joysticks"};
+static cvar_t joy_name = {0, "joyname", "joystick", "name of joystick to use (informational only, used only by joyadvanced 1 mode)"};
+static cvar_t joy_advanced = {0, "joyadvanced", "0", "use more than 2 axis joysticks (configuring this is very technical)"};
+static cvar_t joy_advaxisx = {0, "joyadvaxisx", "0", "axis mapping for joyadvanced 1 mode"};
+static cvar_t joy_advaxisy = {0, "joyadvaxisy", "0", "axis mapping for joyadvanced 1 mode"};
+static cvar_t joy_advaxisz = {0, "joyadvaxisz", "0", "axis mapping for joyadvanced 1 mode"};
+static cvar_t joy_advaxisr = {0, "joyadvaxisr", "0", "axis mapping for joyadvanced 1 mode"};
+static cvar_t joy_advaxisu = {0, "joyadvaxisu", "0", "axis mapping for joyadvanced 1 mode"};
+static cvar_t joy_advaxisv = {0, "joyadvaxisv", "0", "axis mapping for joyadvanced 1 mode"};
+static cvar_t joy_forwardthreshold = {0, "joyforwardthreshold", "0.15", "minimum joystick movement necessary to move forward"};
+static cvar_t joy_sidethreshold = {0, "joysidethreshold", "0.15", "minimum joystick movement necessary to move sideways (strafing)"};
+static cvar_t joy_pitchthreshold = {0, "joypitchthreshold", "0.15", "minimum joystick movement necessary to look up/down"};
+static cvar_t joy_yawthreshold = {0, "joyyawthreshold", "0.15", "minimum joystick movement necessary to turn left/right"};
+static cvar_t joy_forwardsensitivity = {0, "joyforwardsensitivity", "-1.0", "how fast the joystick moves forward"};
+static cvar_t joy_sidesensitivity = {0, "joysidesensitivity", "-1.0", "how fast the joystick moves sideways (strafing)"};
+static cvar_t joy_pitchsensitivity = {0, "joypitchsensitivity", "1.0", "how fast the joystick looks up/down"};
+static cvar_t joy_yawsensitivity = {0, "joyyawsensitivity", "-1.0", "how fast the joystick turns left/right"};
+static cvar_t joy_wwhack1 = {0, "joywwhack1", "0.0", "special hack for wingman warrior"};
+static cvar_t joy_wwhack2 = {0, "joywwhack2", "0.0", "special hack for wingman warrior"};
 
 static qboolean        joy_avail, joy_advancedinit, joy_haspov;
 static DWORD           joy_oldbuttonstate, joy_oldpovstate;
@@ -1784,7 +1784,7 @@ static void IN_Init(void)
        Cvar_RegisterVariable (&joy_yawsensitivity);
        Cvar_RegisterVariable (&joy_wwhack1);
        Cvar_RegisterVariable (&joy_wwhack2);
-       Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
+       Cmd_AddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f, "applies current joyadv* cvar settings to the joystick driver");
 }
 
 static void IN_Shutdown(void)
diff --git a/view.c b/view.c
index 6f202b1..dacbe7e 100644 (file)
--- a/view.c
+++ b/view.c
@@ -31,45 +31,45 @@ when crossing a water boudnary.
 
 */
 
-cvar_t cl_rollspeed = {0, "cl_rollspeed", "200"};
-cvar_t cl_rollangle = {0, "cl_rollangle", "2.0"};
+cvar_t cl_rollspeed = {0, "cl_rollspeed", "200", "how much strafing is necessary to tilt the view"};
+cvar_t cl_rollangle = {0, "cl_rollangle", "2.0", "how much to tilt the view when strafing"};
 
-cvar_t cl_bob = {0, "cl_bob","0.02"};
-cvar_t cl_bobcycle = {0, "cl_bobcycle","0.6"};
-cvar_t cl_bobup = {0, "cl_bobup","0.5"};
+cvar_t cl_bob = {0, "cl_bob","0.02", "view bobbing amount"};
+cvar_t cl_bobcycle = {0, "cl_bobcycle","0.6", "view bobbing speed"};
+cvar_t cl_bobup = {0, "cl_bobup","0.5", "view bobbing adjustment that makes the up or down swing of the bob last longer"};
 
-cvar_t cl_bobmodel = {0, "cl_bobmodel", "1"};
-cvar_t cl_bobmodel_side = {0, "cl_bobmodel_side", "0.05"};
-cvar_t cl_bobmodel_up = {0, "cl_bobmodel_up", "0.02"};
-cvar_t cl_bobmodel_speed = {0, "cl_bobmodel_speed", "7"};
+cvar_t cl_bobmodel = {0, "cl_bobmodel", "1", "enables gun bobbing"};
+cvar_t cl_bobmodel_side = {0, "cl_bobmodel_side", "0.05", "gun bobbing sideways sway amount"};
+cvar_t cl_bobmodel_up = {0, "cl_bobmodel_up", "0.02", "gun bobbing upward movement amount"};
+cvar_t cl_bobmodel_speed = {0, "cl_bobmodel_speed", "7", "gun bobbing speed"};
 
-cvar_t v_kicktime = {0, "v_kicktime", "0.5"};
-cvar_t v_kickroll = {0, "v_kickroll", "0.6"};
-cvar_t v_kickpitch = {0, "v_kickpitch", "0.6"};
+cvar_t v_kicktime = {0, "v_kicktime", "0.5", "how long a view kick from damage lasts"};
+cvar_t v_kickroll = {0, "v_kickroll", "0.6", "how much a view kick from damage rolls your view"};
+cvar_t v_kickpitch = {0, "v_kickpitch", "0.6", "how much a view kick from damage pitches your view"};
 
-cvar_t v_iyaw_cycle = {0, "v_iyaw_cycle", "2"};
-cvar_t v_iroll_cycle = {0, "v_iroll_cycle", "0.5"};
-cvar_t v_ipitch_cycle = {0, "v_ipitch_cycle", "1"};
-cvar_t v_iyaw_level = {0, "v_iyaw_level", "0.3"};
-cvar_t v_iroll_level = {0, "v_iroll_level", "0.1"};
-cvar_t v_ipitch_level = {0, "v_ipitch_level", "0.3"};
+cvar_t v_iyaw_cycle = {0, "v_iyaw_cycle", "2", "v_idlescale yaw speed"};
+cvar_t v_iroll_cycle = {0, "v_iroll_cycle", "0.5", "v_idlescale roll speed"};
+cvar_t v_ipitch_cycle = {0, "v_ipitch_cycle", "1", "v_idlescale pitch speed"};
+cvar_t v_iyaw_level = {0, "v_iyaw_level", "0.3", "v_idlescale yaw amount"};
+cvar_t v_iroll_level = {0, "v_iroll_level", "0.1", "v_idlescale roll amount"};
+cvar_t v_ipitch_level = {0, "v_ipitch_level", "0.3", "v_idlescale pitch amount"};
 
-cvar_t v_idlescale = {0, "v_idlescale", "0"};
+cvar_t v_idlescale = {0, "v_idlescale", "0", "how much of the quake 'drunken view' effect to use"};
 
-cvar_t crosshair = {CVAR_SAVE, "crosshair", "0"};
+cvar_t crosshair = {CVAR_SAVE, "crosshair", "0", "selects crosshair to use (0 is none)"};
 
-cvar_t v_centermove = {0, "v_centermove", "0.15"};
-cvar_t v_centerspeed = {0, "v_centerspeed","500"};
+cvar_t v_centermove = {0, "v_centermove", "0.15", "how long before the view begins to center itself (if freelook/+mlook/+jlook/+klook are off)"};
+cvar_t v_centerspeed = {0, "v_centerspeed","500", "how fast the view centers itself"};
 
-cvar_t cl_stairsmoothspeed = {CVAR_SAVE, "cl_stairsmoothspeed", "160"};
+cvar_t cl_stairsmoothspeed = {CVAR_SAVE, "cl_stairsmoothspeed", "160", "how fast your view moves upward/downward when running up/down stairs"};
 
-cvar_t chase_back = {CVAR_SAVE, "chase_back", "48"};
-cvar_t chase_up = {CVAR_SAVE, "chase_up", "24"};
-cvar_t chase_active = {CVAR_SAVE, "chase_active", "0"};
+cvar_t chase_back = {CVAR_SAVE, "chase_back", "48", "chase cam distance from the player"};
+cvar_t chase_up = {CVAR_SAVE, "chase_up", "24", "chase cam distance from the player"};
+cvar_t chase_active = {CVAR_SAVE, "chase_active", "0", "enables chase cam"};
 // GAME_GOODVSBAD2
-cvar_t chase_stevie = {0, "chase_stevie", "0"};
+cvar_t chase_stevie = {0, "chase_stevie", "0", "chase cam view from above (used only by GoodVsBad2)"};
 
-cvar_t v_deathtilt = {0, "v_deathtilt", "1"};
+cvar_t v_deathtilt = {0, "v_deathtilt", "1", "whether to use sideways view when dead"};
 
 float  v_dmg_time, v_dmg_roll, v_dmg_pitch;
 
@@ -632,9 +632,9 @@ V_Init
 */
 void V_Init (void)
 {
-       Cmd_AddCommand ("v_cshift", V_cshift_f);
-       Cmd_AddCommand ("bf", V_BonusFlash_f);
-       Cmd_AddCommand ("centerview", V_StartPitchDrift);
+       Cmd_AddCommand ("v_cshift", V_cshift_f, "sets tint color of view");
+       Cmd_AddCommand ("bf", V_BonusFlash_f, "briefly flashes a bright color tint on view (used when items are picked up)");
+       Cmd_AddCommand ("centerview", V_StartPitchDrift, "gradually recenter view (stop looking up/down)");
 
        Cvar_RegisterVariable (&v_centermove);
        Cvar_RegisterVariable (&v_centerspeed);
diff --git a/world.c b/world.c
index 846ece8..8195fa7 100644 (file)
--- a/world.c
+++ b/world.c
@@ -29,8 +29,8 @@ line of sight checks trace->inopen and trace->inwater, but bullets don't
 
 */
 
-cvar_t sv_debugmove = {CVAR_NOTIFY, "sv_debugmove", "0"};
-cvar_t sv_areagrid_mingridsize = {CVAR_NOTIFY, "sv_areagrid_mingridsize", "64"};
+cvar_t sv_debugmove = {CVAR_NOTIFY, "sv_debugmove", "0", "disables collision detection optimizations for debugging purposes"};
+cvar_t sv_areagrid_mingridsize = {CVAR_NOTIFY, "sv_areagrid_mingridsize", "64", "minimum areagrid cell size, smaller values work better for lots of small objects, higher values for large objects"};
 
 void SV_AreaStats_f(void);
 
@@ -38,7 +38,7 @@ void SV_World_Init(void)
 {
        Cvar_RegisterVariable(&sv_debugmove);
        Cvar_RegisterVariable(&sv_areagrid_mingridsize);
-       Cmd_AddCommand("sv_areastats", SV_AreaStats_f);
+       Cmd_AddCommand("sv_areastats", SV_AreaStats_f, "prints information on culling grid system");
        Collision_Init();
 }
 
index 11e212f..1e4c009 100644 (file)
@@ -40,7 +40,7 @@ void CSSV_World_Init(void)
 {
        Cvar_RegisterVariable(&sv_debugmove);
        Cvar_RegisterVariable(&sv_areagrid_mingridsize);
-       Cmd_AddCommand("cssv_areastats", CSSV_AreaStats_f);
+       Cmd_AddCommand("cssv_areastats", CSSV_AreaStats_f, "prints information on culling grid system");
        Collision_Init();
 }
 
diff --git a/zone.c b/zone.c
index 02e5fa7..8eb9196 100644 (file)
--- a/zone.c
+++ b/zone.c
@@ -21,8 +21,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
-cvar_t developer_memory = {0, "developer_memory", "0"};
-cvar_t developer_memorydebug = {0, "developer_memorydebug", "0"};
+cvar_t developer_memory = {0, "developer_memory", "0", "prints debugging information about memory allocations"};
+cvar_t developer_memorydebug = {0, "developer_memorydebug", "0", "enables memory corruption checks (very slow)"};
 
 mempool_t *poolchain = NULL;
 
@@ -474,8 +474,8 @@ void Memory_Shutdown (void)
 
 void Memory_Init_Commands (void)
 {
-       Cmd_AddCommand ("memstats", MemStats_f);
-       Cmd_AddCommand ("memlist", MemList_f);
+       Cmd_AddCommand ("memstats", MemStats_f, "prints memory system statistics");
+       Cmd_AddCommand ("memlist", MemList_f, "prints memory pool information (and individual allocations if used as memlist all)");
        Cvar_RegisterVariable (&developer_memory);
        Cvar_RegisterVariable (&developer_memorydebug);
 }