/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***                            Confidential - Westwood Studios                              ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Commando                                                     *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Commando/consolefunction.cpp                 $*
 *                                                                                             *
 *                      $Author:: Steve_t                                                     $*
 *                                                                                             *
 *                     $Modtime:: 10/13/02 10:13p                                             $*
 *                                                                                             *
 *                    $Revision:: 339                                                         $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "consolefunction.h"
#include "console.h"
#include "textdisplay.h"
#include "combatgmode.h"
#include "combat.h"
#include "datasafe.h"
#include "pscene.h"
#include "playermanager.h"
#include "ccamera.h"
#include "debug.h"
#include "level.h"
#include "weaponmanager.h"
#include "cnetwork.h"
#include "ww3d.h"
#include "miscutil.h"
#include "smartgameobj.h"
#include "weapons.h"
#include "WWAudio.H"
#include "wwprofile.h"
//#include "gamesettings.h"
#include "waypoint.h"
#include "action.h"
#include "gameobjmanager.h"
#include "surfaceeffects.h"
#include "gamedata.h"
#include "damage.h"
#include "radar.h"
#include "assets.h"
#include "animobj.h"
#include "matpass.h"
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "objlibrary.h"
#include "useroptions.h"
#include "devoptions.h"
#include "god.h"
#include "playertype.h"
#include "systemsettings.h"
#include "spawn.h"
#include "input.h"
#include "pathfind.h"
#include "waypath.h"
#include "definitionclassids.h"
#include "netinterface.h"
#include "bandwidth.h"
#include "statistics.h"
#include "physaabtreecull.h"
#include "gametype.h"
#include "part_emt.h"
#include "translatedb.h"
#include "string_ids.h"
#include "dx8renderer.h"
#include "backgroundmgr.h"
#include "dynamicphys.h"
#include "humanphys.h"
#include "vehiclephys.h"
#include "objectives.h"
#include "umbrasupport.h"
#include "vehicle.h"
#include "damageablestaticphys.h"
#include "persistfactory.h"
#include "wwphysids.h"
#include "hud.h"
#include "conversationmgr.h"
#include "basecontroller.h"
#include "building.h"
#include "vendor.h"
#include "texture.h"
#include "rddesc.h"
#include "combatchunkid.h"
#include "dialogtests.h"
#include "resource.h"
#include "dx8wrapper.h"
#include "sortingrenderer.h"
#include "weathermgr.h"
#include "mapmgr.h"
#include "path.h"
#include "sctextobj.h"
#include "consolecommandevent.h"
#include "hudinfo.h"
#include "physresourcemgr.h"
#include "cstextobj.h"
#include "suicideevent.h"
#include "godmodeevent.h"
#include "serverfps.h"
#include "warpevent.h"
//#include "helptext.h"
#include "ffactory.h"
#include "dazzle.h"
#include "renegadedialogmgr.h"
#include "moneyevent.h"
#include "scoreevent.h"
#include "dlgmpingamechat.h"
#include "playerterminal.h"
#include "encyclopediamgr.h"
#include "clientbboevent.h"
#include "wheelvehicle.h"
#include "trackedvehicle.h"
#include "woldiags.h"
#include "packetmgr.h"
#include "requestkillevent.h"
#include "csconsolecommandevent.h"
#include "apppacketstats.h"
#include "bandwidthgraph.h"
#include "scexplosionevent.h"
#include "bwbalance.h"
#include "sbbomanager.h"
#include "_globals.h"
#include "registry.h"
#include "vipmodeevent.h"
#include "dx8rendererdebugger.h"
#include "changeteamevent.h"
#include "gamesideservercontrol.h"
#include "autostart.h"
#include "except.h"
#include "slavemaster.h"
#include "donateevent.h"
#include "consolemode.h"
#include "dlgcncpurchasemainmenu.h"
#include "realcrc.h"
#include "gamespyadmin.h"
#include "gamespybanlist.h"
#include "specialbuilds.h"
#include "lightsolve.h"
#include "lightsolvecontext.h"



void	ConsoleFunctionClass::Print( const char *format, ... )
{
	va_list arg_list;
	va_start (arg_list, format);
	StringClass string;
	string.Format_Args( format, arg_list );
	if (Get_Text_Display()) {
		WWASSERT( Get_Text_Display() );
		Get_Text_Display()->Print_System( string );
	}
	ConsoleBox.Print(string.Peek_Buffer());
	va_end (arg_list);
}

//----------------------------------------------------------------------------
//
// DEVELOPMENT CONSOLE FUNCTIONS ONLY
// Only present in Debug and Profile builds.
//
//----------------------------------------------------------------------------

#ifdef WWDEBUG

/*
** Console Functions
*/
class BuildingStateConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "building_state"; }
	virtual	const char * Get_Alias( void ) { return "bs"; }
	virtual	const char * Get_Help( void )	{ return "BUILDING_STATE <health:0,100> <power:0,1> - force all buildings to the given state"; }
	virtual	void Activate( const char * input ) {

		int health_percentage,power;
		int cnt=sscanf(input, "%d %d", &health_percentage, &power);
		if (cnt == 2) {
			GameObjManager::Debug_Set_All_Building_States((float)health_percentage,(power==1));
			Print("Building States set to Health = %d%%, Power = %d\n",health_percentage,power);
		} else {
			GameObjManager::Debug_Set_All_Building_States(100,1);
			GameObjManager::Debug_Set_All_Building_States(0,1);
			Print("Blew up all buildings!\n");
		}
	}
};

class DSAPOResetConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "dsapo_reset"; }
	virtual	const char * Get_Help( void )	{ return "DSAPO_RESET - force all DSAPO's back to their initial state."; }
	virtual	void Activate( const char * input ) {

		if (COMBAT_SCENE) {
			RefPhysListIterator	it = COMBAT_SCENE->Get_Static_Anim_Object_Iterator();
			for (it.First();!it.Is_Done();it.Next()) {

				if (it.Peek_Obj()->Get_Factory().Chunk_ID() == PHYSICS_CHUNKID_DAMAGEABLESTATICPHYS) {
					DamageableStaticPhysClass * dobj = (DamageableStaticPhysClass *)it.Peek_Obj();
					dobj->Reset_Health();
				}
			}
		}

		int health_percentage,power;
		int cnt=sscanf(input, "%d %d", &health_percentage, &power);
		if (cnt == 2) {
			GameObjManager::Debug_Set_All_Building_States((float)health_percentage,(power==1));
			Print("Building States set to Health = %d%%, Power = %d\n",health_percentage,power);
		} else {
			GameObjManager::Debug_Set_All_Building_States(100,1);
			GameObjManager::Debug_Set_All_Building_States(0,1);
			Print("Blew up all buildings!\n");
		}
	}
};

class HUDConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "hud"; }
	virtual	const char * Get_Help( void )	{ return "HUD - toggles the HUD."; }
	virtual	void Activate( const char * input ) {
		HUDClass::Enable( !HUDClass::Is_Enabled() );
      Print( "HUD toggled\n" );
	}
};


class PatsDebugConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "pat"; }
	virtual	const char * Get_Help( void )	{ return "PAT - Pat's generic debug console function."; }
	virtual	void Activate( const char * input )
	{
		RenegadeDialogMgrClass::Goto_Location (RenegadeDialogMgrClass::LOC_INTERNET_MAIN);
		return ;
	}
};


class TextureMemoryCounterConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "texture_memory_counter"; }
	virtual	const char * Get_Help( void )	{ return "TEXTURE_MEMORY_COUNTER - 0=off 1=on 2=details"; }
	virtual	void Activate( const char * input ) {
		Debug_Statistics::RecordTextureMode b;
		if (sscanf(input, "%d", &b) == 1) {
			Debug_Statistics::Record_Texture_Mode(b);
		}
	}
};


class MeshDebuggerEnableConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "mesh_debugger_enable"; }
	virtual	const char * Get_Help( void )	{ return "MESH_DEBUGGER_ENABLE - 0=off 1=on"; }
	virtual	void Activate( const char * input ) {
		unsigned onoff;
		if (sscanf(input, "%d", &onoff) == 1) {
			DX8RendererDebugger::Enable(!!onoff);
		}
	}
};

class MeshDebuggerEnableMeshConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "mesh_debugger_enable_mesh"; }
	virtual	const char * Get_Help( void )	{ return "MESH_DEBUGGER_ENABLE_MESH - id0 ... id9"; }
	virtual	void Activate( const char * input ) {
		// Parameter '*' means ALL meshes
		char string[200];
		sscanf(input, "%s", string);
		if (!stricmp("*",string)) {
			DX8RendererDebugger::Enable_All();
		}
		else {
			unsigned id[10];
			unsigned count=sscanf(input, "%d %d %d %d %d %d %d %d %d %d",
				&id[0], &id[1], &id[2], &id[3], &id[4], &id[5], &id[6], &id[7], &id[8], &id[9]);
			for (unsigned i=0;i<count;++i) {
				DX8RendererDebugger::Enable_Mesh(id[i]);
			}
		}
	}
};

class MeshDebuggerDisableMeshConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "mesh_debugger_disable_mesh"; }
	virtual	const char * Get_Help( void )	{ return "MESH_DEBUGGER_DISABLE_MESH - id0 ... id9"; }
	virtual	void Activate( const char * input ) {
		// Parameter '*' means ALL meshes
		char string[200];
		sscanf(input, "%s", string);
		if (!stricmp("*",string)) {
			DX8RendererDebugger::Disable_All();
		}
		else {
			unsigned id[10];
			unsigned count=sscanf(input, "%d %d %d %d %d %d %d %d %d %d",
				&id[0], &id[1], &id[2], &id[3], &id[4], &id[5], &id[6], &id[7], &id[8], &id[9]);
			for (unsigned i=0;i<count;++i) {
				DX8RendererDebugger::Disable_Mesh(id[i]);
			}
		}
	}
};


class FlashTextureConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "flash_texture"; }
	virtual	const char * Get_Help( void )	{ return "FLASH_TEXTURE <ID> <0/1> - sets texture flashing"; }
	virtual	void Activate( const char * input ) {
#ifdef WW3D_DX8
		int id,state;
		int cnt=sscanf(input, "%d %d", &id, &state);
		TextureFileClass* tfc=NULL;
		if (cnt>=1) tfc=TextureFileClass::Get_Texture(id);
		if (tfc) {
			if (cnt==1) {
				state=!tfc->Get_Texture_Flash();
				tfc->Set_Texture_Flash(!!state);
			}
			else if (cnt==2) {
				tfc->Set_Texture_Flash(!!state);
			}
			StringClass tmp;
			if (state) {
				tmp.Format("Texture %s (id=%d) set FLASHING\n",tfc->Get_File_Name(),tfc->ID());
			}
			else {
				tmp.Format("Texture %s (id=%d) set not flashing\n",tfc->Get_File_Name(),tfc->ID());
			}
			Print(tmp);
		}
#endif //WW3D_DX8
	}
};


class FogRangeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "fog_range"; }
	virtual	const char * Get_Help( void )	{ return "FOG_RANGE <start [0+]> <end [0+]> [ramptime [0+]] - Sets fog range.";}
	virtual	void Activate( const char * input ) {

		const char *feedbackstring = "Fog range changed\n";

		int	argcount;
		float	arg0, arg1, arg2;
		bool	success = false;

		argcount = sscanf (input, "%f %f %f", &arg0, &arg1, &arg2);
		switch (argcount) {

			case 2:
				success = WeatherMgrClass::Set_Fog_Range (arg0, arg1);
				break;

			case 3:
				success = WeatherMgrClass::Set_Fog_Range (arg0, arg1, arg2);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class FogToggleConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{ return "fog_toggle"; }
	virtual	const char * Get_Help (void)	{ return "FOG_TOGGLE - toggles fog on/off."; }
	virtual	void Activate (const char *input) {

		const char *_statusstring [2] = {"Fog disabled\n", "Fog enabled\n"};

		WeatherMgrClass::Set_Fog_Enable (!WeatherMgrClass::Get_Fog_Enable());
		Print (_statusstring [WeatherMgrClass::Get_Fog_Enable()]);
	}
};


class LightModeConsoleFunctionClass : public ConsoleFunctionClass {
	virtual	const char * Get_Name (void)	{ return "light_mode"; }
	virtual	const char * Get_Help (void)	{ return "LIGHT_MODE <0,1,2> - 0=none, 1=surrender, 2=cheap."; }
	virtual	void Activate (const char *input) {
		int mode;
		if (sscanf(input, "%d", &mode) == 1) {
			COMBAT_SCENE->Set_Lighting_Mode(mode);
		}

		switch(COMBAT_SCENE->Get_Lighting_Mode()) {
		case PhysicsSceneClass::LIGHTING_MODE_SURRENDER:
			Print ("Lighting Mode: SURRENDER");
			break;

		case PhysicsSceneClass::LIGHTING_MODE_CHEAP:
			Print ("Lighting Mode: CHEAP");
			break;

		default:
			Print ("Lighting Mode: NONE");
			break;
		}
	}
};

class LightDebugToggleConsoleFunctionClass : public ConsoleFunctionClass {
	virtual	const char * Get_Name (void)	{ return "light_debug"; }
	virtual	const char * Get_Help (void)	{ return "LIGHT_DEBUG - toggles lighting debugging on/off."; }
	virtual	void Activate (const char *input) {
		COMBAT_SCENE->Enable_Lighting_Debug_Display(!COMBAT_SCENE->Is_Lighting_Debug_Display_Enabled());
		if (COMBAT_SCENE->Is_Lighting_Debug_Display_Enabled()) {
			Print ("Lighting debug display ENABLED");
		} else {
			Print ("Lighting debug display DISABLED");
		}
	}
};

class LightLODConsoleFunctionClass : public ConsoleFunctionClass {
	virtual	const char * Get_Name (void)	{ return "light_lod"; }
	virtual	const char * Get_Help (void)	{ return "LIGHT_LOD <intensity> - sets the LOD cutoff for lighting."; }
	virtual	void Activate (const char *input) {
		float inten;
		if (sscanf(input, "%f", &inten) == 1) {
			COMBAT_SCENE->Set_Lighting_LOD_Cutoff(inten);
		}
		Print("Lighting LOD: %d\r\n",COMBAT_SCENE->Get_Lighting_LOD_Cutoff());
	}
};

class LightCalcConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "light_calc"; }
	virtual	const char * Get_Help( void )	{ return "LIGHT_CALC - computes a static vertex lighting solve"; }
	virtual	void Activate( const char * input ) {
		if (COMBAT_SCENE) {
			LightSolveContextClass context;
			LightSolveClass::Generate_Static_Light_Solve(context);
		}
	}
};



class CameraConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "camera"; }
	virtual	const char * Get_Help( void )	{ return "CAMERA <NAME> - switches to camera profile <name>."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_CAMERA ) {
			COMBAT_CAMERA->Use_Profile( input );
		   Print( "Profile Changed\n" );
		}
	}
};

class VisConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_toggle"; }
	virtual	const char * Get_Help( void )	{ return "VIS_TOGGLE - toggles vis culling."; }
	virtual	void Activate( const char * input ) {
		COMBAT_SCENE->Enable_Vis(!COMBAT_SCENE->Is_Vis_Enabled());
		if (COMBAT_SCENE->Is_Vis_Enabled()) {
			Print("vis enabled\n");
		} else {
			Print("vis disabled\n");
		}
	}
};

class VisInvertConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_invert"; }
	virtual	const char * Get_Help( void )	{ return "VIS_INVERT - toggles vis invert setting."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Invert_Vis(!COMBAT_SCENE->Is_Vis_Inverted());
		if (COMBAT_SCENE->Is_Vis_Inverted()) {
			Print("vis_invert enabled\n");
		} else {
			Print("vis_invert disabled\n");
		}
	}
};

class VisGridDisplayConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_grid_display"; }
	virtual	const char * Get_Help( void )	{ return "VIS_GRID_DISPLAY <0,1,2,3> - 0=off, 1=boxes, 2=centers, 3=occupied."; }
	virtual	void Activate( const char * input ) {

		int mode = 0;
		if (sscanf(input, "%d", &mode) == 1) {
			COMBAT_SCENE->Set_Vis_Grid_Display_Mode(mode);
			if (mode == 0) {
				Print("vis_grid_display off\n");
			} else if (mode == 1) {
				Print("vis_grid_display boxes\n");
			} else if (mode == 2) {
				Print("vis_grid_display centers\n");
			} else if (mode == 3) {
				Print("vis_grid_display occupied\n");
			}
		}
	}
};

class VisGridDebugConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_grid_debug"; }
	virtual	const char * Get_Help( void )	{ return "VIS_GRID_DEBUG <p,s,f,b,r> - p=parent,s=sibling,f=front,b=back,r=reset"; }
	virtual	void Activate( const char * input ) {

		char mode = 0;
		if (sscanf(input, "%c", &mode) == 1) {
			mode = toupper(mode);

			if (mode == 'P') {
				if (COMBAT_SCENE->Vis_Grid_Debug_Enter_Parent()) {
					Print("Entered parent node\n");
				} else {
					Print("No parent node\n");
				}
			} else if (mode == 'S') {
				if (COMBAT_SCENE->Vis_Grid_Debug_Enter_Sibling()) {
					Print("Entered sibling\n");
				} else {
					Print("No sibling\n");
				}
			} else if (mode == 'F') {
				if (COMBAT_SCENE->Vis_Grid_Debug_Enter_Front_Child()) {
					Print("Entered front child\n");
				} else {
					Print("No front child\n");
				}
			} else if (mode == 'B') {
				if (COMBAT_SCENE->Vis_Grid_Debug_Enter_Back_Child()) {
					Print("Entered back child\n");
				} else {
					Print("No back child\n");
				}
			} else if (mode == 'R') {
				COMBAT_SCENE->Vis_Grid_Debug_Reset_Node();
				Print("Reset to root\n");
			}
		}
	}
};

class VisHierarchicalConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_hierarchical"; }
	virtual	const char * Get_Help( void )	{ return "VIS_HIERARCHICAL - toggles hierarchical vis culling."; }
	virtual	void Activate( const char * input ) {

		PhysAABTreeCullClass::Enable_Hierarchical_Vis_Culling(!PhysAABTreeCullClass::Is_Hierarchical_Vis_Culling_Enabled());
		if (PhysAABTreeCullClass::Is_Hierarchical_Vis_Culling_Enabled()) {
			Print("hierarchical vis culling enabled\n");
		} else {
			Print("hierarchical vis culling disabled\n");
		}
	}
};

class VisLockConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_lock_sample_point"; }
	virtual	const char * Get_Help( void )	{ return "VIS_LOCK_SAMPLE_POINT - locks/unlocks the current pvs."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Lock_Vis_Sample_Point(!COMBAT_SCENE->Is_Vis_Sample_Point_Locked());
		if (COMBAT_SCENE->Is_Vis_Sample_Point_Locked()) {
			Print("Vis sample point locked.\n");
		} else {
			Print("Vis sample point unlocked.\n");
		}
	}
};

class VisSectorDisplayConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_sector_display"; }
	virtual	const char * Get_Help( void )	{ return "VIS_SECTOR_DISPLAY - toggles diplay of the current vis sector."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Enable_Vis_Sector_Display(!COMBAT_SCENE->Is_Vis_Sector_Display_Enabled());
		if (COMBAT_SCENE->Is_Vis_Sector_Display_Enabled()) {
			Print("vis_sector_display enabled\n");
		} else {
			Print("vis_sector_display disabled\n");
		}
	}
};

class VisSectorHistoryConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "vis_sector_history"; }
	virtual	const char * Get_Help( void )	{ return "VIS_SECTOR_HISTORY - toggles diplay of the previous 3 vis sectors."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Enable_Vis_Sector_History_Display(!COMBAT_SCENE->Is_Vis_Sector_History_Display_Enabled());
		if (COMBAT_SCENE->Is_Vis_Sector_History_Display_Enabled()) {
			Print("vis_sector_history enabled\n");
		} else {
			Print("vis_sector_history disabled\n");
		}
	}
};


class SuicideConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "suicide"; }
	virtual	const char * Get_Help( void )	{ return "SUICIDE - kill your commando."; }
	virtual	void Activate( const char * input ) {
		if (cNetwork::I_Am_Client()) {
         Print("Committing suicide.\n");

			cSuicideEvent * p_suicide = new cSuicideEvent;
			p_suicide->Init();

		} else {
         Print("Only clients can commit suicide.\n");
		}
	}
};


class ShadowAttenuationConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_attenuation"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_ATTENUATION <near> <far> - set the attenuation ranges for shadows."; }
	virtual	void Activate( const char * input ) {
		PhysicsSceneClass * scene = PhysicsSceneClass::Get_Instance();
		float znear,zfar;
		if (sscanf(input, "%f %f",&znear,&zfar) == 2) {
			scene->Set_Shadow_Attenuation(znear,zfar);
			scene->Get_Shadow_Attenuation(&znear,&zfar);
			Print("shadow attenuation set to %f %f\n",znear,zfar);
		}
	}
};

class ShadowBlobTextureConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_blob_texture"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_BLOB_TEXTURE <texture filename> - sets the texture to use for blob shadows."; }
	virtual	void Activate( const char * input ) {
		if (strlen(input) > 0) {
			if (PhysResourceMgrClass::Set_Shadow_Blob_Texture(input)) {
				Print("shadow blob texture set to: %s\n",input);
			}
		}
	}
};

class ShadowElevationConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_elevation"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_ELEVATION <elevation degrees> - sets the angle of the shadow projection."; }
	virtual	void Activate( const char * input )
	{
		/*
		** NOTE: THIS IS JUST TEST CODE TO SEE HOW VARIOUS SHADOW ALGORITHMS
		** WORK WITH VARIOUS SUN-LIGHT ANGLES.  THE SUN IS NOT TO BE MOVED IN-GAME!!!
		*/
		PhysicsSceneClass * scene = PhysicsSceneClass::Get_Instance();

		float elevation,rotation;
		scene->Get_Sun_Light_Orientation(&rotation,&elevation);
		if (sscanf(input, "%f",&elevation) == 1) {
			scene->Set_Sun_Light_Orientation(rotation,DEG_TO_RADF(elevation));
		}
	}
};


class ShadowIntensityConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_intensity"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_INTENSITY <intensity> - sets the darkness of dynamic shadows (0 - 1)."; }
	virtual	void Activate( const char * input )
	{
		PhysicsSceneClass * scene = PhysicsSceneClass::Get_Instance();
		scene->Set_Shadow_Normal_Intensity(atof(input));
		Print("shadow intensity set to: %f\n",scene->Get_Shadow_Normal_Intensity());
	}
};

class ShadowPerPolyCullingConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_per_poly_culling"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_PER_POLY_CULLING - toggles per poly shadow culling."; }
	virtual	void Activate( const char * input )
	{
		MaterialPassClass::Enable_Per_Polygon_Culling(!MaterialPassClass::Is_Per_Polygon_Culling_Enabled());
		if (MaterialPassClass::Is_Per_Polygon_Culling_Enabled()) {
			Print("per-polygon shadow culling enabled!\n");
		} else {
			Print("per-polygon shadow culling disabled\n");
		}
	}
};

class ShadowResolutionConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_resolution"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_RESOLUTION <res> - sets the resolution of dynamic shadows (use a power of 2!)"; }
	virtual	void Activate( const char * input )
	{
		PhysicsSceneClass * scene = PhysicsSceneClass::Get_Instance();
		scene->Set_Shadow_Resolution(atof(input));
		Print("shadow resolution set to: %f\n",scene->Get_Shadow_Resolution());
	}
};

class ShadowCountConsoleFunctionClass : public ConsoleFunctionClass
{
	virtual	const char * Get_Name( void )	{ return "shadow_count"; }
	virtual	const char * Get_Help( void )	{ return "SHADOW_COUNT <count> - sets the maximum simultaneous shadows"; }
	virtual	void Activate( const char * input )
	{
		PhysicsSceneClass * scene = PhysicsSceneClass::Get_Instance();
		scene->Set_Max_Simultaneous_Shadows(atof(input));
		Print("simultaneous shadow count set to: %f\n",scene->Get_Max_Simultaneous_Shadows());
	}
};


class PhysicsDebugConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "physics_debug"; }
	virtual	const char * Get_Help( void )	{ return "PHYSICS_DEBUG - toggles physics debugging display."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Enable_Debug_Display(!COMBAT_SCENE->Is_Debug_Display_Enabled());
		if (COMBAT_SCENE->Is_Debug_Display_Enabled()) {
			Print("physics debug display enabled!\n");
		} else {
			Print("physics debug display disabled :-(\n");
		}
	}
};

class Phys3NetConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "phys3_net"; }
	virtual	const char * Get_Help( void )	{ return "PHYS3_NET <allowable_error> <pop_error> <corr_time> - sets the phys3 networking constants."; }
	virtual	void Activate( const char * input ) {
		float corr_time,allow_error,pop_error;
		int params = sscanf(input, "%f %f %f",&allow_error,&pop_error,&corr_time);
		if (params == 3) {
			Phys3Class::Set_Allowable_Error(allow_error);
			Phys3Class::Set_Pop_Error(pop_error);
			Phys3Class::Set_Correction_Time(corr_time);
		}
		Print("Phys3 Network Params: allowable_error = %f\r\n",Phys3Class::Get_Allowable_Error());
		Print("Phys3 Network Params: pop_error = %f\r\n",Phys3Class::Get_Pop_Error());
		Print("Phys3 Network Params: correction_time = %f\r\n",Phys3Class::Get_Correction_Time());
	}
};

class RBodyNetConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "rbody_net"; }
	virtual	const char * Get_Help( void )	{ return "rbody_net <corr_time> - sets the rigid body correction time."; }
	virtual	void Activate( const char * input ) {
		float corr_time;
		int params = sscanf(input, "%f",&corr_time );
		if (params == 3) {
			RigidBodyClass::Set_Correction_Time(corr_time);
		}
		Print("Rigid Body Network Params: correction_time = %f\r\n",RigidBodyClass::Get_Correction_Time());
	}
};

class ProjectorDebugConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "projector_debug"; }
	virtual	const char * Get_Help( void )	{ return "PROJECTOR_DEBUG - toggles projector debugging display."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Enable_Projector_Debug_Display(!COMBAT_SCENE->Is_Projector_Debug_Display_Enabled());
		if (COMBAT_SCENE->Is_Projector_Debug_Display_Enabled()) {
			Print("projector debug display enabled!\n");
		} else {
			Print("projector debug display disabled :-(\n");
		}
	}
};

class DirtyCullDebugConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "dirty_cull_debug"; }
	virtual	const char * Get_Help( void )	{ return "DIRTY_CULL_DEBUG - toggles debugging of the dirty-cull-list."; }
	virtual	void Activate( const char * input ) {

		COMBAT_SCENE->Enable_Dirty_Cull_Debug_Display(!COMBAT_SCENE->Is_Dirty_Cull_Debug_Display_Enabled());
		if (COMBAT_SCENE->Is_Dirty_Cull_Debug_Display_Enabled()) {
			Print("dirty cull debug display enabled!\n");
		} else {
			Print("dirty cull debug display disabled.\n");
		}
	}
};

class NextRenderConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "next_render"; }
	virtual	const char * Get_Help( void )	{ return "NEXT_RENDER - switches to the next render device."; }
	virtual	void Activate( const char * input ) {
		WW3D::Set_Next_Render_Device();
	}
};

class OneShotKillsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "one_shot_kills"; }
	virtual	const char * Get_Alias( void )	{ return "osk"; }
	virtual	const char * Get_Help( void )	{ return "ONE_SHOT_KILLS - kill or destroy with one shot. Server only."; }
	virtual	void Activate( const char * input ) {

		if (cNetwork::I_Am_Server()) {
         bool osk = false;

#ifdef WWDEBUG
			osk = DefenseObjectClass::Toggle_One_Shot_Kills();
#endif // WWDEBUG

         Print( "One Shot Kills: %s\n", osk ? "ON" : "OFF");
		} else {
         Print(Get_Help());
		}
	}
};

class OpenConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "open"; }
	virtual	const char * Get_Help( void )	{ return "OPEN [regedit|logfile|ini ininame] - open specified object."; }
	virtual	void Activate( const char * input ) {

		if (!stricmp(input, "regedit")) {
			cNetwork::Shell_Command("regedit");
		} else if (!stricmp(input, "logfile")) {
			cNetwork::Shell_Command(DebugManager::Logfile_Name());
		} else if (strstr(input, "ini")) {
			char filename[200];
			sscanf(input, "ini %s", filename);
			char open_command[200];
			sprintf(open_command, "data\\%s.ini", filename);
			cNetwork::Shell_Command(open_command);
		} else {
		   Print(Get_Help());
		}
	}
};

class InvalidateMeshCacheConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "invalidate_mesh_cache"; }
	virtual	const char * Get_Help( void )	{ return "INVALIDATE_MESH_CACHE - invalidates all cached mesh data."; }
	virtual	void Activate( const char * input ) {
		WW3D::_Invalidate_Mesh_Cache();
      Print( "Mesh cache invalidated." );
	}
};

class InvalidateTexturesConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "invalidate_textures"; }
	virtual	const char * Get_Help( void )	{ return "INVALIDATE_TEXTURES - invalidates all textures."; }
	virtual	void Activate( const char * input ) {
		WW3D::_Invalidate_Textures();
      Print( "Textures invalidated." );
	}
};

class TexturingEnableConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "texturing_enable"; }
	virtual	const char * Get_Help( void )	{ return "TEXTURING_ENABLE toggle texturing."; }
	virtual	void Activate( const char * input ) {
		WW3D::Enable_Texturing(!WW3D::Is_Texturing_Enabled());
		Print( "Textures switched." );
	}
};

class ExposePrelitConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "expose_prelit"; }
	virtual	const char * Get_Help( void )	{ return "EXPOSE_PRELIT - expose precalculated lighting on meshes."; }
	virtual	void Activate( const char * input ) {

		static char *_comment [2] = {
			"Unexposed prelit meshes\n",
			"Exposed	prelit meshes\n"
		};

		WW3D::Expose_Prelit (!WW3D::Expose_Prelit());
		Print (_comment [WW3D::Expose_Prelit() ? 1 : 0]);
	}
};

class PlayerPositionConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "player_position"; }
	//virtual	const char * Get_Alias( void )	{ return "pp"; }
	virtual	const char * Get_Help( void )	{ return "PLAYER_POSITION - toggles the players world position display."; }
	virtual	void Activate( const char * input ) {
		Get_Console()->Toggle_Player_Position();
	}
};

class ToggleAssetPreloadingConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_preloading"; }
	virtual	const char * Get_Help( void )	{ return "TOGGLE_PRELOADING - toggles asset preloading."; }
	virtual	void Activate( const char * input ) {
		bool is_preloading = cDevOptions::PreloadAssets.Toggle();
      Print(is_preloading ? "Assets WILL preload.\n" : "Assets will NOT preload.\n" );
	}
};

class ToggleRenderingConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_rendering"; }
	virtual	const char * Get_Help( void )	{ return "TOGGLE_RENDERING <static,dynamic,human,vehicles> - toggles rendering of various types."; }
	virtual	void Activate( const char * input ) {

		/*
		** Note: I'm only comparing the first two characters so the user doesn't have to type the whole thing
		*/
		if (_strnicmp(input,"st",2) == 0) {

			StaticPhysClass::Disable_All_Rendering(!StaticPhysClass::Is_All_Rendering_Disabled());
			Print(StaticPhysClass::Is_All_Rendering_Disabled() ? "Static object rendering DISABLED" : "Static object rendering ENABLED");

		} else if (_strnicmp(input,"dy",2) == 0) {

			DynamicPhysClass::Disable_All_Rendering(!DynamicPhysClass::Is_All_Rendering_Disabled());
			Print(DynamicPhysClass::Is_All_Rendering_Disabled() ? "Dynamic object rendering DISABLED" : "Dynamic object rendering ENABLED");

		} else if (_strnicmp(input,"hu",2) == 0) {

			HumanPhysClass::Disable_All_Rendering(!HumanPhysClass::Is_All_Rendering_Disabled());
			Print(HumanPhysClass::Is_All_Rendering_Disabled() ? "Human object rendering DISABLED" : "Human object rendering ENABLED");

		} else if (_strnicmp(input,"ve",2) == 0) {

			VehiclePhysClass::Disable_All_Rendering(!VehiclePhysClass::Is_All_Rendering_Disabled());
			Print(VehiclePhysClass::Is_All_Rendering_Disabled() ? "Vehicle object rendering DISABLED" : "Vehicle object rendering ENABLED");

		}
	}
};


class ToggleSimulationConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_simulation"; }
	virtual	const char * Get_Help( void )	{ return "TOGGLE_SIMULATION <static,dynamic,human,vehicles> - toggles rendering of various types."; }
	virtual	void Activate( const char * input ) {

		/*
		** Note: I'm only comparing the first two characters so the user doesn't have to type the whole thing
		*/
		if (_strnicmp(input,"st",2) == 0) {

			StaticPhysClass::Disable_All_Simulation(!StaticPhysClass::Is_All_Simulation_Disabled());
			Print(StaticPhysClass::Is_All_Simulation_Disabled() ? "Static object Simulation DISABLED" : "Static object Simulation ENABLED");

		} else if (_strnicmp(input,"dy",2) == 0) {

			DynamicPhysClass::Disable_All_Simulation(!DynamicPhysClass::Is_All_Simulation_Disabled());
			Print(DynamicPhysClass::Is_All_Simulation_Disabled() ? "Dynamic object Simulation DISABLED" : "Dynamic object Simulation ENABLED");

		} else if (_strnicmp(input,"hu",2) == 0) {

			HumanPhysClass::Disable_All_Simulation(!HumanPhysClass::Is_All_Simulation_Disabled());
			Print(HumanPhysClass::Is_All_Simulation_Disabled() ? "Human object Simulation DISABLED" : "Human object Simulation ENABLED");

		} else if (_strnicmp(input,"ve",2) == 0) {

			VehiclePhysClass::Disable_All_Simulation(!VehiclePhysClass::Is_All_Simulation_Disabled());
			Print(VehiclePhysClass::Is_All_Simulation_Disabled() ? "Vehicle object Simulation DISABLED" : "Vehicle object Simulation ENABLED");

		}
	}
};


class TomConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "tom"; }
	virtual	const char * Get_Help( void )	{ return "TOM - Annoyance-reduction registry tweaks customized by Tom."; }
	virtual	void Activate( const char * input ) {

		//
		// Enable a good level of diagnostics - all devices and types except
		// screen and netprolific
		//
      ConsoleFunctionManager::Parse_Input("debug_device on");
      ConsoleFunctionManager::Parse_Input("debug_device screen");
      ConsoleFunctionManager::Parse_Input("debug_type on");
      ConsoleFunctionManager::Parse_Input("debug_type netprolific");

		//
		// Set max scroll lines
		//
		if (Get_Text_Display()) {
			WWASSERT(Get_Text_Display() != NULL);
			Get_Text_Display()->Set_Max_Scroll_Lines(10);
		}

		//
		// Debug flags
		//
		//cDevOptions::ShowDiagnostics.Set(true);
		cDevOptions::PreloadAssets.Set(false);
		cDevOptions::ShowFps.Set(true);
		cDevOptions::ShowGodStatus.Set(true);
		cDevOptions::CompareExeVersionOnNetwork.Set(false);
		cDevOptions::CrtDbgEnabled.Set(false);
		cDevOptions::LogDataSafe.Set(false);
		cDevOptions::FilterLevelFiles.Set(false);
		cDevOptions::ShowThumbnailPreInitDialog.Set(false);

		//
		// Release flags
		//
		cUserOptions::ShowNamesOnSoldier.Set(true);
		cUserOptions::CameraLockedToTurret.Set(true);
		cUserOptions::SkipQuitConfirmDialog.Set(true);
		cUserOptions::SkipIngameQuitConfirmDialog.Set(true);
		cUserOptions::PermitDiagLogging.Set(false);

		//
		// Set 800 x 600, windowed mode
		//
		{
		RegistryClass registry(APPLICATION_SUB_KEY_NAME_RENDER);
		WWASSERT(registry.Is_Valid());
		registry.Set_Int(VALUE_NAME_RENDER_DEVICE_WIDTH, 800);
		registry.Set_Int(VALUE_NAME_RENDER_DEVICE_HEIGHT, 600);
		registry.Set_Int(VALUE_NAME_RENDER_DEVICE_WINDOWED, TRUE);
		}

		/*
		//
		// Stop Jani from spying on us (avoid delay on exit)
		//
		{
		RegistryClass registry(APPLICATION_SUB_KEY_NAME_DEBUG);
		WWASSERT(registry.Is_Valid());
		registry.Set_Int("SystemInfoLogDisable", TRUE);
		registry.Set_Int("DisableLogCopying", TRUE);
		}
		*/

		//
		// Default to third person
		//
		{
		RegistryClass registry(APPLICATION_SUB_KEY_NAME_OPTIONS);
		WWASSERT(registry.Is_Valid());
		registry.Set_Int("DefaultToFirstPerson", FALSE);
		}

		//
		// Skip intro movies
		//
		{
		RegistryClass registry(APPLICATION_SUB_KEY_NAME_OPTIONS);
		WWASSERT(registry.Is_Valid());
		registry.Set_Int("SkipAllIntroMovies", TRUE);
		}

		//
		// Do not require CD for movies
		//
		{
		RegistryClass registry(APPLICATION_SUB_KEY_NAME_DEBUG);
		WWASSERT(registry.Is_Valid());
		registry.Set_Int("DisableCDCheck", TRUE);
		}

		//
		// Set gamma etc so that they don't screw up debugging
		//
		{
		RegistryClass registry(APPLICATION_SUB_KEY_NAME_SYSTEM_SETTINGS);
		WWASSERT(registry.Is_Valid());
		registry.Set_Int("Gamma",			1);
		registry.Set_Int("Brightness",	0);
		registry.Set_Int("Contrast",		1);
		}
	}
};

class RenderBoxesConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "render_boxes"; }
	virtual	const char * Get_Help( void )	{ return "RENDER_BOXES <mask> - enables rendering of boxes.  0=none 1=all 2=physical 4=projectile."; }
	virtual	void Activate( const char * input ) {
		int mask = atoi(input);
		WW3D::Set_Collision_Box_Display_Mask(mask);
	}
};

class AmbientLightConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "ambient_light"; }
	virtual	const char * Get_Help( void )	{ return "AMBIENT_LIGHT <R> <G> <B> - sets the ambeint light color to <r> <g> <b>."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_SCENE ) {
			float r, g, b;
			if (sscanf(input, "%f %f %f", &r, &g, &b) == 3) {
		      COMBAT_SCENE->Set_Ambient_Light(Vector3(r, g, b));
		      Print( "Ambient Light changed\n" );
			}
		} else {
		   Print( "Error : no COMBAT_SCENE\n" );
		}
	}
};

class VblankSyncConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "vblank_sync"; }
	virtual	const char * Get_Help( void )	{ return "VBLANK_SYNC - toggles vblank syncing"; }
	virtual	void Activate( const char * input ) {

		if (WW3D::Get_Ext_Swap_Interval() == 0) {
			WW3D::Set_Ext_Swap_Interval(1);
			Print("Vblank syncing ENABLED!\n");
		} else {
			WW3D::Set_Ext_Swap_Interval(0);
			Print("Vblank syncing DISABLED!\n");
		}
	}
};

class FrameTexturesConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "frame_textures"; }
	virtual	const char * Get_Help( void )	{ return "FRAME_TEXTURES - measures the amoutn of textures needed for the next frame."; }
	virtual	void Activate( const char * input ) {
		DebugManager::Measure_Frame_Textures();
	}
};

class DebugObjectivesConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "objectives_debug"; }
	virtual	const char * Get_Help( void )	{ return "OBJECTIVES_DEBUG - toggles Mission Objectives debug mode."; }
	virtual	void Activate( const char * input ) {
		bool enable_mode = !ObjectiveManager::Is_Objective_Debug_Mode_Enabled();
		ObjectiveManager::Enable_Objective_Debug_Mode( enable_mode );
		if (enable_mode) {
			Print( "Activating Mission Objectives Debug Mode.\n" );
		} else {
			Print( "Deactivating Mission Objectives Debug Mode.\n" );
		}
	}
};


class FreeWeaponsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "free_weapons"; }
	virtual	const char * Get_Help( void )	{ return "FREE_WEAPONS - toggle free_weapons flag (server only)."; }
	virtual	void Activate( const char * input ) {
      if (!cNetwork::I_Am_Server()) {
			Print("Only the server can toggle free-weapons.\n");
      } else {
			WWASSERT(PTheGameData != NULL);
			bool on = The_Game()->IsFreeWeapons.Toggle();
         Print("Free weapons is %s.\n", on ? "ON" : "OFF");

			if (on) {
				//
				// Give everyone free weapons right away
				//
				SLNode<SmartGameObj> * objnode;
				for (objnode = GameObjManager::Get_Smart_Game_Obj_List()->Head(); objnode; objnode = objnode->Next()) {
					SmartGameObj * p_smart_obj = objnode->Data();
					WWASSERT(p_smart_obj != NULL);
					if (p_smart_obj->As_SoldierGameObj() != NULL &&
						p_smart_obj->Get_Player_Type() != PLAYERTYPE_NEUTRAL) {
						p_smart_obj->As_SoldierGameObj()->Give_All_Weapons();
					}
				}
			}
      }
	}
};


class ToggleEmotIconsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_emoticons"; }
	virtual	const char * Get_Help( void )	{ return "TOGGLE_EMOTICONS - Toggle the display of emot icons during conversations."; }
	virtual	void Activate( const char * /*input*/ ) {

		bool display = !ConversationMgrClass::Are_Emot_Icons_Displayed ();
		ConversationMgrClass::Display_Emot_Icons (display);

		if (display) {
			Print( "EmotIcons are now enabled.\n" );
		} else {
			Print( "EmotIcons are now disabled.\n" );
		}
	}
};


class SoldierGhostDebugDisplayConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_ghost_debug_display"; }
	virtual	const char * Get_Help( void )	{ return "toggle_ghost_debug_display - Displays a box around soldiers that are in 'ghost' collision mode."; }
	virtual	void Activate( const char * input ) {

		bool enable = !SoldierGameObj::Is_Ghost_Collision_Debug_Display_Enabled ();
		SoldierGameObj::Enable_Ghost_Collision_Debug_Display (enable);

		if (enable) {
			Print( "Ghost collision debug display enabled.\n" );
		} else {
			Print( "Ghost collision debug display disabled.\n" );
		}

		return ;
	}
};


class HUDHelpTextTestConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "hud_help_text"; }
	//virtual	const char * Get_Help( void )	{ return "CnC [vehicle<def_name> | powerup<def_name> |char<class>[minigunner|rocket_soldier|grenadier|engineer|flame_thrower|mutant] <rank>[enlisted|officer|special_forces|boss] ] - Purchases a team vehicle, a player powerup or upgrades the player."; }
	virtual	const char * Get_Help( void )	{ return "hud_help_text - Sets the current HUD help text."; }
	virtual	void Activate( const char * input ) {

		WideStringClass wide_string;
		wide_string.Convert_From (input);
		HUDInfo::Set_HUD_Help_Text (wide_string);
		return ;
	}
};


class CnCModeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "cnc"; }
	//virtual	const char * Get_Help( void )	{ return "CnC [vehicle<def_name> | powerup<def_name> |char<class>[minigunner|rocket_soldier|grenadier|engineer|flame_thrower|mutant] <rank>[enlisted|officer|special_forces|boss] ] - Purchases a team vehicle, a player powerup or upgrades the player."; }
	virtual	const char * Get_Help( void )	{ return "CnC - Displays CnC player console (for gods only)."; }
	virtual	void Activate( const char * input ) {

		if (cNetwork::I_Am_God()) {
			PlayerTerminalClass::Get_Instance ()->Display_Default_Terminal_For_Player (COMBAT_STAR);
		} else {
			Print(Get_Help());
		}
	}
};


class DebugEncyRevealConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "reveal_encyclopedia"; }
	virtual	const char * Get_Help( void )	{ return "reveal_encyclopedia - Shows all entries in the encyclopedia."; }
	virtual	void Activate( const char * input ) {

		EncyclopediaMgrClass::Reveal_All_Objects ();
		return ;
	}
};


class DebugShowMoveVectorConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "move_vectors"; }
	virtual	const char * Get_Help( void )	{ return "move_vectors - Toggles the debug move vectors."; }
	virtual	void Activate( const char * input ) {
		bool displayed = PathClass::Are_Move_Vectors_Displayed ();
		displayed = !displayed;
		PathClass::Display_Move_Vectors (displayed);
		if ( displayed ) {
			Print( "Move vectors ON.\n" );
		} else {
			Print( "Move vectors OFF.\n" );
		}

		return ;
	}
};


class MapRevealConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "map_reveal"; }
	virtual	const char * Get_Help( void )	{ return "map_reveal - Removes the cloud from the map."; }
	virtual	void Activate( const char * input ) {
		MapMgrClass::Clear_All_Cloud_Cells ();
		Print( "Map is now visible.\n" );
		return ;
	}
};


class ChangeCharacterClassConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "change_character_class"; }
	virtual	const char * Get_Help( void )	{ return "CHANGE_CHARACTER_CLASS <preset_name> - changes your character to the specified class."; }
	virtual	void Activate( const char * input ) {
		bool success = false;

		DefinitionClass *definition = DefinitionMgrClass::Find_Typed_Definition( input, CLASSID_GAME_OBJECT_DEF_SOLDIER );
		if (definition != NULL) {
			SoldierGameObjDef *soldier_def = reinterpret_cast<SoldierGameObjDef *> (definition);
			COMBAT_STAR->Re_Init( *soldier_def );
			COMBAT_STAR->Post_Re_Init();
			success = true;
		}

		if (success) {
			Print( "Successfully changed character class.\n" );
		} else {
			Print( "Unable to change character class.\n" );
		}
	}
};

class RenderModeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "render_mode"; }
   virtual	const char * Get_Alias( void ) { return "rm"; }
	virtual	const char * Get_Help( void )	{ return "RENDER_MODE [0 fill | 1 lines | 2 points] - set the current render mode."; }
	virtual	void Activate( const char * input ) {
		if (COMBAT_SCENE != NULL) {
			if ((stricmp(input,"points") == 0) || (stricmp(input,"2") == 0)) {
				COMBAT_SCENE->Set_Polygon_Mode(SceneClass::POINT);
				Print("Polygon mode set to POINT\n");
			} else if ((stricmp(input,"lines") == 0) || (stricmp(input,"1") == 0)) {
				COMBAT_SCENE->Set_Polygon_Mode(SceneClass::LINE);
				Print("Polygon mode set to LINE\n");
			} else if ((stricmp(input,"fill") == 0) || (stricmp(input,"0") == 0)) {
				COMBAT_SCENE->Set_Polygon_Mode(SceneClass::FILL);
				Print("Polygon mode set to FILL\n");
			}
		}
	}
};

class RenderModeExtraPassConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "render_mode_extra_pass"; }
   virtual	const char * Get_Alias( void ) { return "rm"; }
	virtual	const char * Get_Help( void )	{ return "RENDER_MODE_EXTRA_PASS [0 disable | 1 lines | 2 zbuffered]"; }
	virtual	void Activate( const char * input ) {
		if (COMBAT_SCENE != NULL) {
			if ((stricmp(input,"disable") == 0) || (stricmp(input,"0") == 0)) {
				COMBAT_SCENE->Set_Extra_Pass_Polygon_Mode(SceneClass::EXTRA_PASS_DISABLE);
				Print("Extra pass polygon mode set to DISABLE\n");
			} else if ((stricmp(input,"lines") == 0) || (stricmp(input,"1") == 0)) {
				COMBAT_SCENE->Set_Extra_Pass_Polygon_Mode(SceneClass::EXTRA_PASS_LINE);
				Print("Extra pass polygon mode set to LINE\n");
			} else if ((stricmp(input,"zbuffered") == 0) || (stricmp(input,"2") == 0)) {
				COMBAT_SCENE->Set_Extra_Pass_Polygon_Mode(SceneClass::EXTRA_PASS_CLEAR_LINE);
				Print("Extra pass polygon mode set to ZBUFFERED\n");
			}
		}
	}
};

class TextureFilterModeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "texture_filter_mode"; }
	virtual	const char * Get_Help( void )	{ return "TEXTURE_FILTER_MODE [none|fast|best] - set texture filter and mipmap modes."; }
	virtual	void Activate( const char * input ) {
		if (stricmp(input,"none") == 0) {
			TextureClass::_Set_Default_Min_Filter(TextureClass::FILTER_TYPE_FAST);
			TextureClass::_Set_Default_Mag_Filter(TextureClass::FILTER_TYPE_FAST);
			TextureClass::_Set_Default_Mip_Filter(TextureClass::FILTER_TYPE_NONE);
			Print("Texture filter mode changed to: none\n");
		}
		else if (stricmp(input,"fast") == 0) {
			TextureClass::_Set_Default_Min_Filter(TextureClass::FILTER_TYPE_FAST);
			TextureClass::_Set_Default_Mag_Filter(TextureClass::FILTER_TYPE_FAST);
			TextureClass::_Set_Default_Mip_Filter(TextureClass::FILTER_TYPE_FAST);
			Print("Texture filter mode changed to: fast\n");
		}
		if (stricmp(input,"best") == 0) {
			TextureClass::_Set_Default_Min_Filter(TextureClass::FILTER_TYPE_BEST);
			TextureClass::_Set_Default_Mag_Filter(TextureClass::FILTER_TYPE_BEST);
			TextureClass::_Set_Default_Mip_Filter(TextureClass::FILTER_TYPE_BEST);
			Print("Texture filter mode changed to: best\n");
		}
		else {
			Print("Valid filter modes are: none|fast|best\n");
		}
	}
};

class EnableTriangleRenderConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "enable_triangle_render"; }
	virtual	const char * Get_Help( void )	{ return "ENABLE_TRIANGLE_RENDER [none|opaque|sorting|all] - enable/disable triangle rendering."; }
	virtual	void Activate( const char * input ) {
		if (stricmp(input,"none") == 0) {
			DX8Wrapper::_Enable_Triangle_Draw(false);
			SortingRendererClass::_Enable_Triangle_Draw(false);
			Print("All polygon rendering disabled\n");
		}
		else if (stricmp(input,"opaque") == 0) {
			DX8Wrapper::_Enable_Triangle_Draw(true);
			SortingRendererClass::_Enable_Triangle_Draw(false);
			Print("Only opaque polygons enabled\n");
		}
		else if (stricmp(input,"sorting") == 0) {
			DX8Wrapper::_Enable_Triangle_Draw(false);
			SortingRendererClass::_Enable_Triangle_Draw(true);
			Print("Only sorting polygons enabled\n");
		}
		else {
			DX8Wrapper::_Enable_Triangle_Draw(true);
			SortingRendererClass::_Enable_Triangle_Draw(true);
			Print("All polygons enabled\n");
		}
	}
};

class RunFastConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "run_fast"; }
	virtual	const char * Get_Help( void )	{ return "RUN_FAST - set options for fast framerate."; }
	virtual	void Activate( const char * input ) {

		DebugManager::Option_Enable(DebugManager::DEBUG_DISABLE_LIGHTS, true);
		WWASSERT(DebugManager::Option_Is_Enabled(DebugManager::DEBUG_DISABLE_LIGHTS));
		Print("Lights disabled.\n");

      ConsoleFunctionManager::Parse_Input("Dynamic_LOD_Budget 100");

      ConsoleFunctionManager::Parse_Input("Static_LOD_Budget 100");

      ConsoleFunctionManager::Parse_Input("Shadow_Mode 0");

      ConsoleFunctionManager::Parse_Input("Prelit_Mode 0");

      //ConsoleFunctionManager::Parse_Input("Mesh_Draw_Mode 0");

		if (COMBAT_SCENE != NULL) {
			COMBAT_SCENE->Enable_Dynamic_Projectors(false);
			Print("Dynamic Projectors disabled.\n");
			COMBAT_SCENE->Enable_Static_Projectors(false);
			Print("Static Projectors disabled.\n");
		}

		WW3D::Set_Texture_Reduction(1);
		Print("Texture Resolution set to 1.\n");

		ConsoleGameModeClass::Save_Registry_Keys();

		if (Get_Text_Display()) {
			WWASSERT(Get_Text_Display() != NULL);
			Get_Text_Display()->Set_Max_Scroll_Lines(3);
			Print("Set_Max_Scroll_Lines(3)\n");
		}
	}
};

class RenderBackfacesConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "render_backfaces"; }
	virtual	const char * Get_Help( void )	{ return "RENDER_BACKFACES - toggles debug rendering of backfaced polys."; }
	virtual	void Activate( const char * input ) {
		/*
		** This turns on WW3D backface rendering and also causes the Physics-Scene to
		** stop rendering non-occluders so that we can get a better idea of what VIS
		** is seeing when it renders the occluders and checks for backfaces
		*/
		PhysicsSceneClass * scene = PhysicsSceneClass::Get_Instance();
		if (scene) {
			scene->Enable_Backface_Occluder_Debug(!scene->Is_Backface_Occluder_Debug_Enabled());
			if (scene->Is_Backface_Occluder_Debug_Enabled()) {
				Print("Backface Debug Display ENABLED\n");
			} else {
				Print("Backface Debug Display DISABLED\n");
			}
		}
	}
};

class AmmoConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "ammo"; }
	virtual	const char * Get_Help( void )	{ return "AMMO <count> - sets the players weapon's ammo count."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR != NULL ) {
			WeaponClass * weapon = COMBAT_STAR->Get_Weapon();
			if ( weapon ) {
				int amount = atoi( input );
				weapon->Set_Total_Rounds( amount );
				Print( "Ammo set to %d rounds\n", amount );
			}
		}
	}
};

extern	bool		ScriptTrace;
class ScriptTraceConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "script_trace"; }
	virtual	const char * Get_Help( void )	{ return "SCRIPT_TRACE - toggles debug trace of all scipt events and commands."; }
	virtual	void Activate( const char * input ) {
      ScriptTrace = !ScriptTrace;
		Print( "ScriptTrace is %s\n", ScriptTrace ? "ON" : "OFF" );
	}
};


class DebugTypeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "debug_type"; }
   const char * Get_Alias( void ) { return "dt"; }
	virtual	const char * Get_Help( void )	{ return
		"DEBUG_TYPE [type|on|off] - toggles the debug display of type (info, warning, error, script)"; }
	virtual	void Activate( const char * input ) {
		char str[128];
		sprintf(str,"ERROR (%s)\n", input );
		if (stricmp(input,"info") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_INFORMATION );
			sprintf(str, "Information Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_INFORMATION ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"warning") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_WARNING );
			sprintf(str, "Warning Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_WARNING ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"error") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_ERROR );
			sprintf(str, "Error Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_ERROR ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"script") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_SCRIPT );
			sprintf(str, "Script Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_SCRIPT ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"netadmin") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_NETWORK_ADMIN );
			sprintf(str, "Network Admin Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_NETWORK_ADMIN ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"netbasic") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_NETWORK_BASIC );
			sprintf(str, "Network Basic Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_NETWORK_BASIC ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"netprolific") == 0) {
			DebugManager::Toggle_Type_Enabled( DebugManager::DEBUG_TYPE_NETWORK_PROLIFIC );
			sprintf(str, "Network Prolific Debug %s\n", DebugManager::Is_Type_Enabled( DebugManager::DEBUG_TYPE_NETWORK_PROLIFIC ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"net") == 0) {
         DebugManager::Disable_Type( DebugManager::DEBUG_TYPE_NETWORK_ADMIN );
         DebugManager::Disable_Type( DebugManager::DEBUG_TYPE_NETWORK_BASIC );
         DebugManager::Disable_Type( DebugManager::DEBUG_TYPE_NETWORK_PROLIFIC );
			sprintf(str, "All network debug types DISABLED\n");
		} else if (stricmp(input,"on") == 0) {
			DebugManager::Enable_Type( (DebugManager::DebugType)-1 );
			sprintf(str, "All Debug Types Enabled\n" );
		} else if (stricmp(input,"off") == 0) {
			DebugManager::Disable_Type( (DebugManager::DebugType)-1 );
			sprintf(str, "All Debug Types Disabled\n" );
		}
		Print(str);
		Debug_Say((str));
	}
};

/*
class RadarZoomConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "radar_zoom"; }
	virtual	const char * Get_Help( void )	{ return "RADAR_ZOOM <factor> - Set radar zoom factor."; }
	virtual	void Activate( const char * input ) {
		float zoom_factor = atof(input);
		if (zoom_factor > WWMATH_EPSILON) {
//			RadarManager::Set_Zoom_Factor(zoom_factor);
			Print( "Radar zoomed\n" );
		} else {
			Print( "Error - zoom_factor must be small and positive.\n" );
		}
	}
};


class RadarMaxConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "radar_max"; }
	virtual	const char * Get_Help( void )	{ return "RADAR_MAX - zoom out the radar to world extents."; }
	virtual	void Activate( const char * input ) {
		float world_size = The_Game()->Get_Maximum_World_Distance();
		if (world_size > WWMATH_EPSILON) {
//			RadarManager::Set_Zoom_Factor(1 / world_size);
			Print( "Radar zoomed\n" );
		} else {
			Print( "Error - world size not set.\n" );
		}
	}
};
*/

class DefectConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "defect"; }
	virtual	const char * Get_Help( void )	{ return "DEFECT - switch to the opposite team (gods only)."; }
	virtual	void Activate( const char * input ) {

		cPlayer * p_player = cNetwork::Get_My_Player_Object();

		if (p_player != NULL && p_player->Invulnerable.Is_True()) {
			cChangeTeamEvent * p_event = new cChangeTeamEvent;
			p_event->Init();
		} else {
			Print(Get_Help());
		}
	}
};


class RadarToggleConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "radar_toggle"; }
	virtual	const char * Get_Help( void )	{ return "RADAR_TOGGLE - toggles the Radar."; }
	virtual	void Activate( const char * input ) {
		RadarManager::Set_Hidden( !RadarManager::Is_Hidden() );
      Print( "Radar toggled\n" );
	}
};


class ShellCommandConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "shell"; }
	virtual	const char * Get_Help( void )	{ return "SHELL - SHell command (server only)."; }
	virtual	void Activate( const char * input ) {
      if (IS_SOLOPLAY || !cNetwork::I_Am_Server()) {
         Print("SH is for server only.\n");
      } else {
         cNetwork::Shell_Command(input);
      }
	}
};


/*
class RshCommandConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "rsh"; }
	virtual	const char * Get_Help( void )	{ return "RSH - Remote SHell command (server only)."; }
	virtual	void Activate( const char * input ) {
      if (IS_SOLOPLAY || !cNetwork::I_Am_Server()) {
         Print("rsh is for server only.\n");
      } else {
         Print("Sending command to clients...\n");
         cNetwork::Send_Server_Rsh_Command(input);
      }
	}
};
*/


class LrshCommandConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "lrsh"; }
	virtual	const char * Get_Help( void )	{ return "LRSH - Local and Remote SHell command (server only)."; }

	virtual	void Activate( const char * input ) {
      /*
		ConsoleFunctionManager::Parse_Input(input);
      char rsh_command[500];
      WWASSERT(strlen(input) < sizeof(rsh_command) - 10);
      sprintf(rsh_command, "rsh %s", input);
      ConsoleFunctionManager::Parse_Input(rsh_command);
		*/

      if (IS_SOLOPLAY || !cNetwork::I_Am_Server() || ::strlen(input) == 0) {
		   Print(Get_Help());
		} else {
			cConsoleCommandEvent * p_event = new cConsoleCommandEvent;
			p_event->Init(input);
		}
	}
};


class SrshCommandConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "srsh"; }
	virtual	const char * Get_Help( void )	{ return "SRSH - C->S Remote SHell command (client only)."; }

	virtual	void Activate( const char * input ) {

		if (cNetwork::I_Am_Only_Client() && ::strlen(input) > 0) {
			cCsConsoleCommandEvent * p_event = new cCsConsoleCommandEvent;
			p_event->Init(input);
		} else {
		   Print(Get_Help());
		}
	}
};


class MainMenuConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "main_menu"; }
	virtual	const char * Get_Alias( void )	{ return "mm"; }
	virtual	const char * Get_Help( void )	{ return "MAIN_MENU - go back to the main menu."; }
	virtual	void Activate( const char * input ) {
		cDevOptions::GoToMainMenu.Set(true);
		cDevOptions::QuickFullExit.Set(true);
	}
};


class MaxFacingPenaltyConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "max_facing_penalty"; }
	virtual	const char * Get_Alias( void ){ return "mfp"; }
	virtual	const char * Get_Help( void )	{ return "MAX_FACING_PENALTY - set the max facing penalty. Server only. Float. Use zero to disable."; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
		if (cNetwork::I_Am_Server()) {
			float f = ::atof(input);
			cUserOptions::MaxFacingPenalty.Set(f);
         Print( "MaxFacingPenalty set to %5.2f.", f);
		} else {
		   Print(Get_Help());
		}
	}
};


class IrrelevancePenaltyConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "irrelevance_penalty"; }
	//virtual	const char * Get_Alias( void ){ return ""; }
	virtual	const char * Get_Help( void )	{ return "IRRELEVANCE_PENALTY - set the irrelevance penalty. Server only. Float. Use zero to disable."; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
		if (cNetwork::I_Am_Server()) {
			float f = ::atof(input);
			cUserOptions::IrrelevancePenalty.Set(f);
         Print( "IrrelevancePenalty set to %5.2f.", f);
		} else {
		   Print(Get_Help());
		}
	}
};


class MissionConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual const char * Get_Name(void) {return "mission";}
	virtual const char * Get_Help(void) {return "MISSION <success/failure> end mission with given status.";}
	virtual void Activate(const char * input) {
		if (!stricmp(input, "success")) {
			CombatManager::Mission_Complete(true);
		} else if (!stricmp(input, "failure")) {
			CombatManager::Mission_Complete(false);
		} else {
		   Print(Get_Help());
		}
	}
};


class MoneyConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual const char * Get_Name(void) {return "money";}
	virtual const char * Get_Help(void) {return "MONEY <amount> - money cheat, for gods only.";}

	virtual void Activate(const char * input) {

		int amount = ::atoi(input);

		if (cNetwork::I_Am_God()) {
			cMoneyEvent * p_money = new cMoneyEvent;
			p_money->Init(amount);
		} else {
		   Print(Get_Help());
		}
	}
};


class ScoreConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual const char * Get_Name(void) {return "score";}
	virtual const char * Get_Help(void) {return "SCORE <increment> - score cheat, for gods only.";}

	virtual void Activate(const char * input) {

		int amount = ::atoi(input);

		if (cNetwork::I_Am_God()) {
			cScoreEvent * p_score = new cScoreEvent;
			p_score->Init(amount);
		} else {
		   Print(Get_Help());
		}
	}
};


class MultiHudConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "multihud"; }
	virtual	const char * Get_Help( void )	{ return "MULTIHUD - toggle the multiplayer HUD."; }
	virtual	void Activate( const char * input ) {
      CombatGameModeClass::Toggle_Multi_Hud();
      Print("MultiHud toggled\n");
	}
};


class SetPacketLossConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_packet_loss"; }
	virtual	const char * Get_Alias( void )	{ return "spl"; }
	virtual	const char * Get_Help( void )	{ return "SET_PACKET_LOSS <percentage> - simulate packetloss at given percentage"; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      double percentage;
      percentage = atof(input);
      if (percentage > -WWMATH_EPSILON && percentage < 100 + WWMATH_EPSILON) {
         cNetwork::Set_Simulated_Packet_Loss_Pc((int)percentage);
			ConsoleFunctionManager::Parse_Input("clear ns"); // reset stats
      } else {
		   Print(Get_Help());
      }
   }
};


class SetBandwidthBudgetOutToggleConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "toggle_sbbo"; }
	virtual	const char * Get_Help( void )		{ return "TOGGLE_SBBO - toggle cSbboManager (server only)."; }

	virtual	void Activate( const char * input ) {

		if (cNetwork::I_Am_Server()) {
			bool is_enabled = cSbboManager::Toggle_Is_Enabled();
			Print("cSbboManager %s enabled.\n", is_enabled ? "IS" : "is NOT");
		} else {
			Print(Get_Help());
		}
	}
};



class SetSendFrequencyConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "send_frequency"; }
	virtual	const char * Get_Help( void )		{ return "send_freqency <delay> - set delay between packet sends."; }

	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      int delay = atoi(input);
		PacketManager.Set_Flush_Frequency((unsigned long) delay);
		if (delay) {
			Print("Packets will be sent no more than %d times per second.\n", 1000 / delay);
		} else {
			Print("Packets will be sent immediately.\n");
		}
	}
};


class TogglePacketDeltasConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "packet_delta"; }
	virtual	const char * Get_Help( void )		{ return "packet_delta - toggle packet delta enable flag."; }

	virtual	void Activate( const char * ) {
		bool delta = PacketManager.Toggle_Allow_Deltas();

		if (delta) {
			Print("Packets can be sent as deltas.\n");
		} else {
			Print("Packets are not allowed to be sent as deltas.\n");
		}
	}
};



class TogglePacketComboConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "packet_combo"; }
	virtual	const char * Get_Help( void )		{ return "packet_combo - toggle packet packing."; }

	virtual	void Activate( const char * ) {
		bool combos = PacketManager.Toggle_Allow_Combos();

		if (combos) {
			Print("Packets of different sizes can be combined into one packet.\n");
		} else {
			Print("Packets of different sizes cannot be combined into one packet.\n");
		}
	}
};



class TogglePacketOptConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "packet_opt"; }
	virtual	const char * Get_Help( void )		{ return "packet_opt <state> - enable low level packet optimizations."; }

	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      int on = atoi(input);

		if (on) {
			PacketManager.Set_Flush_Frequency(1000 / 15);
			bool ok = PacketManager.Toggle_Allow_Deltas();
			if (!ok) {
				PacketManager.Toggle_Allow_Deltas();
			}
			ok = PacketManager.Toggle_Allow_Combos();
			if (!ok) {
				PacketManager.Toggle_Allow_Combos();
			}
			Print("Low level packet optioizations enabled.\n");
		} else {
			PacketManager.Set_Flush_Frequency(0);
			bool ok = PacketManager.Toggle_Allow_Deltas();
			if (ok) {
				PacketManager.Toggle_Allow_Deltas();
			}
			ok = PacketManager.Toggle_Allow_Combos();
			if (ok) {
				PacketManager.Toggle_Allow_Combos();
			}
			Print("Low level packet optioizations disabled.\n");
		}
	}
};



class SetLatencyConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "latency"; }
	virtual	const char * Get_Help( void )		{ return "latency <low,high> - set simulated latency on packets."; }

	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
		int low,high,current;
		int fields = sscanf(input, "%d,%d", &low, &high);
		if (fields == 1) {
			high = low;
			fields = 2;
		}
		if (fields == 2) {
			cConnection::Set_Latency(low, high);
			Print("Latency set\n");
		}

		cConnection::Get_Latency(low, high, current);
		Print("Latency set to %d,%d (current latency is %d ms)\n", low, high, current);
	}
};



class ToggleBandwidthBalancerConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "bw_balance"; }
	virtual	const char * Get_Help( void )		{ return "bw_balance - toggle bandwidth balancer code enable."; }

	virtual	void Activate( const char * ) {
		if (BandwidthBalancer.IsEnabled == false) {
			BandwidthBalancer.IsEnabled = true;
			Print("Using bandwidth balancer.\n");
		} else {
			BandwidthBalancer.IsEnabled = false;
			Print("Not using bandwidth balancer.\n");
		}
	}
};


class ToggleNewClientUpdateMethodConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "new_update"; }
	virtual	const char * Get_Help( void )		{ return "new_update - toggle new client update method."; }

	virtual	void Activate( const char * ) {
		if (cNetwork::SensibleUpdates == false) {
			cNetwork::SensibleUpdates = true;
			Print("Using new per object per client update scheme.\n");
		} else {
			cNetwork::SensibleUpdates = false;
			Print("Using old funky distance based update scheme.\n");
		}
	}
};



class SetDesiredSleepConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )	{ return "set_desired_sleep"; }
	virtual	const char * Get_Alias( void )	{ return "sds"; }
	virtual	const char * Get_Help( void )	{ return "SET_DESIRED_SLEEP <sleep_ms> - sleep this many ms per frame."; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      int desired_sleep = atoi(input);
		if (desired_sleep >= 0) {
         cNetwork::Set_Desired_Frame_Sleep_Ms(desired_sleep);
         Print( "Frame sleep set to %d ms.", desired_sleep );
		} else {
		   Print(Get_Help());
		}
	}
};

class SetPacketDuplicationConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_packet_duplication"; }
	//virtual	const char * Get_Alias( void )	{ return "spd"; }
	virtual	const char * Get_Help( void )	{ return "SET_PACKET_DUPLICATION <percentage> - simulate packet duplication at given percentage"; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      double percentage = atof(input);
      if (percentage > -WWMATH_EPSILON && percentage < 100 + WWMATH_EPSILON) {
         cNetwork::Set_Simulated_Packet_Duplication_Pc((int)percentage);
			ConsoleFunctionManager::Parse_Input("clear ns"); // reset stats
      } else {
		   Print(Get_Help());
      }
   }
};


class SetPacketLatencyRangeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_packet_latency_range"; }
	virtual	const char * Get_Alias( void )	{ return "latency"; }
	virtual	const char * Get_Help( void )	{ return "SET_PACKET_LATENCY_RANGE <min> <max> - sets a range for simulated latency (in ms)"; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      int min_latency_ms;
      int max_latency_ms;
      int num_args = sscanf(input, "%d %d", &min_latency_ms, &max_latency_ms);

      if (num_args == 2 && min_latency_ms >= 0 && max_latency_ms >= 0 &&
         min_latency_ms <= max_latency_ms) {
         cNetwork::Set_Simulated_Latency_Range_Ms(min_latency_ms, max_latency_ms);
      } else {
		   Print(Get_Help());
      }
	}
};


class SetSpamCountConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_spam_count"; }
	virtual	const char * Get_Alias( void )	{ return "ssc"; }
	virtual	const char * Get_Help( void )	{ return "SET_SPAM_COUNT <count> - S->C state packet is sent this many extra times."; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      int spam_count = atoi(input);
		if (spam_count >= 0) {
         cNetwork::Set_Spam_Count(spam_count);
         //Print( "Spam Count set to %d ms.", desired_sleep );
		} else {
		   Print(Get_Help());
		}
	}
};


class ClearConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "clear"; }
	virtual	const char * Get_Help( void )	{ return "CLEAR <object> - clear specified object."; }
	virtual	void Activate( const char * input ) {

		if (cMiscUtil::Is_String_Same(input, "isc")) {
		   NetworkObjectMgrClass::Reset_Import_State_Counts();
		} else if (cMiscUtil::Is_String_Same(input, "netstats") ||
			cMiscUtil::Is_String_Same(input, "ns")) {
		   if (cNetwork::PClientConnection != NULL) {
			   cNetwork::PClientConnection->Init_Stats();
			   Print("Network stats for client connection reset.\n");
		   }
		   if (cNetwork::PServerConnection != NULL) {
			   cNetwork::PServerConnection->Init_Stats();
			   Print("Network stats for server connection reset.\n");
		   }
      } else if (cMiscUtil::Is_String_Same(input, "packet_simulation") ||
			cMiscUtil::Is_String_Same(input, "ps")) {
         ConsoleFunctionManager::Parse_Input("spl 0");
         ConsoleFunctionManager::Parse_Input("spd 0");
         ConsoleFunctionManager::Parse_Input("latency 0 0");
		} else if (cMiscUtil::Is_String_Same(input, "0")) {
			ConsoleFunctionManager::Parse_Input("clear ht");
			ConsoleFunctionManager::Parse_Input("clear isc");
			ConsoleFunctionManager::Parse_Input("clear ns");
			ConsoleFunctionManager::Parse_Input("clear ps");
		} else if (cMiscUtil::Is_String_Same(input, "")) {

         Print("Valid clear objects:\n");
         Print("     help_text - clears any help text\n");
         Print("     isc - reset the import state count of all smart game objects\n");
         Print("     netstats - reinitialize net stats\n");
         Print("     packet_simulation - turns off packet simulation (loss, duplication, latency)\n");

      } else {
			Print("Error: no such clear object.\n");
		}
	}
};


class ClientHintFactorConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "client_hint_factor"; }
	virtual	const char * Get_Alias( void ){ return "chf"; }
	virtual	const char * Get_Help( void )	{ return "CLIENT_HINT_FACTOR - set the client hint factor (worst:average). Client only. Float. Use zero to disable."; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
		if (cNetwork::I_Am_Only_Client()) {
			float chf = ::atof(input);
			cUserOptions::ClientHintFactor.Set(chf);
         Print( "ClientHintFactor set to %5.2f.", chf);
		} else {
		   Print(Get_Help());
		}
	}
};


class CreateBotConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "create_bot"; }
	virtual	const char * Get_Alias( void )	{ return "cb"; }
	virtual	const char * Get_Help( void )	{ return "CREATE_BOT <number> - create specified number of bots (max 20, server only)."; }
	virtual	void Activate( const char * input ) {
      if (cNetwork::I_Am_Server()) {
			int num_bots = 1;
			if (strcmp(input, "")) {
				num_bots = atoi(input);
			}
			if (num_bots < 0) {
				num_bots = 0;
			}
			if (num_bots > 20) {
				num_bots = 20;
			}
			for (int i = 0; i < num_bots; i++) {
				WWASSERT(PTheGameData != NULL);
				if (cPlayerManager::Count() < The_Game()->Get_Max_Players()) {
					cGod::Create_Ai_Player();
				}
			}
		} else {
		   Print(Get_Help());
		}
	}
};


class CreateGruntConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "create_grunt"; }
	virtual	const char * Get_Alias( void )	{ return "cg"; }
	virtual	const char * Get_Help( void )	{ return "CREATE_GRUNT <number> - create specified number of grunts (server only, max 20)."; }
	virtual	void Activate( const char * input ) {
      if ( cNetwork::I_Am_Server()) {
			int num_grunts = 1;
			if (strcmp(input, "")) {
				num_grunts = atoi(input);
			}
			if (num_grunts < 0) {
				num_grunts = 0;
			}
			if (num_grunts > 20) {
				num_grunts = 20;
			}

			if (COMBAT_STAR != NULL) {
				Vector3 star_pos;
				COMBAT_STAR->Get_Position(&star_pos);
				Vector3 star_target_pos = COMBAT_STAR->Get_Targeting_Pos();
				//star_pos.Z = 0;
				//star_target_pos.Z = 0;
				star_target_pos.Z = star_pos.Z;
				Vector3 look_vector = star_target_pos - star_pos;
				look_vector.Normalize();
				Vector3 pos = star_pos + 20 * look_vector;
				pos.Z += 0.5;

				for (int i = 0; i < num_grunts; i++) {
					cGod::Create_Grunt(pos);
				}
			}

		} else {
		   Print(Get_Help());
		}
	}
};


class CreateObjectConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "create_object"; }
	virtual	const char * Get_Alias( void )	{ return "co"; }
	virtual	const char * Get_Help( void )	{ return "CREATE_OBJECT <name> - create the named object (server only). Use with caution."; }
	virtual	void Activate( const char * input ) {
      if (COMBAT_STAR && cNetwork::I_Am_Server()) {
         PhysicalGameObj * obj = ObjectLibraryManager::Create_Object(input);
			//if (obj != NULL && obj->As_SmartGameObj() != NULL) {
	      if (obj != NULL) {
            Vector3 position;
            COMBAT_STAR->Get_Position(&position);
	         position.X += 4;
	         //position.Z += 4;
		      Matrix3D tm(1);
		      tm.Set_Translation(position);
		      obj->Set_Transform(tm);
				obj->Start_Observers();
			} else {
		      Print("Failed to create %s.", input);
         }
		} else {
		   Print(Get_Help());
		}
	}
};


class ListConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "list"; }
	//virtual	const char * Get_Alias( void )	{ return "l"; }
	virtual	const char * Get_Help( void )	{ return "LIST <object> - show list of specified object."; }
	virtual	void Activate( const char * input ) {

		if (cMiscUtil::Is_String_Same(input, "active_game_modes") ||
			cMiscUtil::Is_String_Same(input, "agm")) {
		   GameModeManager::List_Active_Game_Modes();
		} else if (cMiscUtil::Is_String_Same(input, "definitions") ||
			cMiscUtil::Is_String_Same(input, "d")) {
		   DefinitionMgrClass::List_Available_Definitions(CLASSID_GAME_OBJECTS);
      } else if (cMiscUtil::Is_String_Same(input, "")) {

         Print("Valid list objects:\n");
         Print("     active_game_modes - list all active game modes\n");
         Print("     definitions - list all definition names\n");

      } else {
			Print("Error: no such list object.\n");
		}
	}
};


class BreakExecutionConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "break"; }
	virtual	const char * Get_Help( void )	{ return "BREAK - break execution. Do not use this just for fun."; }
	virtual	void Activate( const char * input ) {
		Print("Breaking execution on demand.\n");
		_asm int 0x03;
	}
};


class CrashExecutionConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "crash"; }
	virtual	const char * Get_Help( void )	{ return "CRASH - crash execution. Do not use this just for fun."; }
	virtual	void Activate( const char * input ) {
		Print("Bang....\n");
		char *zero = NULL;
		*zero = 0;
	}
};


class GiveWeaponsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "give_weapons"; }
	virtual	const char * Get_Help( void )	{ return "GIVE_WEAPONS - give the commando all the weapons (single-player only)"; }
	virtual	void Activate( const char * input ) {

      if (cNetwork::I_Am_Server()) {
			if (IS_SOLOPLAY && COMBAT_STAR ) {
				COMBAT_STAR->Give_All_Weapons();
			} else {
				Print("Use FREE_WEAPONS instead in a multiplayer game.\n");
			}
		} else {
		   Print(Get_Help());
		}
	}
};


class GodConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "god"; }
	virtual	const char * Get_Help( void )	{ return "GOD - if you are a true believer, you may toggle your godlike status.\n"; }

	virtual	void Activate( const char * input ) {

		StringClass password;
		password.Format("%s", input);

      if (cNetwork::I_Am_Client() &&
			(!password.Is_Empty() || cDevOptions::IBelieveInGod.Is_True())) {

			cGodModeEvent * p_event = new cGodModeEvent;
			p_event->Init(password);

		} else {

		   Print(Get_Help());
		}
	}
};


class IBelieveInGodConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "ibelieveingod"; }
	virtual	const char * Get_Help( void )	{ return "IBELIEVEINGOD - toggle philosophical standpoint on this issue.\n"; }

	virtual	void Activate( const char * input ) {

		bool believe = cDevOptions::IBelieveInGod.Toggle();

		if (believe) {
			Print("You believe in god !\n");
		} else {
			Print("You do NOT believe in god !\n");

			if (cNetwork::I_Am_Server()) {
				//
				// Reduce any gods to mere mortals
				//
				for (
					SLNode<cPlayer> * player_node = cPlayerManager::Get_Player_Object_List()->Head();
					player_node;
					player_node = player_node->Next()) {

					cPlayer * p_player = player_node->Data();
					WWASSERT(p_player != NULL);

					if (p_player->Invulnerable.Is_True()) {
						p_player->Invulnerable.Set(false);
						p_player->Mark_As_Modified();
					}
				}
			}
		}
	}
};


class HideStarConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "hide_star"; }
	virtual	const char * Get_Help( void )	{ return "HIDE_STAR - toggles display of the commando."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR ) {
			RenderObjClass	 *ro = COMBAT_STAR->Peek_Model();
			ro->Set_Hidden( !ro->Is_Hidden() );
		}
	}
};

class FlyStarConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "fly_star"; }
	virtual	const char * Get_Help( void )	{ return "FLY_STAR - toggles fly mode for the commando."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR != NULL && (IS_SOLOPLAY || cNetwork::I_Am_God() )) {
			COMBAT_STAR->Toggle_Fly_Mode();
		}
	}
};

class WatchConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "watch"; }
	//virtual	const char * Get_Alias( void )	{ return "w"; }
	virtual	const char * Get_Help( void )	{ return "WATCH <object> - show debug output of specified type."; }
   static   void         Get_Verbose_Help(char * buffer, int bufsize) {
      WWASSERT(buffer != NULL);
      WWASSERT(bufsize >= 1000);

      buffer[0] = 0;
      strcat(buffer, "\n");
      strcat(buffer, "Valid watch objects:\n");
      strcat(buffer, "     bandwidth               (bw)\n");
      strcat(buffer, "     bandwidth_budget_out    (bbo)\n");
//strcat(buffer, "     bounty                  \n");
      strcat(buffer, "     building_data           (bd)\n");
      strcat(buffer, "     client_fps					(client_fps)\n");
      strcat(buffer, "     client_rhost_data       (crd)\n");
      strcat(buffer, "     diagnostics             (diag)\n");
      strcat(buffer, "     door_data               (dd)\n");
      strcat(buffer, "     DSAPO_data              (DSAPO_data)\n");
      strcat(buffer, "     elevator_data           (ed)\n");
      strcat(buffer, "     fps                     (fps)\n");
      strcat(buffer, "     god                     (god)\n");
      strcat(buffer, "     import_states_count     (isc)\n");
      strcat(buffer, "     ids                     (ids)\n");
      strcat(buffer, "     ip_addresses            (ip)\n");
      strcat(buffer, "     last_contact            (lc)\n");
      strcat(buffer, "     latency                 (lat)\n");
      strcat(buffer, "     list_size               (ls)\n");
      strcat(buffer, "     list_packet_size        (lps)\n");
      strcat(buffer, "     list_time               (lt)\n");
//strcat(buffer, "     menu_stack              (ms)\n");
      strcat(buffer, "     money							(money)\n");
      strcat(buffer, "     names                   (names)\n");
      strcat(buffer, "     object_tally            (ot)\n");
      strcat(buffer, "     packets                 (p)\n");
      strcat(buffer, "     ping							(ping)\n");
      strcat(buffer, "     powerup_data				(pd)\n");
      strcat(buffer, "     priorities              (pri)\n");
      strcat(buffer, "     server_rhost_data       (srd)\n");
      strcat(buffer, "     soldier_data            (sd)\n");
      strcat(buffer, "     spawner_data            (spawn)\n");
      strcat(buffer, "     vehicle_data            (vd)\n");
      strcat(buffer, "     wol							(wol)\n");
      strcat(buffer, "     wol_location            (wl)\n");

      strcat(buffer, "     PacketsSentServer						(pss)\n");
      strcat(buffer, "     PacketsSentClient						(psc)\n");
      strcat(buffer, "     PacketsRecdServer						(prs)\n");
      strcat(buffer, "     PacketsRecdClient						(prc)\n");
      strcat(buffer, "     AvgSizePacketsSentServer			(aspss)\n");
      strcat(buffer, "     AvgSizePacketsSentClient			(aspsc)\n");
      strcat(buffer, "     AvgSizePacketsRecdServer			(asprs)\n");
      strcat(buffer, "     AvgSizePacketsRecdClient			(asprc)\n");
      strcat(buffer, "     BytesSentServer						(bss)\n");
      strcat(buffer, "     BytesSentClient						(bsc)\n");
      strcat(buffer, "     BytesRecdServer						(brs)\n");
      strcat(buffer, "     BytesRecdClient						(brc)\n");

      strcat(buffer, "     WwnetPacketsSentServer				(wpss)\n");
      strcat(buffer, "     WwnetPacketsSentClient				(wpsc)\n");
      strcat(buffer, "     WwnetPacketsRecdServer				(wprs)\n");
      strcat(buffer, "     WwnetPacketsRecdClient				(wprc)\n");
      strcat(buffer, "     WwnetAvgSizePacketsSentServer		(waspss)\n");
      strcat(buffer, "     WwnetAvgSizePacketsSentClient		(waspsc)\n");
      strcat(buffer, "     WwnetAvgSizePacketsRecdServer		(wasprs)\n");
      strcat(buffer, "     WwnetAvgSizePacketsRecdClient		(wasprc)\n");
      strcat(buffer, "     WwnetBytesSentServer					(wbss)\n");
      strcat(buffer, "     WwnetBytesSentClient					(wbsc)\n");
      strcat(buffer, "     WwnetBytesRecdServer					(wbrs)\n");
      strcat(buffer, "     WwnetBytesRecdClient					(wbrc)\n");

   }
	virtual	void Activate( const char * input ) {

		if (cMiscUtil::Is_String_Same(input, "bandwidth") ||
			cMiscUtil::Is_String_Same(input, "bw")) {
			cDevOptions::ShowBandwidth.Toggle();
      //} else if (cMiscUtil::Is_String_Same(input, "bandwidth_budget_out") ||
		//	cMiscUtil::Is_String_Same(input, "bbo")) {
		//	cDevOptions::ShowBandwidthBudgetOut.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "client_fps")) {
			cDevOptions::ShowClientFps.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "client_rhost_data") ||
			cMiscUtil::Is_String_Same(input, "crd")) {
			cDevOptions::ShowClientRhostData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "diagnostics") ||
			cMiscUtil::Is_String_Same(input, "diag")) {
			cDevOptions::ShowDiagnostics.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "gs_auth")) {
			cDevOptions::ShowGameSpyAuthState.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "ids")) {
			cDevOptions::ShowId.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "money")) {
			cDevOptions::ShowMoney.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "ping")) {
			cDevOptions::ShowPing.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "ip_addresses") ||
			cMiscUtil::Is_String_Same(input, "ip")) {
			cDevOptions::ShowIpAddresses.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "fps")) {
			cDevOptions::ShowFps.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "god")) {
			cDevOptions::ShowGodStatus.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "import_states_count") ||
			cMiscUtil::Is_String_Same(input, "isc")) {
			bool is_shown = cDevOptions::ShowImportStates.Toggle();
			if (is_shown) {
				Print("You may use RESET_ISC to reset the counts.\n");
			}
      } else if (cMiscUtil::Is_String_Same(input, "import_states_count_soldiers_vehicles") ||
			cMiscUtil::Is_String_Same(input, "iscsv")) {
			bool is_shown = cDevOptions::ShowImportStatesSV.Toggle();
			if (is_shown) {
				Print("You may use RESET_ISC to reset the counts.\n");
			}
		} else if (cMiscUtil::Is_String_Same(input, "latency") ||
			cMiscUtil::Is_String_Same(input, "lat")) {
			ConsoleFunctionManager::Parse_Input("clear ns"); // reset stats
			cDevOptions::ShowLatency.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "last_contact") ||
			cMiscUtil::Is_String_Same(input, "lc")) {
			//ConsoleFunctionManager::Parse_Input("clear ns"); // reset stats
			cDevOptions::ShowLastContact.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "list_size") ||
			cMiscUtil::Is_String_Same(input, "ls")) {
			cDevOptions::ShowListSizes.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "list_packet_size") ||
			cMiscUtil::Is_String_Same(input, "lps")) {
			cDevOptions::ShowListPacketSizes.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "list_time") ||
			cMiscUtil::Is_String_Same(input, "lt")) {
			cDevOptions::ShowListTimes.Toggle();
		/*
		} else if (cMiscUtil::Is_String_Same(input, "menu_stack") ||
			cMiscUtil::Is_String_Same(input, "ms")) {
			cDevOptions::ShowMenuStack.Toggle();
		*/
		} else if (cMiscUtil::Is_String_Same(input, "names")) {
         if (IS_MISSION) {
            Print("Name showing is for multiplayer only.\n");
         } else {
            bool on = cUserOptions::ShowNamesOnSoldier.Toggle();
            if (on) {
               Print("Name showing is now ON\n");
            } else {
               Print("Name showing is now OFF\n");
            }
         }
		} else if (cMiscUtil::Is_String_Same(input, "object_tally") ||
			cMiscUtil::Is_String_Same(input, "ot")) {
			cDevOptions::ShowObjectTally.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "inactive")) {
			cDevOptions::ShowInactivePlayers.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "PacketsSentServer")			|| cMiscUtil::Is_String_Same(input, "pss")) {
			cDevOptions::PacketsSentServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "PacketsSentClient")			|| cMiscUtil::Is_String_Same(input, "psc")) {
			cDevOptions::PacketsSentClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "PacketsRecdServer")			|| cMiscUtil::Is_String_Same(input, "prs")) {
			cDevOptions::PacketsRecdServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "PacketsRecdClient")			|| cMiscUtil::Is_String_Same(input, "prc")) {
			cDevOptions::PacketsRecdClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "AvgSizePacketsSentServer")	|| cMiscUtil::Is_String_Same(input, "aspss")) {
			cDevOptions::AvgSizePacketsSentServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "AvgSizePacketsSentClient") || cMiscUtil::Is_String_Same(input, "aspsc")) {
			cDevOptions::AvgSizePacketsSentClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "AvgSizePacketsRecdServer") || cMiscUtil::Is_String_Same(input, "asprs")) {
			cDevOptions::AvgSizePacketsRecdServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "AvgSizePacketsRecdClient") || cMiscUtil::Is_String_Same(input, "asprc")) {
			cDevOptions::AvgSizePacketsRecdClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "BytesSentServer")				|| cMiscUtil::Is_String_Same(input, "bss")) {
			cDevOptions::BytesSentServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "BytesSentClient")				|| cMiscUtil::Is_String_Same(input, "bsc")) {
			cDevOptions::BytesSentClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "BytesRecdServer")				|| cMiscUtil::Is_String_Same(input, "brs")) {
			cDevOptions::BytesRecdServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "BytesRecdClient")				|| cMiscUtil::Is_String_Same(input, "brc")) {
			cDevOptions::BytesRecdClient.Toggle();

      } else if (cMiscUtil::Is_String_Same(input, "WwnetPacketsSentServer")			|| cMiscUtil::Is_String_Same(input, "wpss")) {
			cDevOptions::WwnetPacketsSentServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetPacketsSentClient")			|| cMiscUtil::Is_String_Same(input, "wpsc")) {
			cDevOptions::WwnetPacketsSentClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetPacketsRecdServer")			|| cMiscUtil::Is_String_Same(input, "wprs")) {
			cDevOptions::WwnetPacketsRecdServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetPacketsRecdClient")			|| cMiscUtil::Is_String_Same(input, "wprc")) {
			cDevOptions::WwnetPacketsRecdClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetAvgSizePacketsSentServer")	|| cMiscUtil::Is_String_Same(input, "waspss")) {
			cDevOptions::WwnetAvgSizePacketsSentServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetAvgSizePacketsSentClient")  || cMiscUtil::Is_String_Same(input, "waspsc")) {
			cDevOptions::WwnetAvgSizePacketsSentClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetAvgSizePacketsRecdServer")  || cMiscUtil::Is_String_Same(input, "wasprs")) {
			cDevOptions::WwnetAvgSizePacketsRecdServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetAvgSizePacketsRecdClient")  || cMiscUtil::Is_String_Same(input, "wasprc")) {
			cDevOptions::WwnetAvgSizePacketsRecdClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetBytesSentServer")				|| cMiscUtil::Is_String_Same(input, "wbss")) {
			cDevOptions::WwnetBytesSentServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetBytesSentClient")				|| cMiscUtil::Is_String_Same(input, "wbsc")) {
			cDevOptions::WwnetBytesSentClient.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetBytesRecdServer")				|| cMiscUtil::Is_String_Same(input, "wbrs")) {
			cDevOptions::WwnetBytesRecdServer.Toggle();
      } else if (cMiscUtil::Is_String_Same(input, "WwnetBytesRecdClient")				|| cMiscUtil::Is_String_Same(input, "wbrc")) {
			cDevOptions::WwnetBytesRecdClient.Toggle();

      } else if (cMiscUtil::Is_String_Same(input, "priorities") ||
			cMiscUtil::Is_String_Same(input, "pri")) {
			cDevOptions::ShowPriorities.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "server_rhost_data") ||
			cMiscUtil::Is_String_Same(input, "srd")) {
			cDevOptions::ShowServerRhostData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "soldier_data") ||
			cMiscUtil::Is_String_Same(input, "sd")) {
			cDevOptions::ShowSoldierData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "spawner_data") ||
			cMiscUtil::Is_String_Same(input, "spawn")) {
			cDevOptions::ShowSpawnerData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "vehicle_data") ||
			cMiscUtil::Is_String_Same(input, "vd")) {
			cDevOptions::ShowVehicleData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "door_data") ||
			cMiscUtil::Is_String_Same(input, "dd")) {
			cDevOptions::ShowDoorData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "elevator_data") ||
			cMiscUtil::Is_String_Same(input, "ed")) {
			cDevOptions::ShowElevatorData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "DSAPO_data") ||
			cMiscUtil::Is_String_Same(input, "DSAPO_data")) {
			cDevOptions::ShowDSAPOData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "building_data") ||
			cMiscUtil::Is_String_Same(input, "bd")) {
			cDevOptions::ShowBuildingData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "powerup_data") ||
			cMiscUtil::Is_String_Same(input, "pd")) {
			cDevOptions::ShowPowerupData.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "wol_location") ||
			cMiscUtil::Is_String_Same(input, "wl")) {
			cDevOptions::ShowWolLocation.Toggle();
		} else if (cMiscUtil::Is_String_Same(input, "0")) {
			//
			// Turn off any watch objects
			//
			cDevOptions::ShowBandwidth.Set(false);
			//cDevOptions::ShowBandwidthBudgetOut.Set(false);
			cDevOptions::ShowDiagnostics.Set(false);
         cDevOptions::ShowFps.Set(false);
         cDevOptions::ShowGodStatus.Set(false);
         //cDevOptions::ShowPacketGraphs.Set(false);
         cDevOptions::ShowPriorities.Set(false);
			cDevOptions::ShowLatency.Set(false);
			cDevOptions::ShowLastContact.Set(false);
			cDevOptions::ShowListSizes.Set(false);
			cDevOptions::ShowListTimes.Set(false);
			cDevOptions::ShowListPacketSizes.Set(false);
			cDevOptions::ShowMenuStack.Set(false);
			cDevOptions::ShowObjectTally.Set(false);
			cDevOptions::ShowInactivePlayers.Set(false);
         cDevOptions::ShowSoldierData.Set(false);
         cDevOptions::ShowSpawnerData.Set(false);
         cDevOptions::ShowVehicleData.Set(false);
         cDevOptions::ShowDoorData.Set(false);
         cDevOptions::ShowElevatorData.Set(false);
         cDevOptions::ShowDSAPOData.Set(false);
         cDevOptions::ShowBuildingData.Set(false);
         cDevOptions::ShowPowerupData.Set(false);
			cDevOptions::ShowImportStates.Set(false);
			cDevOptions::ShowImportStatesSV.Set(false);
			cDevOptions::ShowServerRhostData.Set(false);
			cDevOptions::ShowClientRhostData.Set(false);
			cDevOptions::ShowClientFps.Set(false);
			cDevOptions::ShowWolLocation.Set(false);
			cDevOptions::ShowPing.Set(false);
			cDevOptions::ShowMoney.Set(false);
			cDevOptions::ShowGameSpyAuthState.Set(false);

      } else if (cMiscUtil::Is_String_Same(input, "")) {

			cDevOptions::ShowWolLocation.Toggle();

			if (Get_Text_Display()) {
				if (cDevOptions::ShowWolLocation.Is_True())
				{
					char buffer[10000];
					Get_Verbose_Help(buffer, sizeof(buffer));
					Get_Text_Display()->Set_Verbose_Help_Text(buffer);
				}
				else
				{
					Get_Text_Display()->Set_Verbose_Help_Text("");
				}
			}

      } else {
			Print("Error: no such watch object.\n");
		}
	}
};


class SurfaceEffectsDebugConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "surface_effects_debug"; }
	virtual	const char * Get_Help( void )	{ return "SURFACE_EFFECTS_DEBUG - toggles display of surface effects debug info."; }
	virtual	void Activate( const char * input ) {
		SurfaceEffectsManager::Toggle_Debug();
		Print( "Surface Effects Debug Toggled\n" );
	}
};

class SurfaceTypeOverrideConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "surface_type_override"; }
	virtual	const char * Get_Help( void )	{ return "SURFACE_TYPE_OVERRIDE <int> - all surfaces forced to be given type (-1 disables)."; }
	virtual	void Activate( const char * input ) {
		int type = atoi( input );
		SurfaceEffectsManager::Set_Override_Surface_Type(type);;
		Print( "Override Surface Type Set: %d\n",type );
	}
};

class SurfacePhysicsOverrideConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "surface_physics_override"; }
	virtual	const char * Get_Help( void )	{ return "SURFACE_PHYSICS_OVERRIDE <friction> <drag> - force friction and drag for all surfaces (0.0 disables)."; }
	virtual	void Activate( const char * input ) {
		float friction,drag;
		if (sscanf(input, "%f %f", &friction, &drag) == 2) {
			PhysicsConstants::Set_Override_Surface_Friction(friction);
			PhysicsConstants::Set_Override_Surface_Drag(drag);
			Print( "Friction set to: %f  Drag set to: %f\n",friction,drag );
		} 	else if (sscanf(input, "%f", &friction) == 1) {
			PhysicsConstants::Set_Override_Surface_Friction(friction);
			Print( "Friction set to: %f \n",friction);
		}
	}
};


class SwapTeamsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "swap_teams"; }
	virtual	const char * Get_Help( void )	{ return "SWAP_TEAMS - switch everyone to the opposite team (server only)."; }
	virtual	void Activate( const char * input ) {
		if (cNetwork::I_Am_Server()) {
			//if (The_Game() != NULL && The_Game()->Is_Team_Game()) {
			if (The_Game() != NULL) {
				for (
					SLNode<cPlayer> * player_node = cPlayerManager::Get_Player_Object_List()->Head();
					player_node;
					player_node = player_node->Next()) {

					cPlayer * p_player = player_node->Data();
					WWASSERT(p_player != NULL);

					int team = p_player->Get_Player_Type();

					WWASSERT(team == PLAYERTYPE_NOD || team == PLAYERTYPE_GDI);

					int new_team = PLAYERTYPE_NOD;
					if (team == PLAYERTYPE_NOD)
					{
						new_team = PLAYERTYPE_GDI;
					}
					else
					{
						new_team = PLAYERTYPE_NOD;
					}

					p_player->Set_Player_Type(new_team);

					SoldierGameObj * p_soldier = GameObjManager::Find_Soldier_Of_Client_ID(p_player->Get_Id());
					if (p_soldier != NULL)
					{
						p_soldier->Set_Delete_Pending();
					}
				}
			}
		} else {
			Print(Get_Help());
		}
	}
};


/*
**
*/
class SetStarHealthConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_star_health"; }
	virtual	const char * Get_Alias( void ){ return "ssh"; }
	virtual	const char * Get_Help( void )	{ return "SET_STAR_HEALTH <strength> - sets the strength of the star."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR ) {
			float health = atof( input );
			DefenseObjectClass * defense = COMBAT_STAR->Get_Defense_Object();
			WWASSERT(defense != NULL);
			if (health > defense->Get_Health_Max()) {
				defense->Set_Health_Max( health );
			}
			defense->Set_Health( health );
			Print( "Star Health set to %1.1f\n", defense->Get_Health() );
		}
	}
};

class SetStarSkinConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_star_skin"; }
	virtual	const char * Get_Help( void )	{ return "SET_STAR_SKIN <type> - sets the type of the star's skin."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR ) {
			DefenseObjectClass * defense = COMBAT_STAR->Get_Defense_Object();
			defense->Set_Skin( ArmorWarheadManager::Get_Armor_Type( input ) );
			Print( "Star Skin set to %s\n", ArmorWarheadManager::Get_Armor_Name( defense->Get_Skin() ) );
		}
	}
};

class SetStarShieldStrengthConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_star_shield_strength"; }
	virtual	const char * Get_Help( void )	{ return "SET_STAR_SHIELD_STRENGTH <strength> - sets the strength of the star's shield."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR ) {
			DefenseObjectClass * defense = COMBAT_STAR->Get_Defense_Object();
			defense->Set_Shield_Strength( atof( input ) );
			Print( "Star Shield Strength set to %1.1f\n", defense->Get_Shield_Strength() );
		}
	}
};

class SetStarShieldTypeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "set_star_shield_type"; }
	virtual	const char * Get_Help( void )	{ return "SET_STAR_SHIELD_TYPE <type> - sets the type of the star's shield."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR ) {
			DefenseObjectClass * defense = COMBAT_STAR->Get_Defense_Object();
			defense->Set_Shield_Type( ArmorWarheadManager::Get_Armor_Type( input ) );
			Print( "Star Sheild_Type set to %s\n", ArmorWarheadManager::Get_Armor_Name( defense->Get_Shield_Type() ) );
		}
	}
};


class BuByeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "bubye"; }
	virtual	const char * Get_Help( void )	{ return "BUBYE <mindist> - kills everything but the star if they are at least mindist away."; }
	virtual	void Activate( const char * input ) {
		Vector3	star_pos(0,0,0);
		if ( COMBAT_STAR ) {
			COMBAT_STAR->Get_Position( &star_pos );
		}
		float min_dist = atof( input );

		int count = 0;
		SLNode<SmartGameObj> *objnode;
		for (	objnode = GameObjManager::Get_Smart_Game_Obj_List()->Head(); objnode; objnode = objnode->Next() ) {
			if ( objnode->Data() != (SmartGameObj*)COMBAT_STAR ) {
				Vector3 obj_pos;
				objnode->Data()->Get_Position( &obj_pos );
				obj_pos -= star_pos;
				if ( obj_pos.Length() > min_dist ) {
					objnode->Data()->Set_Delete_Pending();
					count++;
				}
			}
		}
		Print( "%d others say \"Bye Now!\"\n", count );

	}
};


class KillConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual LPCSTR Get_Name(void)	{return "kill";}
	virtual LPCSTR Get_Help(void)	{return "KILL <object types> <percent=n> <id=xxxxx> - kills % of types (vehicles,soldiers,powerups,c4s,armeds,smarts,all). Server only";}
	virtual void Activate(LPCSTR input) {

		/*
		if (!cNetwork::I_Am_Server()) {
			Print(Get_Help());
			return;
		}
		*/

		if (strcmp(input, "")) {

			//
			// C & S can both use id=xxxxxx format
			//
			char * p_id = ::strstr(input, "id=");
			if (p_id != NULL) {
				int id = -1;
				::sscanf(p_id, "id=%d", &id);
				if (cNetwork::I_Am_Client()) {
					cRequestKillEvent * p_event = new cRequestKillEvent;
					p_event->Init(id);
				} else {
					NetworkObjectClass *	p_object = NetworkObjectMgrClass::Find_Object(id);
					if (p_object != NULL) {
						p_object->Set_Delete_Pending();
					}
				}
				return;
			} else if (!cNetwork::I_Am_Server()) {
				Print(Get_Help());
				return;
			}

			//
			// Remaining functionality only for server.
			//

			char * p_pc = strstr(input, "percent=");
			int percent = 100;
			if (p_pc != NULL) {
				sscanf(p_pc, "percent=%d", &percent);
				if (percent < 0) {
					percent = 0;
				} else if (percent > 100) {
					percent = 100;
				}
			}

			int count = 0;
			PhysicalGameObj * p_object = NULL;
			for (SLNode<BaseGameObj> * objnode = GameObjManager::Get_Game_Obj_List()->Head(); objnode != NULL; objnode = objnode->Next()) {

				p_object = objnode->Data()->As_PhysicalGameObj();
				if (p_object == NULL) {
					continue;
				}

				if (p_object->As_SmartGameObj() != NULL && p_object == COMBAT_STAR) {
					continue;
				}

				if ((strstr(input, "vehicles")	&& p_object->As_VehicleGameObj()		!= NULL) ||
					 (strstr(input, "soldiers")	&& p_object->As_SoldierGameObj()		!= NULL) ||
//					 (strstr(input, "commandos")	&& p_object->As_CommandoGameObj()	!= NULL) ||
					 (strstr(input, "powerups")	&& p_object->As_PowerUpGameObj()		!= NULL) ||
					 (strstr(input, "c4s")			&& p_object->As_C4GameObj()			!= NULL) ||
					 (strstr(input, "armeds")		&& p_object->As_ArmedGameObj()		!= NULL) ||
					 (strstr(input, "smarts")		&& p_object->As_SmartGameObj()		!= NULL) ||
					 (strstr(input, "all")) ||
					 (strstr(input, "-9"))) {

					if (rand() % 101 <= percent) {
						objnode->Data()->Set_Delete_Pending();
						count++;
					}
				}
			}

			Print("Killed a total of %d objects. Hope you're happy now.\n", count);

		} else {
			Print(Get_Help());
			Print("\n  Object types: vehicles, soldiers, commandos, powerups, c4s, armeds, smarts, all\n");
		}
	}
};


class SkeletonSliderDemoConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "skeleton_slider_demo"; }
	virtual	const char * Get_Help( void )	{ return "SKELETON_SLIDER_DEMO - toggles the Skeleton Slider Demo."; }
	virtual	void Activate( const char * input ) {
		CombatManager::Toggle_Skeleton_Slider_Demo();
		Print( "Skeleton Slider Demo Toggles\n" );
	}
};

class SkeletonStandersConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "skeleton_standers"; }
	virtual	const char * Get_Help( void )	{ return "SKELETON_STANDERS - creates 4 skeleton demos."; }
	virtual	void Activate( const char * input ) {

		char * skel_names[ 4 ] = {
			"human_bt",
			"human_st",
			"human_bw",
			"human_sw",
		};

		for ( int i = 0; i < 4; i++ ) {
			PhysicalGameObjDef * def = (PhysicalGameObjDef *)DefinitionMgrClass::Find_Typed_Definition( "Commando", CLASSID_GAME_OBJECT_DEF_SOLDIER );
			WWASSERT( def );
			PhysicalGameObj * obj = (PhysicalGameObj *)def->Create();
			WWASSERT( obj );
			Matrix3D tm;
			tm.Set_Translation( Vector3( 0, i*1.2f, 0 ) );
			obj->Set_Transform( tm );
			HTreeClass *tree = WW3DAssetManager::Get_Instance()->Get_HTree( skel_names[i] );
			if ( tree ) {
				Animatable3DObjClass * robj = (Animatable3DObjClass *)obj->Peek_Model();
				robj->Set_HTree( tree );
			}
		}

		Print( "Skeleton Standers Created\n" );
	}
};

class GroupControllerTestConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "group_controller_test"; }
	virtual	const char * Get_Help( void )	{ return "GROUP_CONTROLLER_TEST - tests group controller code."; }
	virtual	void Activate( const char * input ) {

#if 0
		GroupControllerClass * group = new TestGroupControllerClass();

		for ( int i = 0; i < 3; i++) {
			SoldierGameObjDef * def = (SoldierGameObjDef *)DefinitionMgrClass::Find_Definition( "Nod Minigunner" );
			WWASSERT( def );
			SoldierGameObj * obj = (SoldierGameObj *)def->Create();
			WWASSERT( obj );
			obj->Set_Control_Owner( SmartGameObj::SERVER_CONTROL_OWNER );
			obj->Set_Player_Type( PLAYERTYPE_NOD );
			Vector3 pos( 3*i, 3*i, 1 );
			obj->Set_Position( pos );

			obj->Add_Observer( group );
//			group->Add_Unit( obj );
		}

		GroupControllerManager::Add_Controller( group );

		Print( "Group Controller Test Started\n" );
#else
		Print( "Group Controller Test BROKEN\n" );
#endif
	}
};


class StarVisibilityConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "star_visibility"; }
	virtual	const char * Get_Help( void )	{ return "STAR_VISIBILITY - toggles the logical visibility of the star."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_STAR ) {
			COMBAT_STAR->Set_Is_Visible( !COMBAT_STAR->Is_Visible() );
			Print( "Star is %svisible.\n", COMBAT_STAR->Is_Visible() ? "" : "in" );
		}
	}
};


/*
class StealthConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "stealth"; }
	virtual	const char * Get_Help( void )	{ return "STEALTH - toggle stealth ability on star (client only)."; }
	virtual	void Activate( const char * input ) {
		//if (COMBAT_STAR != NULL) {
		//	COMBAT_STAR->Toggle_Stealth();
		//	Print("Star %s stealth ability\n", COMBAT_STAR->Is_Stealth_Enabled() ? "has" : "does NOT have");
		//}
      if (cNetwork::I_Am_Client()) {

			cPlayer * p_player = cNetwork::Get_My_Player_Object();

			if (p_player == NULL) {
				Print("Error: you don't have a player object.");
			} else {

				bool i_can_stealth = p_player->StealthEnabled.Toggle();

				Print("You %s stealth ability\n", i_can_stealth ? "have" : "do NOT have");

				if (cNetwork::I_Am_Only_Client())
				{
					cStealthEvent * p_event = new cStealthEvent;
					p_event->Init(p_player->StealthEnabled.Get());
				}
				else
				{
					p_player->Mark_As_Modified();
				}
			}
		} else {
		   Print("Error: you are not a client.");
		}
	}
};
*/


class ProfileConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "profile"; }
	virtual	const char * Get_Help( void )	{ return "PROFILE - send a profile command (on,off,up,<#>)."; }
	virtual	void Activate( const char * input ) {
		Get_Console()->Profile_Command( input );
	}
};


class QuickStatsConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "quick_stats"; }
	virtual	const char * Get_Alias( void ){ return "qs"; }
	virtual	const char * Get_Help( void )	{ return "QUICK_STATS - stats profile + profile on."; }
	virtual	void Activate( const char * input ) {
      ConsoleFunctionManager::Parse_Input("stats profile");
		Get_Console()->Profile_Command( "on" );
		Get_Console()->Profile_Command( "1" );
		Get_Console()->Profile_Command( "reset" );
		if (ConsoleBox.Is_Exclusive()) {
			ConsoleBox.Set_Profile_Mode(true);
		}
	}
};


class ProfileCollectBeginConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "profile_collect_begin"; }
	virtual	const char * Get_Help( void )	{ return "PROFILE_COLLECT_BEGIN"; }
	virtual	void Activate( const char * input ) {
		WWProfileManager::Begin_Collecting();
	}
};

class ProfileCollectEndConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "profile_collect_end"; }
	virtual	const char * Get_Help( void )	{ return "PROFILE_COLLECT_END"; }
	virtual	void Activate( const char * input ) {
		WWProfileManager::End_Collecting("profile_log.txt");
	}
};


class SetTheStarConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "set_the_star"; }
	virtual	const char * Get_Help( void )	{ return "SET_THE_STAR <id> - set the star to a different object."; }
	virtual	void Activate( const char * input ) {
		SmartGameObj * star = GameObjManager::Find_SmartGameObj( atoi( input ) );
		if ( star != NULL && star->As_SoldierGameObj() != NULL ) {
			CombatManager::Set_The_Star( star->As_SoldierGameObj() );
		}
	}
};


class TeleportStarConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "teleport_star"; }
	virtual	const char * Get_Help( void )	{ return "TELEPORT_STAR < x, y, z > - teleport the star."; }
	virtual	void Activate( const char * input ) {
		float x,y,z;
		::sscanf( input, "%f, %f, %f", &x, &y, &z );
		if ( COMBAT_STAR ) {
			COMBAT_STAR->Set_Position( Vector3( x,y,z ) );
			Print( "Teleported Star to %f %f %f\n", x,y,z );
		}
	}
};


class ScaleTimeConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "scale_time"; }
	virtual	const char * Get_Help( void )	{ return "SCALE_TIME < factor > - scale time (SP only)."; }
	virtual	void Activate( const char * input ) {
		if (IS_SOLOPLAY) {
			float scale = atof( input );
			if ( scale <= 0 ) {
				scale = 1;
			}
			TimeManager::Set_Time_Scale( scale );
			Print( "TimeScaling %f\n", scale );
		} else {
			Print(Get_Help());
		}
	}
};

class ParticleToggleConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "particle_toggle"; }
	virtual	const char * Get_Help( void )	{ return "PARTICLE_TOGGLE - toggles particle emission on and off."; }
	virtual	void Activate( const char * input ) {
		ParticleEmitterClass::Disable_All_Emitters(!ParticleEmitterClass::Are_Emitters_Disabled());
		if (ParticleEmitterClass::Are_Emitters_Disabled()) {
			Print("Emitters disabled\n");
		} else {
			Print("Emitters enabled\n");
		}
	}
};

class TargetSteeringToggleConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "target_steering_toggle"; }
	virtual	const char * Get_Help( void )	{ return "TARGET_STEERING_TOGGLE - toggles vehicle targetsteering."; }
	virtual	void Activate( const char * input ) {
		Print( "Target Steering %s\n", VehicleGameObj::Toggle_Target_Steering() ? "ON" : "OFF" );
	}
};

class DazzleReloadConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "dazzle_reload"; }
	virtual	const char * Get_Help( void )	{ return "DAZZLE_RELOAD - reloads the dazzle ini file (DANGEROUS!)."; }
	virtual	void Activate( const char * input ) {

		FileClass * dazzle_ini_file = _TheFileFactory->Get_File("DAZZLE.INI");
		if (dazzle_ini_file) {
			INIClass dazzle_ini(*dazzle_ini_file);
			DazzleRenderObjClass::Init_From_INI(&dazzle_ini);
			_TheFileFactory->Return_File(dazzle_ini_file);
		}
	}
};


/*
**
** Class to print out data safe stats
**
** ST - 7/18/2001 2:06PM
*/
class DataSafeStatsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "safe_stats"; }
	virtual	const char * Get_Help( void )	{ return "SAFE_STATS - Show data safe statistics"; }
	virtual	void Activate( const char * input ) {
		static char dump_buffer[1024];
		GenericDataSafeClass::Dump_Safe_Stats(dump_buffer, 1024);
		Print(dump_buffer);
	}
};





#endif // WWDEBUG, development only commands

class ScreenUVBiasConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "screen_uv_bias"; }
	//virtual	const char * Get_Alias( void )	{ return "sub"; }
	virtual	const char * Get_Help( void )	{ return "SCREEN_UV_BIAS - toggles the half pixel bias in screen text."; }
	virtual	void Activate( const char * input ) {
		WW3D::Set_Screen_UV_Bias( !WW3D::Is_Screen_UV_Biased() );
      Print( "Screen UV Bias Switched\n" );
	}
};


class SetBandwidthBudgetOutConsoleFunctionClass : public ConsoleFunctionClass {
public:
   virtual	const char * Get_Name( void )		{ return "set_bw_budget_out"; }
	virtual	const char * Get_Alias( void )	{ return "sbbo"; }
	virtual	const char * Get_Help( void )		{ return "SET_BW_BUDGET_OUT <bps> - set total bps budget out."; }

	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
      ULONG bbo = (ULONG) ::atol(input);
		if (bbo > 0) {

      	if (cNetwork::I_Am_Server()) {
				cNetwork::PServerConnection->Set_Bandwidth_Budget_Out(bbo);
			}

      	if (cNetwork::I_Am_Client()) {
				cNetwork::PClientConnection->Set_Bandwidth_Budget_Out(bbo);

				//
				// Notify the server
				//
				cClientBboEvent * p_event = new cClientBboEvent;
				p_event->Init(bbo);
			}

			int bw_scale = (bbo * 2) / 10;
			bw_scale = (bw_scale / 1000) * 1000;
			cBandwidthGraph::Set_Scale(bw_scale);

		   if (cNetwork::PClientConnection != NULL) {
			   cNetwork::PClientConnection->Init_Stats();
			   Print("Network stats for client connection reset.\n");
		   }
		   if (cNetwork::PServerConnection != NULL) {
			   cNetwork::PServerConnection->Init_Stats();
			   Print("Network stats for server connection reset.\n");
		   }
			//ConsoleFunctionManager::Parse_Input("clear ns"); // reset stats
		}
	}
};



class GameOverConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "gameover"; }
	virtual	const char * Get_Help( void )	{ return "GAMEOVER - end current game (server only)."; }
	virtual	void Activate( const char * input ) {

		bool print_help = false;
      if (IS_MISSION) {
			//
			// Fail the mission
			//
#ifdef WWDEBUG
	      ConsoleFunctionManager::Parse_Input("mission failure");
#else //WWDEBUG
			print_help = true;
#endif //WWDEBUG
		} else if (!cNetwork::I_Am_Server()) {
			print_help = true;
      } else {
			if (cNetwork::I_Am_Only_Server()) {
         	Print("Terminating game on demand...\n");
         	cGameData::Set_Manual_Restart(true);
			} else {
#ifdef WWDEBUG
         	cGameData::Set_Manual_Restart(true);
#else //WWDEBUG
				print_help = true;
#endif //WWDEBUG
			}
      }
		if (print_help) {
			Print("GAMEOVER is for dedicated server only\n");
		}
	}
};


class ToggleSortingConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_sorting"; }
	virtual	const char * Get_Help( void )	{ return "TOGGLE_SORTING - toggles WW3D sorting."; }
	virtual	void Activate( const char * input ) {
		WW3D::Enable_Sorting(!WW3D::Is_Sorting_Enabled());
      Print( WW3D::Is_Sorting_Enabled() ? "Sorting Enabled\n" : "Sorting Disabled\n" );
	}
};

class ExtrasConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "extras"; }
	virtual	const char * Get_Help( void )	{ return "EXTRAS <key>"; }
	virtual	void Activate( const char * input ) {

#if 0
		//int crc = CRC_String("quantifigon");//not any more, pw changed...

		//WWDEBUG_SAY(("*E* %d\n", CRC_String(input)));

		//bool onoff = (CRC_String(input) == 0xa8452331);

		CNCPurchaseMainMenuClass::Enable_Secrets(false);  // Just to scramble code
		CNCPurchaseMainMenuClass::Enable_Secrets(false);  // Just to scramble code
		bool onoff = (CRC_String(input) == 65729409);
		CNCPurchaseMainMenuClass::Enable_Secrets(onoff);  // Just to scramble code

		if (The_Game()->IsLaddered.Is_True()) {
			onoff = false;
			CNCPurchaseMainMenuClass::Enable_Secrets(onoff);  // Just to scramble code
			Print("Not allowed in laddered games\r\n");
		}

		CNCPurchaseMainMenuClass::Enable_Secrets(onoff);
		if (CNCPurchaseMainMenuClass::Are_Secrets_Enabled()) {
			Print("extras ENABLED!\r\n");
		}
		CNCPurchaseMainMenuClass::Enable_Secrets(onoff);  // Just to scramble code
#else
		// (gth) secrets don't need a password any more...
		if (The_Game()->IsLaddered.Is_True()) {

			CNCPurchaseMainMenuClass::Enable_Secrets(false);
			Print("Not allowed in laddered games\r\n");

		} else {

			CNCPurchaseMainMenuClass::Enable_Secrets(true);
			if (CNCPurchaseMainMenuClass::Are_Secrets_Enabled()) {
				Print("extras ENABLED!\r\n");
			}
		}
#endif
	}
};

class DebugDeviceConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "debug_device"; }
   const char * Get_Alias( void ) { return "dd"; }
	virtual	const char * Get_Help( void )	{ return
		"DEBUG_DEVICE [device|on|off] - toggles the debug device (screen, mono, dbwin32, log, windows)"; }
	virtual	void Activate( const char * input ) {
		char str[128];
		sprintf(str,"ERROR (%s)\n", input );
		if (stricmp(input,"screen") == 0) {
			DebugManager::Toggle_Device_Enabled( DebugManager::DEBUG_DEVICE_SCREEN );
			sprintf(str, "Screen Debug %s\n", DebugManager::Is_Device_Enabled( DebugManager::DEBUG_DEVICE_SCREEN ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"mono") == 0) {
			DebugManager::Toggle_Device_Enabled( DebugManager::DEBUG_DEVICE_MONO );
			sprintf(str, "Mono Debug %s\n", DebugManager::Is_Device_Enabled( DebugManager::DEBUG_DEVICE_MONO ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"dbwin32") == 0) {
			DebugManager::Toggle_Device_Enabled( DebugManager::DEBUG_DEVICE_DBWIN32 );
			sprintf(str, "DBWin32 Debug %s\n", DebugManager::Is_Device_Enabled( DebugManager::DEBUG_DEVICE_DBWIN32 ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"log") == 0) {
			DebugManager::Toggle_Device_Enabled( DebugManager::DEBUG_DEVICE_LOG );
			sprintf(str, "Log File Debug %s\n", DebugManager::Is_Device_Enabled( DebugManager::DEBUG_DEVICE_LOG ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"windows") == 0) {
			DebugManager::Toggle_Device_Enabled( DebugManager::DEBUG_DEVICE_WINDOWS );
			sprintf(str, "Windows Debug %s\n", DebugManager::Is_Device_Enabled( DebugManager::DEBUG_DEVICE_WINDOWS ) ? "Enabled" : "Disabled" );
		} else if (stricmp(input,"on") == 0) {
			DebugManager::Enable_Device( (DebugManager::DebugDevice)-1 );
			sprintf(str, "All Debug Devices Enabled\n" );
		} else if (stricmp(input,"off") == 0) {
			DebugManager::Disable_Device( (DebugManager::DebugDevice)-1 );
			sprintf(str, "All Debug Devices Disabled\n" );
		}
		Print(str);
		Debug_Say((str));
	}
};

class AdminMessageConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "admin_message"; }
   const char * Get_Alias( void ) { return "amsg"; }
	virtual	const char * Get_Help( void )	{ return
		"ADMIN_MESSAGE <message> - sends an admin message to all clients. Host only."; }
	virtual	void Activate( const char * input ) {
		WWASSERT(input != NULL);
		if (cNetwork::I_Am_Server() && ::strlen(input) > 0) {
			WideStringClass widestring;
			widestring.Convert_From(input);
			cScTextObj * p_message = new cScTextObj;
			p_message->Init(widestring, TEXT_MESSAGE_PUBLIC, true, HOST_TEXT_SENDER, -1);
		} else {
			Print(Get_Help());
		}
	}
};




class MessageConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "message"; }
   const char * Get_Alias( void ) { return "msg"; }
	virtual	const char * Get_Help( void )	{ return "MESSAGE <message> - sends a chat message to all clients. Host only."; }
	virtual	void Activate( const char * input ) {
		WWASSERT(input != NULL);
		if (cNetwork::I_Am_Server() && ::strlen(input) > 0) {
			WideStringClass widestring(input, true);
			cScTextObj *event_obj = new cScTextObj;
			event_obj->Init(widestring, TEXT_MESSAGE_PUBLIC, false, HOST_TEXT_SENDER, -1);
		} else {
			Print(Get_Help());
		}
	}
};


#ifndef FREEDEDICATEDSERVER
class FPSConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "fps"; }
   const char * Get_Alias( void ) { return "fps"; }
	virtual	const char * Get_Help( void )	{ return "FPS - toggle FPS display."; }
	virtual	void Activate( const char * ) {
//		if (!cNetwork::I_Am_Server()) {
         cDevOptions::ShowFps.Toggle();
//		}
	}
};
#endif //FREEDEDICATEDSERVER

#if 1
class ClientPhysicsOptimizationConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "client_physics_optimization"; }
	const char * Get_Alias( void ) { return "cpo"; }
	virtual	const char * Get_Help( void )	{ return "CLIENT_PHYSICS_OPTIMIZATION [0|1] - Update only visible physic objects on client."; }
	virtual	void Activate( const char * input) {
		if (!cNetwork::I_Am_Server()) {
			int state = 0;
			int argcount=::sscanf(input, "%d", &state);
			if (argcount==1) {
				state=!!state;
			}
			else {
				state=!COMBAT_SCENE->Get_Update_Only_Visible_Objects();
			}
         COMBAT_SCENE->Set_Update_Only_Visible_Objects(state==1);

			Print( "Client physics optimization %s\n", state ? "ENABLED" : "DISABLED");
		}
	}
};
#endif

class StatsConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "stats"; }
	virtual	const char * Get_Help( void )	{ return "STATS <off|fps|dx8|star|sr_history|sr|gerd|collision|culling|physics|vehicle|ai|wol|profile|memory> - changes stats display."; }
	virtual	void Activate( const char * input ) {
		StatisticsDisplayManager::Set_Display( input );
	}
};

class ResolutionConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "resolution"; }
	virtual	const char * Get_Help( void )	{ return "RESOLUTION [+|-]"; }
	virtual	void Activate( const char * input ) {
		int w,h,bits;
		bool windowed;
		WW3D::Get_Device_Resolution(w,h,bits,windowed);
		const RenderDeviceDescClass& desc=WW3D::Get_Render_Device_Desc();
		const DynamicVectorClass<ResolutionDescClass> & resos=desc.Enumerate_Resolutions();
		for (int i=0;i<resos.Count();++i) {
			if (resos[i].Width==w && resos[i].Height==h && resos[i].BitDepth==bits) {
				break;
			}
		}

		unsigned char sign;
		if (sscanf (input, "%c", &sign) == 1 && (sign=='+' || sign=='-')) {

			if (sign=='+') i++;
			else i--;

			if (i>=resos.Count()) i=0;
			else if (i<0) i=resos.Count()-1;

			WW3DErrorType error=WW3D::Set_Device_Resolution(
				resos[i].Width,
				resos[i].Height,
				resos[i].BitDepth,
				-1,
				true );
			if (error==WW3D_ERROR_OK) {
				RectClass rect;
				rect.Left = 0;
				rect.Top = 0;
				rect.Right = resos[i].Width;
				rect.Bottom = resos[i].Height;

				Render2DClass::Set_Screen_Resolution(rect);
				Print( "Resolution changed to %d * %d, %d bits\n", resos[i].Width,resos[i].Height,resos[i].BitDepth);
			}
			else {
				Print( "Failed to set resolution to %d * %d, %d bits\n", resos[i].Width,resos[i].Height,resos[i].BitDepth);
				error=WW3D::Set_Device_Resolution(
					w,
					h,
					bits,
					-1,
					true );
			}
		}
		else {
			Print("Resolution is %d * %d, %d bits\n",w,h,bits);
		}
	}
};


class ToggleSurfaceEffectsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "toggle_surface_effects"; }
	virtual	const char * Get_Help( void )	{ return "TOGGLE_SURFACE_EFFECTS - toggles surface effects."; }
	virtual	void Activate( const char * input ) {
		SurfaceEffectsManager::Enable_Effects(!SurfaceEffectsManager::Are_Effects_Enabled());
      Print( SurfaceEffectsManager::Are_Effects_Enabled() ? "Surface Effects Enabled\n" : "Surface Effects Disabled\n" );
	}
};


//----------------------------------------------------------------------------
//
// SHIPPING CONSOLE FUNCTIONS ONLY
// THESE MUST BE DEBUGGED!  THEY ARE PRESENT IN RELEASE BUILDS!!!
//
//----------------------------------------------------------------------------

class DisplayFindpathConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "display_findpath"; }
	virtual	const char * Get_Help( void )	{ return "DISPLAY_FINDPATH - Toggles the display of findpath lines."; }
	virtual	void Activate( const char * input ) {
		Toggle_Display_Findpaths();
	}
};


class DonateConsoleFunctionClass : public ConsoleFunctionClass {
	StringClass HelpText;
public:
	virtual const char * Get_Name(void) {return "donate";}
	virtual const char * Get_Help(void) {
		HelpText.Format("DONATE <credits> <teammate> - donate money (minimum %d credits) to teammate.",
			cDonateEvent::Get_Minimum_Acceptable_Donation());
		return HelpText.Peek_Buffer();;
	}

	virtual void Activate(const char * input) {

		int amount = 0;
		char recipient[1000];
		::sscanf(input, "%d %s", &amount, recipient);

		cPlayer * p_me = cNetwork::Get_My_Player_Object();
		cPlayer * p_recipient = cPlayerManager::Find_Player(recipient);

		if (p_me != NULL &&
			 p_recipient != NULL &&
			 amount >= cDonateEvent::Get_Minimum_Acceptable_Donation() &&
			(p_me->Get_Player_Type() == p_recipient->Get_Player_Type()) &&
			 p_me->Get_Money() >= amount) {

			cDonateEvent * p_event = new cDonateEvent;
			p_event->Init(amount, p_recipient->Get_Id());

		} else {
		   Print(Get_Help());
		}
	}
};


class DoStuffConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "do_stuff"; }
	virtual	const char * Get_Help( void )	{ return "DO_STUFF - Execute some task..."; }
	virtual	void Activate( const char * input ) {

		//
		// This command is for executing some test... put whatever code
		// you want here...
		//

		/*
		int recipient_id = atoi(input);

		WideStringClass msg;
		msg.Format(L"Hola amigo!");

		if (cNetwork::I_Am_Client()) {
			cCsTextObj * p_message = new cCsTextObj;
			p_message->Init(msg, TEXT_MESSAGE_PRIVATE, cNetwork::Get_My_Id(), recipient_id);
		} else {
			cScTextObj * p_message = new cScTextObj;
			p_message->Init(msg, TEXT_MESSAGE_PRIVATE, HOST_TEXT_SENDER, recipient_id);
		}
		*/

		//::exit(1);

		//::Sleep(::atoi(input));
/*
#if 0
		if (cNetwork::I_Am_Server()) {
			float x, y, z;
			::sscanf(input, "%f, %f, %f", &x, &y, &z);
			Vector3 position;
			position.Set(Vector3(x, y, z));

			cScExplosionEvent * p_event = new cScExplosionEvent;
			p_event->Init(1, position);
		}
#endif
*/

		cPlayer * p_player = cPlayerManager::Find_Player(input);
		if (p_player != NULL) {
			int id = p_player->Get_Id();
			cNetwork::Server_Kill_Connection(id);
			cNetwork::Cleanup_After_Client(id);
		}
	}
};


//
// REQUIRED for shipping dedicated server.
//
class QuitConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "quit"; }
	virtual	const char * Get_Help( void )	{
		if (!SlaveMaster.Am_I_Slave()) {
			return ("QUIT - End game and quit to desktop (dedicated server only).\n");
		} else {
			return ("QUIT - End game and restart slave server.\nTo exit without restarting use 'QUIT_SLAVE' on master server\n");
		}
	}
	virtual	void Activate( const char * input ) {

		if (!IS_MISSION) {
			if (AutoRestart.Is_Active()) {
				AutoRestart.Set_Restart_Flag(false);
				Set_Exit_On_Exception(true);
         	cGameData::Set_Manual_Exit(true);
			} else {
				if (cNetwork::I_Am_Server()) {
					if (The_Game() && The_Game()->IsDedicated.Is_True()) {

						if (!SlaveMaster.Am_I_Slave()) {
         				Print("Terminating slaves on demand...\n");
							SlaveMaster.Shutdown_Slaves();
						}

         			Print("Terminating game on demand...\n");
						AutoRestart.Set_Restart_Flag(false);
						Set_Exit_On_Exception(true);
         			cGameData::Set_Manual_Exit(true);
					} else {
         			Print("QUIT is for dedicated server only.\n");
					}
				} else {
					/*
					** I_Am_Server may not report true if we just started up and we aren't a server yet.
					*/
					if (ConsoleBox.Is_Exclusive()) {
						AutoRestart.Set_Restart_Flag(false);
						Set_Exit_On_Exception(true);
         			cGameData::Set_Manual_Exit(true);
					} else {
         			Print("QUIT is for dedicated server only.\n");
					}
				}
			}
      }
	}
};




//
// REQUIRED for shipping dedicated server.
//
class QuitSlaveConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "quit_slave"; }
	virtual	const char * Get_Help( void )	{ return "QUIT_SLAVE slavename - Shutdown a slave server (dedicated master server only)."; }
	virtual	void Activate( const char * input ) {

		if (!IS_MISSION) {
			if (cNetwork::I_Am_Server()) {
				if (The_Game() && The_Game()->IsDedicated.Is_True()) {

					if (!SlaveMaster.Am_I_Slave()) {
         			Print("Terminating slave %s on demand...\n", input);
						if (SlaveMaster.Shutdown_Slave((char*)input)) {
         				Print("Slave %s terminated\n", input);
						} else {
         				Print("Slave %s not found\n", input);
						}
						return;
					}
				}
			}
		}
      Print("QUIT_SLAVE is for dedicated master server only.\n");
	}
};





class NetUpdateRateConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "net_update_rate"; }
	virtual	const char * Get_Alias( void ){ return "nur"; }
	virtual	const char * Get_Help( void )	{ return "NET_UPDATE_RATE - set the max. net update think rate (times per second)."; }
	virtual	void Activate( const char * input ) {
      WWASSERT(input != NULL);
		int rate = ::atoi(input);
#ifdef WWDEBUG
		if (rate > 0) {
#else //WWDEBUG
		if (rate >= 5 && rate <= 30) {
#endif //WWDEBUG
			cUserOptions::NetUpdateRate.Set(rate);
         Print( "NetUpdateRate set to %d.", rate);
		} else {
		   Print(Get_Help());
		}
	}
};




class GameInfoConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "game_info"; }
	virtual	const char * Get_Help( void )	{ return "GAME_INFO - Print info about a game in progress to console box"; }
	virtual	void Activate(const char *) {

		bool active = false;

		if (cNetwork::I_Am_Server()) {

			if (The_Game() && The_Game()->IsDedicated.Is_True()) {

				char upstring[256] = "?";
				char timestr[256] = "?";
				FILETIME creation;
				FILETIME exit;
				FILETIME kernel;
				FILETIME user;
				int ok = GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user);
				if (ok) {
					FILETIME local;
					if (FileTimeToLocalFileTime(&creation, &local)) {
						SYSTEMTIME time;
						if (FileTimeToSystemTime(&local, &time)) {
							GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &time, NULL, upstring, 256);
							GetTimeFormat(LOCALE_SYSTEM_DEFAULT, TIME_FORCE24HOURFORMAT, &time, NULL, timestr, 256);
							strcat(upstring, " - ");
							strcat(upstring, timestr);
						}
					}
				}

				GameModeClass* game = GameModeManager::Find("Combat");
				if (game && game->Is_Active()) {
					game = GameModeManager::Find("WOL");
					if (game && game->Is_Active()) {
						ConsoleBox.Print("Westwood Online mode active since %s\n", upstring);
						active = true;
					} else {
						game = GameModeManager::Find("LAN");
						if (game && game->Is_Active()) {
							if (cGameSpyAdmin::Get_Is_Server_Gamespy_Listed()) {
								ConsoleBox.Print("GameSpy mode active since %s\n", upstring);
							} else {
								ConsoleBox.Print("LAN mode active since %s\n", upstring);
							}
							active = true;
						}
					}
				}

				if (active && The_Game()) {

					unsigned long time = The_Game()->Get_Time_Remaining_Seconds();
					unsigned long seconds = time % 60;
					unsigned long minutes = (time / 60) % 60;
					unsigned long hours = (time / (60*60));


					if (The_Game()->Is_Gameplay_Permitted()) {
						ConsoleBox.Print("Gameplay in progress\n");
					} else {
						ConsoleBox.Print("Gameplay Pending\n");
					}

					char buf[256];
					sprintf(buf, "     Map : %s\n", The_Game()->Get_Map_Name().Peek_Buffer());
					ConsoleBox.Print(buf);

					sprintf(buf, "    Time : %d.%02d.%02d\n", hours, minutes, seconds);
					ConsoleBox.Print(buf);

					sprintf(buf, "     Fps : %d\n", cNetwork::Get_Fps());
					ConsoleBox.Print(buf);

					sprintf(buf, "     GDI : %d/%d players      %d points\n",
						cPlayerManager::Tally_Team_Size(PLAYERTYPE_GDI),
						The_Game()->Get_Max_Players(),
						(int)cTeamManager::Find_Team(PLAYERTYPE_GDI)->Get_Score());
					ConsoleBox.Print(buf);

					sprintf(buf, "     NOD : %d/%d players      %d points\n",
						cPlayerManager::Tally_Team_Size(PLAYERTYPE_NOD),
						The_Game()->Get_Max_Players(),
						(int)cTeamManager::Find_Team(PLAYERTYPE_NOD)->Get_Score());
					ConsoleBox.Print(buf);

					ConsoleBox.Print("\n");
				}
			}
		}
	}
};








class PlayerInfoConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "player_info"; }
	virtual	const char * Get_Help( void )	{ return "PLAYER_INFO - Print info about players in the game to the console box"; }
	virtual	void Activate(const char *) {

		if (cNetwork::I_Am_Server() && The_Game() && The_Game()->IsDedicated.Is_True() && cNetwork::PServerConnection != NULL) {

			unsigned long time = TIMEGETTIME();
			unsigned long bw = 0;

			if (cNetwork::PServerConnection->Get_Num_RHosts() == 0) {
				ConsoleBox.Print("No players\n");
			} else {

				ConsoleBox.Print("\rId  Name           Score Side\tPing\tAddress               Kbits/s Time\n\n");

				for (int i=cNetwork::PServerConnection->Get_Min_RHost() ; i <= cNetwork::PServerConnection->Get_Max_RHost() ; i++) {

					cRemoteHost *client = cNetwork::PServerConnection->Get_Remote_Host(i);

					if (client) {
      				cPlayer * playerptr = cPlayerManager::Find_Player(i);

						if (playerptr) {
							WideStringClass name(playerptr->Get_Name(), true);
							StringClass short_name;
							name.Convert_To(short_name);
							int len = name.Get_Length();
							char temp_name[256];
							strcpy(temp_name, short_name.Peek_Buffer());
							strncat(temp_name, "                    ", 14-len);

							unsigned long dur = (time - client->Get_Creation_Time()) / 1000;

							unsigned long seconds = dur % 60;
							unsigned long minutes = (dur / 60) % 60;
							unsigned long hours = (dur / (60*60));

							bw += PacketManager.Get_Compressed_Bandwidth_Out(&client->Get_Address());

							char addr_string[128];
							sockaddr_in *addr = &client->Get_Address();
							sprintf(addr_string, "%d.%d.%d.%d;%d", 	(int)(addr->sin_addr.S_un.S_un_b.s_b1),
																					(int)(addr->sin_addr.S_un.S_un_b.s_b2),
																					(int)(addr->sin_addr.S_un.S_un_b.s_b3),
																					(int)(addr->sin_addr.S_un.S_un_b.s_b4),
																					unsigned int(ntohs(addr->sin_port)));
							int addr_string_len = strlen(addr_string);
							char local_addr_string[128];
							strcpy(local_addr_string, addr_string);
							if (addr_string_len < 21) {
								strncat(local_addr_string, "                         ", 21-addr_string_len);
							}

							Vector3 color = playerptr->Get_Color();
							char buffer[256];
							sprintf(buffer, "%3d %s%- 6d %s\t%d\t%s%- 7d  %03d.%02d.%02d\n", i, temp_name,
																								(int)playerptr->Get_Score(),
																								(playerptr->Get_Player_Type() == PLAYERTYPE_NOD) ? "NOD" : "GDI",
																								(int)client->Get_Average_Internal_Pingtime_Ms(),
																								local_addr_string,
																								(int)(PacketManager.Get_Compressed_Bandwidth_Out(&client->Get_Address()) / 1024),
																								hours, minutes, seconds);

							WideStringClass ws(buffer, true);
							ConsoleBox.Add_Message(&ws, &color, true);
						}
					}
				}
				ConsoleBox.Print("Total current bandwidth usage for players is %d kilobits per second\n", bw / 1024);
			}
   	} else {
			Print("player_info is for dedicated server only\n");
		}
	}
};

class KickConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "kick"; }
	virtual	const char * Get_Help( void )	{ return "KICK [<Nickname>|<Id>] - Kick a user from the game."; }
	bool KickWOLUser(const WideStringClass & user_name) {

		GameModeClass* game = GameModeManager::Find("WOL");

		if (game && game->Is_Active()) {

			if (user_name.Get_Length() > 0) {
				WolGameModeClass* wolgame = reinterpret_cast<WolGameModeClass*>(game);

				if (wolgame->Kick_Player(user_name)) {
					StringClass smallstring(true);
					user_name.Convert_To(smallstring);
					ConsoleBox.Print("%s was kicked\n", smallstring.Peek_Buffer());
					return true;
				}
			}
		}
		return false;
	}
	bool KickWOLUser(int id) {
		cPlayer *player = cPlayerManager::Find_Player(id);
		if (player) {
			return KickWOLUser(player->Get_Name());
		}
		return false;
	}
	bool KickGameSpyUser(int id) {
		if (cGameSpyAdmin::Is_Gamespy_Game()) {
			return GameSpyBanList.Kick_Player(id);
		}
		return false;
	}
	bool KickGameSpyUser(const WideStringClass & user_name) {
		if (cGameSpyAdmin::Is_Gamespy_Game()) {
			cPlayer *player = NULL;

			for (SLNode<cPlayer> *player_node = cPlayerManager::Get_Player_Object_List ()->Head ()
				; player_node != NULL; player_node = player_node->Next ()) {

				player = player_node->Data ();
				WWASSERT (player != NULL);

				if (player->Get_Is_Active().Is_False() || !player->Is_Human()) {
					continue;
				}
				if (stricmp(StringClass(user_name), StringClass(player->Get_Name())) == 0) {
					KickGameSpyUser(player->Get_Id());
					return true;
				}
			}
		}
		return false;
	}
	virtual	void Activate( const char * input ) {

		if (cNetwork::I_Am_Server()) {
			if (!input || !(*input)) return;
			bool kicked = false;
			WideStringClass user_name(input, true);

			kicked = KickWOLUser(user_name);
			if (!kicked) kicked = KickGameSpyUser(user_name);

			if (!kicked) {
				// try to kick by Id number
				// make sure this is a decimal number since atoi returns 0 on error
				// and we don't want to kick player 0 unless they really mean to
				const char *t = input;
				if (!(*t)) t = NULL;
				while (t && *t) {
					if (!isdigit(*t)) t = NULL;
					else t++;
				}
				if (t) {
					kicked = KickWOLUser(atoi(input));
					if (!kicked) kicked = KickGameSpyUser(atoi(input));
				}
			}

			if (!kicked) {
				ConsoleBox.Print("%s not found\n", input);
			}
		}
	}
};

class BanConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "ban"; }
	virtual	const char * Get_Help( void )	{ return "BAN [<Nickname>|<Id>] - Permanently ban a user from this server(GameSpy & WOL mode only)."; }
	virtual	void Activate( const char * input ) {

		GameModeClass* wolgame = GameModeManager::Find("WOL");
		bool is_wol = false;
		if (wolgame && wolgame->Is_Active()) {
			is_wol = true;
		}
		//if (cGameSpyAdmin::Is_Gamespy_Game() && cNetwork::I_Am_Server()) {
		if ((cGameSpyAdmin::Is_Gamespy_Game() || is_wol) && cNetwork::I_Am_Server()) {

			if (!input || !(*input)) return;
			cPlayer *player = NULL;

			for (SLNode<cPlayer> *player_node = cPlayerManager::Get_Player_Object_List ()->Head ()
				; player_node != NULL; player_node = player_node->Next ()) {

				player = player_node->Data ();
				WWASSERT (player != NULL);

				if (player->Get_Is_Active().Is_False() || !player->Is_Human()) {
					continue;
				}
				if (stricmp(StringClass(input), StringClass(player->Get_Name())) == 0) {
					if (is_wol) {
						((WolGameModeClass*)wolgame)->Ban_Player(player->Get_Name(), player->Get_Ip_Address());
					} else {
						if (player->Get_GameSpy_Hash_Id().Is_Empty()) {
							GameSpyBanList.Ban_User(input);
						} else {
							GameSpyBanList.Ban_User(input, player->Get_GameSpy_Hash_Id());
						}
					}
					break;
				}
			}
			if (player_node == NULL) {
				// make sure this is a decimal number since atoi returns 0 on error
				// and we don't want to kick player 0 unless they really mean to
				const char *t = input;
				if (!(*t)) t = NULL;
				while (t && *t) {
					if (!isdigit(*t)) t = NULL;
					else t++;
				}
				if (t) {
					player = cPlayerManager::Find_Player(atoi(input));
					if (player) {
						if (is_wol) {
							((WolGameModeClass*)wolgame)->Ban_Player(player->Get_Name(), player->Get_Ip_Address());
						} else {
							if (player->Get_GameSpy_Hash_Id().Is_Empty() && !player->Get_Name().Is_Empty()) {
								GameSpyBanList.Ban_User(StringClass(player->Get_Name()));
							} else if (!player->Get_GameSpy_Hash_Id().Is_Empty()) {
								GameSpyBanList.Ban_User(StringClass(player->Get_Name()), player->Get_GameSpy_Hash_Id());
							}
						}
					}
				} else {
					ConsoleBox.Print("%s not found\n", input);
				}
			}
		}
	}
};


class AllowConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "allow"; }
	virtual	const char * Get_Help( void )	{ return "ALLOW [<Nickname>|<Id>] - Remove user channel ban from this server (WOL mode only)."; }
	virtual	void Activate( const char * input ) {

		GameModeClass* game = GameModeManager::Find("WOL");

		if (!input || !(*input)) return;

		if (game && game->Is_Active()) {

			WideStringClass wname(input, true);
			
			if (wname.Get_Length() > 0 && wname.Get_Length() <15) {
				RefPtr<WWOnline::Session> wol_session = WWOnline::Session::GetInstance(false);
				if (wol_session.IsValid()) {
					wol_session->BanUser(wname, false);
				}
			}
		}
	}
};


class PageConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "page"; }
	virtual	const char * Get_Help( void )	{ return "PAGE Nickname Message - Page a Westwood Online user."; }
	virtual	void Activate( const char * input ) {

		static unsigned long last_page = 0;

		GameModeClass* wolgame = GameModeManager::Find("WOL");
		bool is_wol = false;
		if (wolgame && wolgame->Is_Active()) {
			is_wol = true;
		}
		
		if (is_wol) {
			RefPtr<WWOnline::Session> wol_session = WWOnline::Session::GetInstance(false);
			if (wol_session.IsValid()) {
				
				unsigned long time = TIMEGETTIME();
				if (time < last_page || time - last_page > 1000) {
					last_page = time;

					char temp[1024];
					strncpy(temp, input, 1023);
					char *name = temp;
					char *message = strchr(temp, ' ');
					if (message) {
						*message++ = 0;

						if (strlen(name) && strlen(message)) {
							WideStringClass wname(name, true);
							WideStringClass wmessage(message, true);
							wol_session->PageUser(wname, wmessage);
						}
					}
				}
			}
		}
	}
};





//
// REQUIRED for shipping dedicated server.
//
class RestartConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "restart"; }
	virtual	const char * Get_Help( void )	{ return "RESTART - Quit to desktop and restart process (dedicated server only)."; }
	virtual	void Activate( const char * input ) {

		if (!IS_MISSION) {
			if (AutoRestart.Is_Active()) {
				AutoRestart.Set_Restart_Flag(true);
				Set_Exit_On_Exception(true);
         	cGameData::Set_Manual_Exit(true);
			} else {
				if (cNetwork::I_Am_Server()) {
					if (The_Game() && The_Game()->IsDedicated.Is_True()) {

						if (SlaveMaster.Am_I_Slave() == false) {
         				Print("Terminating slaves on demand...\n");
							SlaveMaster.Shutdown_Slaves();
						}

         			Print("Restarting game on demand...\n");
						AutoRestart.Set_Restart_Flag(true);
						Set_Exit_On_Exception(true);
         			cGameData::Set_Manual_Exit(true);
					} else {
         			Print("RESTART is for dedicated server only.\n");
					}
				} else {
         		Print("RESTART is for dedicated server only.\n");
				}
			}
      }
	}
};




class LogMeshStatsConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "log_mesh_stats"; }
	virtual	const char * Get_Help( void )	{ return "LOG_MESH_STATS - log stats to debug window or file."; }
	virtual	void Activate( const char * input ) {
		TheDX8MeshRenderer.Request_Log_Statistics();
	}
};

class LogTexturesConsoleFunctionClass : public ConsoleFunctionClass
{
public:
	virtual	const char * Get_Name( void )	{ return "log_textures"; }
	virtual	const char * Get_Help( void )	{ return "LOG_TEXTURES - log texture statistics to debug window or file."; }
	virtual	void Activate( const char * input ) {
		WW3DAssetManager::Get_Instance()->Log_All_Textures();
	}
};

class DeviceInfoConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "device_info"; }
	virtual	const char * Get_Help( void )	{ return "DEVICE_INFO - get device driver info."; }
	virtual	void Activate( const char * input ) {
		const RenderDeviceDescClass &	rddesc = WW3D::Get_Render_Device_Desc();
		Print( "Render Device: %s\n", rddesc.Get_Device_Name() );
		Print( "Graphics Hardware: %s\n",rddesc.Get_Hardware_Name() );
	}
};


//
// TEMP DEBUG CODE
//
class NewTCADOConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "newtcado"; }
	virtual	const char * Get_Help( void )	{ return "newtcado - Toggle new TCADO code"; }
	virtual	void Activate( const char * input ) {
		bool is_new_tcado = cDevOptions::UseNewTCADO.Toggle();
      Print(is_new_tcado ? "Using new TCADO.\n" : "Using old TCADO.\n" );
	}
};


class TimeOfDayConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("time_of_day");}
	virtual	const char * Get_Help (void)	{return ("TIME_OF_DAY <hours [0..23]> <minutes [0..59]> - sets the time of day for the background.");}
	virtual	void Activate (const char *input) {

		if (COMBAT_SCENE != NULL) {

			unsigned hours, minutes;

			if (sscanf (input, "%d %d", &hours, &minutes) == 2) {
				if (BackgroundMgrClass::Set_Time_Of_Day (hours, minutes)) {

					const float theta = (((hours * 60.0f) + minutes) / 1440.0f) * 2.0f * WWMATH_PI;

					BackgroundMgrClass::Set_Light_Source_Type (BackgroundMgrClass::LIGHT_SOURCE_TYPE_SUN);
					COMBAT_SCENE->Set_Sun_Light_Orientation (0.0f, theta + (WWMATH_PI * 1.5f));
					Print ("Time of day changed\n");
				}
			}
		}
	}
};


class CloudsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("clouds");}
	virtual	const char * Get_Help (void)	{return ("CLOUDS <cloudcover [0..1]> <gloominess [0..1]> [ramptime [0+]]");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Clouds changed\n";

		int	argcount;
		float cloudcover, gloominess, ramptime;
		bool	success = false;

		argcount = sscanf (input, "%f %f %f", &cloudcover, &gloominess, &ramptime);
		switch (argcount) {

			case 2:
				success = BackgroundMgrClass::Set_Clouds (cloudcover, gloominess);
				break;

			case 3:
				success = BackgroundMgrClass::Set_Clouds (cloudcover, gloominess, ramptime);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class CopyLogsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("copy_logs");}
	virtual	const char * Get_Help (void)	{return ("COPY_LOGS <on/off> - enable/disable error logging to network.");}
	virtual	void Activate (const char *input) {

		if (!::stricmp(input, "on")) {

			RegistryClass registry(APPLICATION_SUB_KEY_NAME_DEBUG);
			WWASSERT(registry.Is_Valid());
			registry.Set_Int("SystemInfoLogDisable", FALSE);
			registry.Set_Int("DisableLogCopying", FALSE);

			Print("Log copying is ON.");

		} else if (!::stricmp(input, "off")) {

			RegistryClass registry(APPLICATION_SUB_KEY_NAME_DEBUG);
			WWASSERT(registry.Is_Valid());
			registry.Set_Int("SystemInfoLogDisable", TRUE);
			registry.Set_Int("DisableLogCopying", TRUE);

			Print("Log copying is OFF.");

		} else {

			Print(Get_Help());
		}
	}
};


class SkyTintConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("sky_tint");}
	virtual	const char * Get_Help (void)	{return ("SKY_TINT <tintfactor [0..1]> [ramptime [0+]]");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Sky tint changed\n";

		int	argcount;
		float skytintfactor, ramptime;
		bool	success = false;

		argcount = sscanf (input, "%f %f %f", &skytintfactor, &ramptime);
		switch (argcount) {

			case 1:
				success = BackgroundMgrClass::Set_Sky_Tint (skytintfactor);
				break;

			case 2:
				success = BackgroundMgrClass::Set_Sky_Tint (skytintfactor, ramptime);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class InfoDebugToggle : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "info_debug_toggle"; }
	virtual	const char * Get_Help( void )	{ return "INFO_DEBUG_TOGGLE - Toggles display of debug info on object info."; }
	virtual	void Activate( const char * input ) {
		extern bool	InfoDebug;
		InfoDebug = !InfoDebug;
		Print( "Toggled Info Debug\n" );
	}
};

class MeshRenderSnapshotFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "mesh_render_snapshot"; }
	virtual	const char * Get_Help( void )	{ return "MESH_RENDER_SNAPSHOT - Logs one frame of mesh render system."; }
	virtual	void Activate( const char * input ) {
		WW3D::Activate_Snapshot(true);
	}
};

class UmbraToggleFunctionClass : public ConsoleFunctionClass {
public:
	virtual  const char * Get_Name(void) { return "umbra_toggle"; }
	virtual	const char * Get_Help(void) { return "UMBRA_TOGGLE - toggles umbra culling (if compiled into this build)."; }
	virtual  void Activate(const char * input) {
#if (UMBRASUPPORT)
		UmbraSupport::Enable_Umbra(!UmbraSupport::Is_Umbra_Enabled());
		Print("Umbra %s\n",(UmbraSupport::Is_Umbra_Enabled() ? "enabled." : "disabled."));
#else
		Print("Umbra support not compiled into this build.\n");
#endif

	}
};

class UnusedSpawnerFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "unused_spawners"; }
	virtual	const char * Get_Help( void )	{ return "UNUSED_SPAWNERS - Displays the ID of spawns which have spawned nothing."; }
	virtual	void Activate( const char * input ) {
		SpawnManager::Display_Unused_Spawners();
	}
};

class VipConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "vip"; }
	virtual	const char * Get_Help( void )	{ return "VIP <password> - Toggle VIP mode. Client only.\n"; }

	virtual	void Activate( const char * input ) {

		StringClass password;
		password.Format("%s", input);

      if (cNetwork::I_Am_Client()) {// && !password.Is_Empty()) {

			cVipModeEvent * p_event = new cVipModeEvent;
			p_event->Init(password);

		} else {

		   Print(Get_Help());
		}
	}
};

class AllowKillingHibernatingSpawnFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "allow_killing_hibernating_spawn"; }
	virtual	const char * Get_Help( void )	{ return "ALLOW_KILLING_HIBERNATING_SPAWN - Toggles the global ability for spawners to kill hibernating spawn."; }
	virtual	void Activate( const char * input ) {
		if (	SpawnManager::Toggle_Allow_Killing_Hibernating_Spawn() ) {
			Print("Killing Hibernating Spawn Allowed\n");
		} else {
			Print("Killing Hibernating Spawn Disallowed\n");
		}
	}
};

class DisplayHibernatingFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "display_hibernating"; }
	virtual	const char * Get_Help( void )	{ return "DISPLAY_HIBERNATING - Toggles displaying of objects begining and ending hibernation."; }
	virtual	void Activate( const char * input ) {
extern bool	_DisplayHibernating;
		_DisplayHibernating = !_DisplayHibernating;
		Print("Display Hibernating now %s\n", _DisplayHibernating ? "ON" : "OFF" );
	}
};

class HideHUDPointsFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "hide_hud_points"; }
	virtual	const char * Get_Help( void )	{ return "HIDE_HUD_POINTS - Toggles displaying of points on the HUD."; }
	virtual	void Activate( const char * input ) {
		Print("HUD points toggled\n" );
		HUDClass::Toggle_Hide_Points();
	}
};

class SnapShotModeToggleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "snap_shot_mode_toggle"; }
	virtual	const char * Get_Alias( void ){ return "ssm"; }
	virtual	const char * Get_Help( void )	{ return "SNAP_SHOT_MODE_TOGGLE - Toggles Snap Shot Mode."; }
	virtual	void Activate( const char * input ) {
		if ( COMBAT_CAMERA ) {
			COMBAT_CAMERA->Set_Snap_Shot_Mode( !COMBAT_CAMERA->Is_Snap_Shot_Mode() );
			Print( "Snap Shot Mode %s\n", COMBAT_CAMERA->Is_Snap_Shot_Mode() ? "ON" : "OFF" );
		}
	}
};


class LightningConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("lightning");}
	virtual	const char * Get_Help (void)	{return ("LIGHTNING <intensity [0..1]> [<start [0..1]> <end [0..1]> <heading [0..360]> <distribution [0..1]>] [ramptime [0+]] - Sets lightning.");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Lightning changed\n";

		int	argcount;
		float arg0, arg1, arg2, arg3, arg4, arg5;
		bool  success = false;

		argcount = sscanf (input, "%f %f %f %f %f %f", &arg0, &arg1, &arg2, &arg3, &arg4, &arg5);
		switch (argcount) {

			case 1:
				success = BackgroundMgrClass::Set_Lightning_Intensity (arg0);
				break;

			case 5:
				success = BackgroundMgrClass::Set_Lightning (arg0, arg1, arg2, arg3, arg4);
				break;

			case 6:
				success = BackgroundMgrClass::Set_Lightning (arg0, arg1, arg2, arg3, arg4, arg5);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class WarBlitzConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("warblitz");}
	virtual	const char * Get_Help (void)	{return ("WARBLITZ <intensity [0..1]> [<start [0..1]> <end [0..1]> <heading [0..360]> <distribution [0..1]>] [ramptime [0+]] - Sets war blitz.");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "War blitz changed\n";

		int	argcount;
		float arg0, arg1, arg2, arg3, arg4, arg5;
		bool  success = false;

		argcount = sscanf (input, "%f %f %f %f %f %f", &arg0, &arg1, &arg2, &arg3, &arg4, &arg5);
		switch (argcount) {

			case 1:
				success = BackgroundMgrClass::Set_War_Blitz (arg0);
				break;

			case 5:
				success = BackgroundMgrClass::Set_War_Blitz (arg0, arg1, arg2, arg3, arg4);
				break;

			case 6:
				success = BackgroundMgrClass::Set_War_Blitz (arg0, arg1, arg2, arg3, arg4, arg5);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class WarpConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("warp");}
	virtual	const char * Get_Help (void)	{return ("WARP <player name> - warp to first other player or named player (client only).");}
	virtual	void Activate (const char *input) {
      if (cNetwork::I_Am_Client()) {

			WideStringClass player_name;
			player_name.Convert_From(input);

			cWarpEvent * p_warp = new cWarpEvent;
			p_warp->Init(player_name);

		} else {
		   Print(Get_Help());
		}
	}
};


class WhoIsConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("whois");}
	virtual	const char * Get_Help (void)	{return ("WHOIS <player name> - who the heck is this annoying bugger? (server only)\n");}
	virtual	void Activate (const char *input) {
		cPlayer * p_player = cPlayerManager::Find_Player(input);

		if (!cNetwork::I_Am_Server() || p_player == NULL) {
		   Print(Get_Help());
		} else {

			ULONG ip = p_player->Get_Ip_Address();
			HOSTENT * p_host = ::gethostbyaddr((char *) &ip, sizeof(ip), AF_INET);
			char resolved_ip[100] = "";
			if (p_host != NULL) {
				::sprintf(resolved_ip, "(%s)", p_host->h_name);
			}

			Print("%s is at ip %s %s\n",
				input, cNetUtil::Address_To_String(ip), resolved_ip);
		}
	}
};


class WindConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("wind");}
	virtual	const char * Get_Help (void)	{return ("WIND <heading [0..360]> <speed [0+]> <variability [0..1]> [ramptime [0+]] - Sets wind.");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Wind changed\n";

		int	argcount;
		float heading, speed, variability, ramptime;
		bool  success = false;

		argcount = sscanf (input, "%f %f %f %f", &heading, &speed, &variability, &ramptime);
		switch (argcount) {

			case 3:
				success = WeatherMgrClass::Set_Wind (heading, speed, variability);
				break;

			case 4:
				success = WeatherMgrClass::Set_Wind (heading, speed, variability, ramptime);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class RainConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("rain");}
	virtual	const char * Get_Help (void)	{return ("RAIN <density [0+]> [ramptime [0+]] - Sets rain.");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Rain changed\n";

		int	argcount;
		float	arg0, arg1;
		bool	success = false;

		argcount = sscanf (input, "%f %f", &arg0, &arg1);
		switch (argcount) {

			case 1:
				success = WeatherMgrClass::Set_Precipitation (WeatherMgrClass::PRECIPITATION_RAIN, arg0);
				break;

			case 2:
				success = WeatherMgrClass::Set_Precipitation (WeatherMgrClass::PRECIPITATION_RAIN, arg0, arg1);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class SnowConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("snow");}
	virtual	const char * Get_Help (void)	{return ("SNOW <density [0+]> [ramptime [0+]] - Sets snow.");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Snow changed\n";

		int	argcount;
		float	arg0, arg1;
		bool	success = false;

		argcount = sscanf (input, "%f %f", &arg0, &arg1);
		switch (argcount) {

			case 1:
				success = WeatherMgrClass::Set_Precipitation (WeatherMgrClass::PRECIPITATION_SNOW, arg0);
				break;

			case 2:
				success = WeatherMgrClass::Set_Precipitation (WeatherMgrClass::PRECIPITATION_SNOW, arg0, arg1);
				break;

 			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};


class AppPacketTypesResetConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name( void )	{ return "app_packet_types_reset"; }
	virtual	const char * Get_Alias( void ){ return "aptr"; }
	virtual	const char * Get_Help( void )	{ return "APP_PACKET_TYPES_RESET - reset app packet stats."; }
	virtual	void Activate( const char * input ) {
		cAppPacketStats::Reset();
	}
};


class AshConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("ash");}
	virtual	const char * Get_Help (void)	{return ("ASH <density [0+]> [ramptime [0+]] - Sets ash.");}
	virtual	void Activate (const char *input) {

		const char *feedbackstring = "Ash changed\n";

		int	argcount;
		float	arg0, arg1;
	  	bool	success = false;

		argcount = sscanf (input, "%f %f", &arg0, &arg1);
		switch (argcount) {

			case 1:
				success = WeatherMgrClass::Set_Precipitation (WeatherMgrClass::PRECIPITATION_ASH, arg0);
				break;

			case 2:
				success = WeatherMgrClass::Set_Precipitation (WeatherMgrClass::PRECIPITATION_ASH, arg0, arg1);
				break;

			default:
				// Do nothing.
				break;
		}
		if (success) Print (feedbackstring);
	}
};

/*
**
*/
class CinematicFreezeConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("cinematic_freeze");}
	virtual	const char * Get_Help (void)	{return ("CINEMATIC_FREEZE - Toggles Cinematic Freeze.");}
	virtual	void Activate (const char *input) {
		GameObjManager::Toggle_Cinematic_Freeze();
		Print( "Cinematic Freeze %s\n",
			GameObjManager::Is_Cinematic_Freeze_Active() ? "ON" : "OFF" );
	}
};



class EditVehicleConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("edit_vehicle");}
	virtual	const char * Get_Help (void)	{return ("EDIT_VEHICLE - Edit the parameters of the currently driven vehicle.");}
	virtual	void Activate (const char *input)
	{
		// Only do this in single player or 1-player multiplay games
      if (IS_SOLOPLAY || ((PTheGameData != NULL) && (PTheGameData->Get_Max_Players() == 1)) )
		{
			VehicleGameObj * vehicle = COMBAT_STAR->Get_Vehicle();
			if ((vehicle != NULL) && (vehicle->Peek_Vehicle_Phys() != NULL)) {
				VehiclePhysClass * pobj = vehicle->Peek_Vehicle_Phys();

				TrackedVehicleClass * tv = pobj->As_TrackedVehicleClass();
				WheeledVehicleClass * wv = pobj->As_WheeledVehicleClass();

				if (tv != NULL) {

					float wheel_radius = 0.0f;
					for (int i=0; i<tv->Get_Wheel_Count(); i++) {
						WheelClass * wheel = (WheelClass*)tv->Peek_Wheel(i);
						if (wheel->Get_Flag(SuspensionElementClass::ENGINE)) {
							wheel_radius = wheel->Get_Radius();
						}
					}

					TrackedVehicleDefClass * def = (TrackedVehicleDefClass *)tv->Get_TrackedVehicleDef();

					EditTrackedVehicleDialogClass * popup = new EditTrackedVehicleDialogClass(def,wheel_radius);
					popup->Start_Dialog();
					popup->Release_Ref();

				} else if (wv != NULL) {

					float wheel_radius = 0.0f;
					for (int i=0; i<wv->Get_Wheel_Count(); i++) {
						WheelClass * wheel = (WheelClass*)wv->Peek_Wheel(i);
						if (wheel->Get_Flag(SuspensionElementClass::ENGINE)) {
							wheel_radius = wheel->Get_Radius();
						}
					}

					WheeledVehicleDefClass * def = (WheeledVehicleDefClass *)wv->Get_WheeledVehicleDef();
					EditWheeledVehicleDialogClass * popup = new EditWheeledVehicleDialogClass(def,wheel_radius);
					popup->Start_Dialog();
					popup->Release_Ref();

				}
			}
		}
	}
};


/*
**
*/
class ToggleUseLetencyInterpretConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("toggle_latency_interpret");}
	virtual	const char * Get_Help (void)	{return ("TOGGLE_LATENCY_INTERPRET - Toggles Latency Interpret logic.");}
	virtual	void Activate (const char *input) {
		extern	bool	_UseLatencyInterpret;
		_UseLatencyInterpret	= !_UseLatencyInterpret;
		Print( "UseLetencyInterpret %s\n",
			_UseLatencyInterpret ? "ON" : "OFF" );
	}
};

/*
**
*/
class ToggleHitReticleConsoleFunctionClass : public ConsoleFunctionClass {
public:
	virtual	const char * Get_Name (void)	{return ("toggle_hit_reticle");}
	virtual	const char * Get_Help (void)	{return ("TOGGLE_HIT_RETICLE - Toggles the center reticle dot.");}
	virtual	void Activate (const char *input) {
		CombatManager::Toggle_Hit_Reticle_Enabled();
		Print( "Hit Reticle Toggled\n" );
	}
};


//------------------------------------------------------------------------------------
/*
** Console Function Manager
*/
DynamicVectorClass<ConsoleFunctionClass *>	ConsoleFunctionManager::FunctionList;

void	ConsoleFunctionManager::Init( void )
{

#ifdef WWDEBUG
   //
   // DEVELOPMENT CONSOLE FUNCTIONS ONLY
	// ONLY PRESENT IN DEBUG AND PROFILE BUILDS
   //

	FunctionList.Add( new AllowKillingHibernatingSpawnFunctionClass() );
	FunctionList.Add( new AmbientLightConsoleFunctionClass() );
	FunctionList.Add( new AmmoConsoleFunctionClass() );
	FunctionList.Add( new AppPacketTypesResetConsoleFunctionClass() );
	FunctionList.Add( new AshConsoleFunctionClass() );
	FunctionList.Add( new BreakExecutionConsoleFunctionClass() );
	FunctionList.Add( new CrashExecutionConsoleFunctionClass() );
	FunctionList.Add( new BuByeConsoleFunctionClass() );
	FunctionList.Add( new BuildingStateConsoleFunctionClass() );
	FunctionList.Add( new CameraConsoleFunctionClass() );
	FunctionList.Add( new CinematicFreezeConsoleFunctionClass() );
	FunctionList.Add( new ClearConsoleFunctionClass() );
	FunctionList.Add( new ClientHintFactorConsoleFunctionClass() );
	FunctionList.Add( new CloudsConsoleFunctionClass() );
	FunctionList.Add( new CopyLogsConsoleFunctionClass() );
	FunctionList.Add( new SkyTintConsoleFunctionClass() );
	FunctionList.Add( new CreateBotConsoleFunctionClass() );
	FunctionList.Add( new CreateGruntConsoleFunctionClass() );
	FunctionList.Add( new CreateObjectConsoleFunctionClass() );
	FunctionList.Add( new DazzleReloadConsoleFunctionClass() );
	FunctionList.Add( new DebugTypeConsoleFunctionClass() );
	FunctionList.Add( new DefectConsoleFunctionClass() );
	FunctionList.Add( new DisplayFindpathConsoleFunctionClass() );
	FunctionList.Add( new DisplayHibernatingFunctionClass() );
	FunctionList.Add( new DirtyCullDebugConsoleFunctionClass() );
   FunctionList.Add( new DonateConsoleFunctionClass() );
	FunctionList.Add( new DoStuffConsoleFunctionClass() );
	FunctionList.Add( new DSAPOResetConsoleFunctionClass() );
	FunctionList.Add( new EnableTriangleRenderConsoleFunctionClass() );
	FunctionList.Add( new ExposePrelitConsoleFunctionClass() );
	FunctionList.Add( new FlashTextureConsoleFunctionClass() );
	FunctionList.Add( new FlyStarConsoleFunctionClass() );
	FunctionList.Add( new FogRangeConsoleFunctionClass() );
	FunctionList.Add( new FogToggleConsoleFunctionClass() );
	FunctionList.Add( new FrameTexturesConsoleFunctionClass() );
	FunctionList.Add( new FreeWeaponsConsoleFunctionClass() );
	FunctionList.Add( new GiveWeaponsConsoleFunctionClass() );
	FunctionList.Add( new GodConsoleFunctionClass() );
	FunctionList.Add( new IBelieveInGodConsoleFunctionClass() );
	FunctionList.Add( new IrrelevancePenaltyConsoleFunctionClass() );
	FunctionList.Add( new GroupControllerTestConsoleFunctionClass() );
	FunctionList.Add( new HideStarConsoleFunctionClass() );
	FunctionList.Add( new HideHUDPointsFunctionClass() );
	FunctionList.Add( new InvalidateMeshCacheConsoleFunctionClass() );
	FunctionList.Add( new InvalidateTexturesConsoleFunctionClass() );
	FunctionList.Add( new InfoDebugToggle() );
	FunctionList.Add( new HUDConsoleFunctionClass() );
	FunctionList.Add( new KillConsoleFunctionClass() );
	FunctionList.Add( new ListConsoleFunctionClass() );
	FunctionList.Add( new LightModeConsoleFunctionClass() );
	FunctionList.Add( new LightDebugToggleConsoleFunctionClass() );
	FunctionList.Add( new LightCalcConsoleFunctionClass() );
	FunctionList.Add( new LightLODConsoleFunctionClass() );
	FunctionList.Add( new LightningConsoleFunctionClass() );
	FunctionList.Add( new LrshCommandConsoleFunctionClass() );
	FunctionList.Add( new LogMeshStatsConsoleFunctionClass() );
	FunctionList.Add( new LogTexturesConsoleFunctionClass() );
	FunctionList.Add( new MainMenuConsoleFunctionClass() );
	FunctionList.Add( new MaxFacingPenaltyConsoleFunctionClass() );
	FunctionList.Add( new MeshDebuggerDisableMeshConsoleFunctionClass() );
	FunctionList.Add( new MeshDebuggerEnableConsoleFunctionClass() );
	FunctionList.Add( new MeshDebuggerEnableMeshConsoleFunctionClass() );
	FunctionList.Add( new MeshRenderSnapshotFunctionClass() );
	FunctionList.Add( new MissionConsoleFunctionClass() );
	FunctionList.Add( new MoneyConsoleFunctionClass() );
	FunctionList.Add( new MultiHudConsoleFunctionClass() );
	FunctionList.Add( new NextRenderConsoleFunctionClass() );
	FunctionList.Add( new OneShotKillsConsoleFunctionClass() );
	FunctionList.Add( new OpenConsoleFunctionClass() );
	FunctionList.Add( new Phys3NetConsoleFunctionClass() );
	FunctionList.Add( new PhysicsDebugConsoleFunctionClass() );
	FunctionList.Add( new PlayerPositionConsoleFunctionClass() );
	FunctionList.Add( new ProfileCollectBeginConsoleFunctionClass() );
	FunctionList.Add( new ProfileCollectEndConsoleFunctionClass() );
	FunctionList.Add( new ProjectorDebugConsoleFunctionClass() );
	//FunctionList.Add( new RadarMaxConsoleFunctionClass() );
	FunctionList.Add( new RadarToggleConsoleFunctionClass() );
	//FunctionList.Add( new RadarZoomConsoleFunctionClass() );
	FunctionList.Add( new RBodyNetConsoleFunctionClass() );
	FunctionList.Add( new RenderBackfacesConsoleFunctionClass() );
	FunctionList.Add( new RenderBoxesConsoleFunctionClass() );
	FunctionList.Add( new RenderModeConsoleFunctionClass() );
	FunctionList.Add( new RenderModeExtraPassConsoleFunctionClass() );
	FunctionList.Add( new ResolutionConsoleFunctionClass() );
	FunctionList.Add( new RunFastConsoleFunctionClass() );
	FunctionList.Add( new ParticleToggleConsoleFunctionClass() );
	FunctionList.Add( new ProfileConsoleFunctionClass() );
	FunctionList.Add( new QuickStatsConsoleFunctionClass() );
	FunctionList.Add( new RainConsoleFunctionClass() );
	//FunctionList.Add( new RshCommandConsoleFunctionClass() );
	FunctionList.Add( new ScaleTimeConsoleFunctionClass() );
	FunctionList.Add( new ScoreConsoleFunctionClass() );
	FunctionList.Add( new SnowConsoleFunctionClass() );
	FunctionList.Add( new SrshCommandConsoleFunctionClass() );
	FunctionList.Add( new DebugObjectivesConsoleFunctionClass() );
	FunctionList.Add( new CnCModeConsoleFunctionClass() );
	FunctionList.Add( new HUDHelpTextTestConsoleFunctionClass() );
	FunctionList.Add( new DebugEncyRevealConsoleFunctionClass() );
	FunctionList.Add( new DebugShowMoveVectorConsoleFunctionClass() );
	FunctionList.Add( new ChangeCharacterClassConsoleFunctionClass() );
	FunctionList.Add( new MapRevealConsoleFunctionClass() );
	FunctionList.Add( new ScriptTraceConsoleFunctionClass() );
	FunctionList.Add( new SetBandwidthBudgetOutToggleConsoleFunctionClass() );
	FunctionList.Add( new SetDesiredSleepConsoleFunctionClass() );
	FunctionList.Add( new SetPacketDuplicationConsoleFunctionClass() );
	FunctionList.Add( new SetPacketLatencyRangeConsoleFunctionClass() );
	FunctionList.Add( new SetPacketLossConsoleFunctionClass() );
	FunctionList.Add( new SetSpamCountConsoleFunctionClass() );
	FunctionList.Add( new SetStarHealthConsoleFunctionClass() );
	FunctionList.Add( new SetStarSkinConsoleFunctionClass() );
	FunctionList.Add( new SetStarShieldStrengthConsoleFunctionClass() );
	FunctionList.Add( new SetStarShieldTypeConsoleFunctionClass() );
	FunctionList.Add( new SetTheStarConsoleFunctionClass() );
	FunctionList.Add( new ShadowAttenuationConsoleFunctionClass() );
	FunctionList.Add( new ShadowBlobTextureConsoleFunctionClass() );
	FunctionList.Add( new ShadowCountConsoleFunctionClass() );
	FunctionList.Add( new ShadowElevationConsoleFunctionClass() );
	FunctionList.Add( new ShadowIntensityConsoleFunctionClass() );
	FunctionList.Add( new ShadowPerPolyCullingConsoleFunctionClass() );
	FunctionList.Add( new ShadowResolutionConsoleFunctionClass() );
	FunctionList.Add( new ShellCommandConsoleFunctionClass() );
	FunctionList.Add( new SkeletonSliderDemoConsoleFunctionClass() );
	FunctionList.Add( new SkeletonStandersConsoleFunctionClass() );
	FunctionList.Add( new SnapShotModeToggleFunctionClass() );
	FunctionList.Add( new SoldierGhostDebugDisplayConsoleFunctionClass() );
	FunctionList.Add( new StarVisibilityConsoleFunctionClass() );
	FunctionList.Add( new StatsConsoleFunctionClass() );
	//FunctionList.Add( new StealthConsoleFunctionClass() );
	FunctionList.Add( new SuicideConsoleFunctionClass() );
	FunctionList.Add( new SurfaceEffectsDebugConsoleFunctionClass() );
	FunctionList.Add( new SurfaceTypeOverrideConsoleFunctionClass() );
	FunctionList.Add( new SurfacePhysicsOverrideConsoleFunctionClass() );
	FunctionList.Add( new SwapTeamsConsoleFunctionClass() );
	FunctionList.Add( new TargetSteeringToggleConsoleFunctionClass() );
	FunctionList.Add( new TeleportStarConsoleFunctionClass() );
	FunctionList.Add( new TextureFilterModeConsoleFunctionClass() );
	FunctionList.Add( new TextureMemoryCounterConsoleFunctionClass() );
	FunctionList.Add( new TexturingEnableConsoleFunctionClass() );
	FunctionList.Add( new TimeOfDayConsoleFunctionClass() );
	FunctionList.Add( new ToggleAssetPreloadingConsoleFunctionClass() );
	FunctionList.Add( new ToggleEmotIconsConsoleFunctionClass() );
	FunctionList.Add( new ToggleHitReticleConsoleFunctionClass() );
	FunctionList.Add( new ToggleUseLetencyInterpretConsoleFunctionClass() );
	FunctionList.Add( new ToggleSimulationConsoleFunctionClass() );
	FunctionList.Add( new ToggleRenderingConsoleFunctionClass() );
	FunctionList.Add( new TomConsoleFunctionClass() );
	FunctionList.Add( new UmbraToggleFunctionClass() );
	FunctionList.Add( new UnusedSpawnerFunctionClass() );
	FunctionList.Add( new VipConsoleFunctionClass() );
	FunctionList.Add( new VisConsoleFunctionClass() );
	FunctionList.Add( new VisInvertConsoleFunctionClass() );
	FunctionList.Add( new VisGridDisplayConsoleFunctionClass() );
	FunctionList.Add( new VisGridDebugConsoleFunctionClass() );
	FunctionList.Add( new VisHierarchicalConsoleFunctionClass() );
	FunctionList.Add( new VisLockConsoleFunctionClass() );
	FunctionList.Add( new VisSectorDisplayConsoleFunctionClass() );
	FunctionList.Add( new VisSectorHistoryConsoleFunctionClass() );
	FunctionList.Add( new VblankSyncConsoleFunctionClass() );
	FunctionList.Add( new WatchConsoleFunctionClass() );
	FunctionList.Add( new WarBlitzConsoleFunctionClass() );
	FunctionList.Add( new WarpConsoleFunctionClass() );
	FunctionList.Add( new WhoIsConsoleFunctionClass() );
	FunctionList.Add( new WindConsoleFunctionClass() );
	FunctionList.Add( new WOLConsoleFunctionClass() );
	FunctionList.Add( new DataSafeStatsConsoleFunctionClass() );
	FunctionList.Add( new PatsDebugConsoleFunctionClass() );
	FunctionList.Add( new SetSendFrequencyConsoleFunctionClass() );
	FunctionList.Add( new TogglePacketDeltasConsoleFunctionClass() );
	FunctionList.Add( new TogglePacketComboConsoleFunctionClass() );
	FunctionList.Add( new TogglePacketOptConsoleFunctionClass() );
	FunctionList.Add( new SetLatencyConsoleFunctionClass() );
	FunctionList.Add( new ToggleNewClientUpdateMethodConsoleFunctionClass() );
	FunctionList.Add( new ToggleBandwidthBalancerConsoleFunctionClass() );
	FunctionList.Add( new NewTCADOConsoleFunctionClass() );

   FunctionList.Add( new DebugDeviceConsoleFunctionClass() );
	FunctionList.Add( new StatsConsoleFunctionClass() );
	FunctionList.Add( new ToggleSurfaceEffectsConsoleFunctionClass() );

	FunctionList.Add( new DeviceInfoConsoleFunctionClass() );

#endif // WWDEBUG (development commands)

   //
   // SHIPPING CONSOLE FUNCTIONS ONLY
   //

	FunctionList.Add( new GameOverConsoleFunctionClass() );
   FunctionList.Add( new AdminMessageConsoleFunctionClass() );
	FunctionList.Add( new GameInfoConsoleFunctionClass() );
	FunctionList.Add( new KickConsoleFunctionClass() );
	FunctionList.Add( new AllowConsoleFunctionClass() );

	FunctionList.Add( new BanConsoleFunctionClass() );
   FunctionList.Add( new MessageConsoleFunctionClass() );
	FunctionList.Add( new PlayerInfoConsoleFunctionClass() );
	FunctionList.Add( new QuitConsoleFunctionClass() );
	FunctionList.Add( new QuitSlaveConsoleFunctionClass() );
	FunctionList.Add( new RestartConsoleFunctionClass() );
	FunctionList.Add( new ScreenUVBiasConsoleFunctionClass() );
	FunctionList.Add( new SetBandwidthBudgetOutConsoleFunctionClass() );
	FunctionList.Add( new ToggleSortingConsoleFunctionClass() );
	FunctionList.Add( new ExtrasConsoleFunctionClass() );  /// CHEATS? MAY NEED TO BE DEV ONLY!!!!
	FunctionList.Add( new EditVehicleConsoleFunctionClass() );
	FunctionList.Add( new NetUpdateRateConsoleFunctionClass() );
	FunctionList.Add( new ClientPhysicsOptimizationConsoleFunctionClass() );
#ifndef FREEDEDICATEDSERVER
	FunctionList.Add( new FPSConsoleFunctionClass() );		// Steve W wanted this.
#endif //FREEDEDICATEDSERVER
#ifdef FREEDEDICATEDSERVER
	FunctionList.Add( new PageConsoleFunctionClass() );
#endif //FREEDEDICATEDSERVER


	SystemSettings::Add_Console_Functions( FunctionList );

	Sort_Function_List();

	//
	// Dump list to a file
	//
	Verbose_Help_File();
}

void	ConsoleFunctionManager::Shutdown( void )
{
	while ( FunctionList.Count() ) {
		delete FunctionList[ FunctionList.Count()-1 ];
		FunctionList.Delete( FunctionList.Count()-1 );
	}
}

//------------------------------------------------------------------------------------

void	ConsoleFunctionManager::Sort_Function_List( void )
{
	// ARGH!! Bubblesort!!!
	bool done = false;
	int count = FunctionList.Count();
	while ( !done ) {
		done = true;
		count--;
		for (	int index = 0; index < count; index++) {
			if ( stricmp(	FunctionList[index]->Get_Name(),
								FunctionList[index+1]->Get_Name() ) > 0 ) {
				ConsoleFunctionClass * temp = FunctionList[index];
				FunctionList[index] = FunctionList[index+1];
				FunctionList[index+1] = temp;
				done = false;
			}
		}
	}
}

//------------------------------------------------------------------------------------

void	ConsoleFunctionManager::Help(	const char * function_name )
{
	char string[120];

	// Eat leading spaces
	while ( function_name && *function_name == ' ' ) {
		function_name++;
	}

	if ( ( function_name == NULL ) || ( function_name[0] == 0 ) ) {
		// Show name of each function...
      Print( "------ Available commands -------\n" );
		*string = 0;
		for (	int index = 0; index < FunctionList.Count(); index++) {
			ConsoleFunctionClass * function = FunctionList[index];
			if ( *string ) {
				strcat( string, ", " );
			}
			strcat( string, function->Get_Name() );
			if ( ( strlen( string ) > (sizeof( string ) / 2) ) || (index == FunctionList.Count()-1) ) {
				strcat( string, "\n" );
				Print( string );
				*string = 0;
			}
		}
	} else {
		// Show help for a certian function
		for (	int index = 0; index < FunctionList.Count(); index++) {
			ConsoleFunctionClass * function = FunctionList[index];
			if ( !stricmp( function->Get_Name(), function_name ) ) {
		      Print( function->Get_Help() );
				return;
			}
		}
		Print( "Help not found for \"%s\"\n", function_name );
	}
}

//------------------------------------------------------------------------------------
int ConsoleFunctionManager::Get_Function_Count(void)
{
	return FunctionList.Count();
}

//------------------------------------------------------------------------------------
void ConsoleFunctionManager::Verbose_Help_File(void)
{
	//
	// Log function list to a file
	//
   FILE * file = fopen("commands.txt", "w");
	if ( file ) {
		char buffer[500];
		sprintf(buffer, "RENEGADE COMMANDS as at %s\n\n", cMiscUtil::Get_Text_Time());
		fwrite(buffer, 1, strlen(buffer), file);
		for (	int index = 0; index < FunctionList.Count(); index++) {
			ConsoleFunctionClass * function = FunctionList[index];
			WWASSERT(function != NULL);
			sprintf(buffer, "%s", function->Get_Help());
			if (function->Get_Alias() != NULL) {
				char alias_string[100];
				sprintf(alias_string, " (%s)", function->Get_Alias());
				strcat(buffer, alias_string);
			}
			strcat(buffer, "\n");
			fwrite(buffer, 1, strlen(buffer), file);
		}

#ifdef WWDEBUG
		char watch_help_buffer[5000];
      WatchConsoleFunctionClass::Get_Verbose_Help(watch_help_buffer, sizeof(watch_help_buffer));
		fwrite(watch_help_buffer, 1, strlen(watch_help_buffer), file);
#endif

		fclose(file);
	}
}

//------------------------------------------------------------------------------------
void ConsoleFunctionManager::Next_Verbose_Help_Screen(void)
{
	//
	// Show name of each function on a separate line...
	//
	char buffer[5000];
	buffer[0] = 0;

	static int page_number = -1;
	page_number++;

	if ( page_number >= 0 ) {
		int command_number = 0;
		for (	int index = 0; index < FunctionList.Count(); index++) {
			command_number++;
			int per_page = 57;
			if (floor(command_number / per_page) == page_number) {
				ConsoleFunctionClass * function = FunctionList[index];
				WWASSERT(function != NULL);
				strcat( buffer, function->Get_Help() );
				strcat( buffer, "\n" );

				if ( index == FunctionList.Count() - 1 ) {	// if this is the last line,
					page_number = -2;				// turn it off for next time

#ifdef WWDEBUG
					//
               // Also, show help for watch objects
               //
               strcat( buffer, "\n" );
               char watch_help_buffer[10000];
               WatchConsoleFunctionClass::Get_Verbose_Help(watch_help_buffer, sizeof(watch_help_buffer));
   				strcat( buffer, watch_help_buffer );
#endif // WWDEBUG
				}
			}
		}
	}
	if (Get_Text_Display()) {
		Get_Text_Display()->Set_Verbose_Help_Text( buffer );
	}
}

//------------------------------------------------------------------------------------
void	ConsoleFunctionManager::Parse_Input( const char * string )
{
	if (!strnicmp(string, "help", 4)) {
		Help( string + 4 );
	} else {
		for (	int index = 0; index < FunctionList.Count(); index++) {
			ConsoleFunctionClass * function = FunctionList[index];

         if ( !strnicmp( string, function->Get_Name(), strlen( function->Get_Name() ) ) ) {

				const char *s = string + strlen (function->Get_Name());

				// The next input character must be either a string terminator or space character
				// in order for the input string to match the function list string.
				if ((*s == '\0') || (*s == ' ')) {

					// Remove any trailing white space.
					while (*s == ' ') s++;

					function->Activate (s);
					return;
				}
         }

         //
         // Check short-form alias too
         // There has to be a space (or nothing) following the alias for
         // it to match
         //
         if (function->Get_Alias() != NULL &&
            strlen(function->Get_Alias()) > 0) {
            char alias[100];
            WWASSERT(strlen(function->Get_Alias()) < sizeof(alias));
            strcpy(alias, function->Get_Alias());
            int alias_len = strlen(alias);
            int string_len = strlen(string);
            if (!strnicmp(string, alias, alias_len) &&
               (string_len == alias_len || string[alias_len] == ' ')) {
				   string += alias_len;
				   while ( string && *string == ' ' ) string++;
				   function->Activate( string );
				   return;
            }
         }
		}

		if (ConsoleBox.Is_Exclusive()) {
      	Print( "\"%s\" is not a command. To send a message, use \"msg\" and \"amsg\"\n", string );
		} else {
      	Print( "\"%s\" is not a command. To send a message, Use F2 and F3\n", string );
		}
      Print( "For a list of available commands, use the \"help\" command !\n" );
	}
}

bool ConsoleFunctionManager::Get_Command_Suggestion
(
	const char *	input,					// what user has typed,
	const char *	cur_suggestion,		// last suggestion we gave (move to next if not null)
	char *			set_suggestion,		// copy suggestion into this string
	char *			set_help,				// copy help into this string
	int				len						// don't copy more than this many characters.
)
{
	ConsoleFunctionClass * function = NULL;
	int	node_index = 0;

	/*
	** If user is passing in a 'cur_suggestion', then we need to first find that
	** function in the list and search past it.  If we don't find a suggestion, we
	** will drop through and search from the head of the list.
	*/
	if (cur_suggestion != NULL) {

		node_index = Find_Function_Node(cur_suggestion);

		/*
		** Try to find a suggestion after this node.
		*/
		if (node_index != -1) {
			function = Find_Command_Suggestion(input,node_index+1);
		}
	}

	/*
	** Find a suggestion starting at the head of the list
	*/
	if (function == NULL) {
		function = Find_Command_Suggestion(input,0);
	}

	/*
	** If we found a suggestion, copy its command into 'set_suggestion' and its help
	** into 'set_help'
	*/
	if (function != NULL) {
		if (set_suggestion != NULL) {
			strncpy(set_suggestion,function->Get_Name(),len);
		}
		if (set_help != NULL) {
			strncpy(set_help,function->Get_Help(),len);
		}
		return true;
	}
	return false;
}

int ConsoleFunctionManager::Find_Function_Node(const char * name)
{
	for (	int index = 0; index < FunctionList.Count(); index++) {
		ConsoleFunctionClass * function = FunctionList[index];
		if (stricmp(name,function->Get_Name()) == 0) {
			return index;
		}
	}
	return -1;
}

ConsoleFunctionClass * ConsoleFunctionManager::Find_Command_Suggestion
(
	const char *	input,		// incomplete function name
	int				start_index	// node to start searching from
)
{
	for (	int index = start_index; index < FunctionList.Count(); index++) {
		ConsoleFunctionClass * function = FunctionList[index];
		if (_strnicmp(input,function->Get_Name(),strlen(input)) == 0) {
			return function;
		}
	}
	return NULL;
}

void	ConsoleFunctionManager::Print( const char *format, ... )
{
	va_list arg_list;
	va_start (arg_list, format);
	StringClass string;
	string.Format_Args( format, arg_list );
	if (Get_Text_Display()) {
		WWASSERT( Get_Text_Display() );
		Get_Text_Display()->Print_System( string );
	}
	ConsoleBox.Print(string.Peek_Buffer());
	va_end (arg_list);
}