SysCmds.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "../Game_local.h"

#include "TypeInfo.h"

/*
==================
Cmd_GetFloatArg
==================
*/
float Cmd_GetFloatArg( const idCmdArgs &args, int &argNum ) {
        const char *value;

        value = args.Argv( argNum++ );
        return atof( value );
}

/*
===================
Cmd_EntityList_f
===================
*/
void Cmd_EntityList_f( const idCmdArgs &args ) {
        int                     e;
        idEntity        *check;
        int                     count;
        size_t          size;
        idStr           match;

        if ( args.Argc() > 1 ) {
                match = args.Args();
                match.Replace( " ", "" );
        } else {
                match = "";
        }

        count = 0;
        size = 0;

        gameLocal.Printf( "%-4s  %-20s %-20s %s\n", " Num", "EntityDef", "Class", "Name" );
        gameLocal.Printf( "--------------------------------------------------------------------\n" );
        for( e = 0; e < MAX_GENTITIES; e++ ) {
                check = gameLocal.entities[ e ];

                if ( !check ) {
                        continue;
                }

                if ( !check->name.Filter( match, true ) ) {
                        continue;
                }

                gameLocal.Printf( "%4i: %-20s %-20s %s\n", e,
                        check->GetEntityDefName(), check->GetClassname(), check->name.c_str() );

                count++;
                size += check->spawnArgs.Allocated();
        }

        gameLocal.Printf( "...%d entities\n...%d bytes of spawnargs\n", count, size );
}

/*
===================
Cmd_ActiveEntityList_f
===================
*/
void Cmd_ActiveEntityList_f( const idCmdArgs &args ) {
        idEntity        *check;
        int                     count;

        count = 0;

        gameLocal.Printf( "%-4s  %-20s %-20s %s\n", " Num", "EntityDef", "Class", "Name" );
        gameLocal.Printf( "--------------------------------------------------------------------\n" );
        for( check = gameLocal.activeEntities.Next(); check != NULL; check = check->activeNode.Next() ) {
                char    dormant = check->fl.isDormant ? '-' : ' ';
                gameLocal.Printf( "%4i:%c%-20s %-20s %s\n", check->entityNumber, dormant, check->GetEntityDefName(), check->GetClassname(), check->name.c_str() );
                count++;
        }

        gameLocal.Printf( "...%d active entities\n", count );
}

/*
===================
Cmd_ListSpawnArgs_f
===================
*/
void Cmd_ListSpawnArgs_f( const idCmdArgs &args ) {
        int i;
        idEntity *ent;

        ent = gameLocal.FindEntity( args.Argv( 1 ) );
        if ( !ent ) {
                gameLocal.Printf( "entity not found\n" );
                return;
        }

        for ( i = 0; i < ent->spawnArgs.GetNumKeyVals(); i++ ) {
                const idKeyValue *kv = ent->spawnArgs.GetKeyVal( i );
                gameLocal.Printf( "\"%s\"  "S_COLOR_WHITE"\"%s\"\n", kv->GetKey().c_str(), kv->GetValue().c_str() );
        }
}

/*
===================
Cmd_ReloadScript_f
===================
*/
void Cmd_ReloadScript_f( const idCmdArgs &args ) {
        // shutdown the map because entities may point to script objects
        gameLocal.MapShutdown();

        // recompile the scripts
        gameLocal.program.Startup( SCRIPT_DEFAULT );

#ifdef _D3XP
        // loads a game specific main script file
        idStr gamedir;
        int i;
        for ( i = 0; i < 2; i++ ) {
                if ( i == 0 ) {
                        gamedir = cvarSystem->GetCVarString( "fs_game_base" );
                } else if ( i == 1 ) {
                        gamedir = cvarSystem->GetCVarString( "fs_game" );
                }
                if ( gamedir.Length() > 0 ) {
                        idStr scriptFile = va( "script/%s_main.script", gamedir.c_str() );
                        if ( fileSystem->ReadFile(scriptFile.c_str(), NULL) > 0 ) {
                                gameLocal.program.CompileFile( scriptFile.c_str() );
                                gameLocal.program.FinishCompilation();
                        }
                }
        }
#endif

        // error out so that the user can rerun the scripts
        gameLocal.Error( "Exiting map to reload scripts" );
}

/*
===================
Cmd_Script_f
===================
*/
void Cmd_Script_f( const idCmdArgs &args ) {
        const char *    script;
        idStr                   text;
        idStr                   funcname;
        static int              funccount = 0;
        idThread *              thread;
        const function_t *func;
        idEntity                *ent;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        sprintf( funcname, "ConsoleFunction_%d", funccount++ );

        script = args.Args();
        sprintf( text, "void %s() {%s;}\n", funcname.c_str(), script );
        if ( gameLocal.program.CompileText( "console", text, true ) ) {
                func = gameLocal.program.FindFunction( funcname );
                if ( func ) {
                        // set all the entity names in case the user named one in the script that wasn't referenced in the default script
                        for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                                gameLocal.program.SetEntity( ent->name, ent );
                        }

                        thread = new idThread( func );
                        thread->Start();
                }
        }
}

/*
==================
KillEntities

Kills all the entities of the given class in a level.
==================
*/
void KillEntities( const idCmdArgs &args, const idTypeInfo &superClass ) {
        idEntity        *ent;
        idStrList       ignore;
        const char *name;
        int                     i;

        if ( !gameLocal.GetLocalPlayer() || !gameLocal.CheatsOk( false ) ) {
                return;
        }

        for( i = 1; i < args.Argc(); i++ ) {
                name = args.Argv( i );
                ignore.Append( name );
        }

        for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                if ( ent->IsType( superClass ) ) {
                        for( i = 0; i < ignore.Num(); i++ ) {
                                if ( ignore[ i ] == ent->name ) {
                                        break;
                                }
                        }

                        if ( i >= ignore.Num() ) {
                                ent->PostEventMS( &EV_Remove, 0 );
                        }
                }
        }
}

/*
==================
Cmd_KillMonsters_f

Kills all the monsters in a level.
==================
*/
void Cmd_KillMonsters_f( const idCmdArgs &args ) {
        KillEntities( args, idAI::Type );

        // kill any projectiles as well since they have pointers to the monster that created them
        KillEntities( args, idProjectile::Type );
}

/*
==================
Cmd_KillMovables_f

Kills all the moveables in a level.
==================
*/
void Cmd_KillMovables_f( const idCmdArgs &args ) {
        if ( !gameLocal.GetLocalPlayer() || !gameLocal.CheatsOk( false ) ) {
                return;
        }
        KillEntities( args, idMoveable::Type );
}

/*
==================
Cmd_KillRagdolls_f

Kills all the ragdolls in a level.
==================
*/
void Cmd_KillRagdolls_f( const idCmdArgs &args ) {
        if ( !gameLocal.GetLocalPlayer() || !gameLocal.CheatsOk( false ) ) {
                return;
        }
        KillEntities( args, idAFEntity_Generic::Type );
        KillEntities( args, idAFEntity_WithAttachedHead::Type );
}

/*
==================
Cmd_Give_f

Give items to a client
==================
*/
void Cmd_Give_f( const idCmdArgs &args ) {
        const char *name;
        int                     i;
        bool            give_all;
        idPlayer        *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        name = args.Argv( 1 );

        if ( idStr::Icmp( name, "all" ) == 0 ) {
                give_all = true;
        } else {
                give_all = false;
        }

        if ( give_all || ( idStr::Cmpn( name, "weapon", 6 ) == 0 ) ) {
                if ( gameLocal.world->spawnArgs.GetBool( "no_Weapons" ) ) {
                        gameLocal.world->spawnArgs.SetBool( "no_Weapons", false );
                        for( i = 0; i < gameLocal.numClients; i++ ) {
                                if ( gameLocal.entities[ i ] ) {
                                        gameLocal.entities[ i ]->PostEventSec( &EV_Player_SelectWeapon, 0.5f, gameLocal.entities[ i ]->spawnArgs.GetString( "def_weapon1" ) );
                                }
                        }
                }
        }

        if ( ( idStr::Cmpn( name, "weapon_", 7 ) == 0 ) || ( idStr::Cmpn( name, "item_", 5 ) == 0 ) || ( idStr::Cmpn( name, "ammo_", 5 ) == 0 ) ) {
                player->GiveItem( name );
                return;
        }

        if ( give_all || idStr::Icmp( name, "health" ) == 0 )   {
                player->health = player->inventory.maxHealth;
                if ( !give_all ) {
                        return;
                }
        }

        if ( give_all || idStr::Icmp( name, "weapons" ) == 0 ) {
                player->inventory.weapons = BIT( MAX_WEAPONS ) - 1;
                player->CacheWeapons();

                if ( !give_all ) {
                        return;
                }
        }

        if ( give_all || idStr::Icmp( name, "ammo" ) == 0 ) {
                for ( i = 0 ; i < AMMO_NUMTYPES; i++ ) {
                        player->inventory.ammo[ i ] = player->inventory.MaxAmmoForAmmoClass( player, idWeapon::GetAmmoNameForNum( ( ammo_t )i ) );
                }
                if ( !give_all ) {
                        return;
                }
        }

        if ( give_all || idStr::Icmp( name, "armor" ) == 0 ) {
                player->inventory.armor = player->inventory.maxarmor;
                if ( !give_all ) {
                        return;
                }
        }

        if ( idStr::Icmp( name, "berserk" ) == 0 ) {
                player->GivePowerUp( BERSERK, SEC2MS( 30.0f ) );
                return;
        }

        if ( idStr::Icmp( name, "invis" ) == 0 ) {
                player->GivePowerUp( INVISIBILITY, SEC2MS( 30.0f ) );
                return;
        }

#ifdef _D3XP
        if ( idStr::Icmp( name, "invulnerability" ) == 0 ) {
                if ( args.Argc() > 2 ) {
                        player->GivePowerUp( INVULNERABILITY, atoi( args.Argv( 2 ) ) );
                }
                else {
                        player->GivePowerUp( INVULNERABILITY, 30000 );
                }
                return;
        }

        if ( idStr::Icmp( name, "helltime" ) == 0 ) {
                if ( args.Argc() > 2 ) {
                        player->GivePowerUp( HELLTIME, atoi( args.Argv( 2 ) ) );
                }
                else {
                        player->GivePowerUp( HELLTIME, 30000 );
                }
                return;
        }

        if ( idStr::Icmp( name, "envirosuit" ) == 0 ) {
                if ( args.Argc() > 2 ) {
                        player->GivePowerUp( ENVIROSUIT, atoi( args.Argv( 2 ) ) );
                }
                else {
                        player->GivePowerUp( ENVIROSUIT, 30000 );
                }
                return;
        }
#endif
        if ( idStr::Icmp( name, "pda" ) == 0 ) {
                player->GivePDA( args.Argv(2), NULL );
                return;
        }

        if ( idStr::Icmp( name, "video" ) == 0 ) {
                player->GiveVideo( args.Argv(2), NULL );
                return;
        }

        if ( !give_all && !player->Give( args.Argv(1), args.Argv(2) ) ) {
                gameLocal.Printf( "unknown item\n" );
        }
}

/*
==================
Cmd_CenterView_f

Centers the players pitch
==================
*/
void Cmd_CenterView_f( const idCmdArgs &args ) {
        idPlayer        *player;
        idAngles        ang;

        player = gameLocal.GetLocalPlayer();
        if ( !player ) {
                return;
        }

        ang = player->viewAngles;
        ang.pitch = 0.0f;
        player->SetViewAngles( ang );
}

/*
==================
Cmd_God_f

Sets client to godmode

argv(0) god
==================
*/
void Cmd_God_f( const idCmdArgs &args ) {
        const char      *msg;
        idPlayer        *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( player->godmode ) {
                player->godmode = false;
                msg = "godmode OFF\n";
        } else {
                player->godmode = true;
                msg = "godmode ON\n";
        }

        gameLocal.Printf( "%s", msg );
}

/*
==================
Cmd_Notarget_f

Sets client to notarget

argv(0) notarget
==================
*/
void Cmd_Notarget_f( const idCmdArgs &args ) {
        const char      *msg;
        idPlayer        *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( player->fl.notarget ) {
                player->fl.notarget = false;
                msg = "notarget OFF\n";
        } else {
                player->fl.notarget = true;
                msg = "notarget ON\n";
        }

        gameLocal.Printf( "%s", msg );
}

/*
==================
Cmd_Noclip_f

argv(0) noclip
==================
*/
void Cmd_Noclip_f( const idCmdArgs &args ) {
        const char      *msg;
        idPlayer        *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( player->noclip ) {
                msg = "noclip OFF\n";
        } else {
                msg = "noclip ON\n";
        }
        player->noclip = !player->noclip;

        gameLocal.Printf( "%s", msg );
}

/*
=================
Cmd_Kill_f
=================
*/
void Cmd_Kill_f( const idCmdArgs &args ) {
        idPlayer        *player;

        if ( gameLocal.isMultiplayer ) {
                if ( gameLocal.isClient ) {
                        idBitMsg        outMsg;
                        byte            msgBuf[ MAX_GAME_MESSAGE_SIZE ];
                        outMsg.Init( msgBuf, sizeof( msgBuf ) );
                        outMsg.WriteByte( GAME_RELIABLE_MESSAGE_KILL );
                        networkSystem->ClientSendReliableMessage( outMsg );
                } else {
                        player = gameLocal.GetClientByCmdArgs( args );
                        if ( !player ) {
                                common->Printf( "kill <client nickname> or kill <client index>\n" );
                                return;
                        }
                        player->Kill( false, false );
                        cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "say killed client %d '%s^0'\n", player->entityNumber, gameLocal.userInfo[ player->entityNumber ].GetString( "ui_name" ) ) );
                }
        } else {
                player = gameLocal.GetLocalPlayer();
                if ( !player ) {
                        return;
                }
                player->Kill( false, false );
        }
}

/*
=================
Cmd_PlayerModel_f
=================
*/
void Cmd_PlayerModel_f( const idCmdArgs &args ) {
        idPlayer        *player;
        const char *name;
        idVec3          pos;
        idAngles        ang;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() < 2 ) {
                gameLocal.Printf( "usage: playerModel <modelname>\n" );
                return;
        }

        name = args.Argv( 1 );
        player->spawnArgs.Set( "model", name );

        pos = player->GetPhysics()->GetOrigin();
        ang = player->viewAngles;
        player->SpawnToPoint( pos, ang );
}

/*
==================
Cmd_Say
==================
*/
static void Cmd_Say( bool team, const idCmdArgs &args ) {
        const char *name;
        idStr text;
        const char *cmd = team ? "sayTeam" : "say" ;

        if ( !gameLocal.isMultiplayer ) {
                gameLocal.Printf( "%s can only be used in a multiplayer game\n", cmd );
                return;
        }

        if ( args.Argc() < 2 ) {
                gameLocal.Printf( "usage: %s <text>\n", cmd );
                return;
        }

        text = args.Args();
        if ( text.Length() == 0 ) {
                return;
        }

        if ( text[ text.Length() - 1 ] == '\n' ) {
                text[ text.Length() - 1 ] = '\0';
        }
        name = "player";

        idPlayer *      player;

        // here we need to special case a listen server to use the real client name instead of "server"
        // "server" will only appear on a dedicated server
        if ( gameLocal.isClient || cvarSystem->GetCVarInteger( "net_serverDedicated" ) == 0 ) {
                player = gameLocal.localClientNum >= 0 ? static_cast<idPlayer *>( gameLocal.entities[ gameLocal.localClientNum ] ) : NULL;
                if ( player ) {
                        name = player->GetUserInfo()->GetString( "ui_name", "player" );
                }

#ifdef CTF
        // Append the player's location to team chat messages in CTF
        if ( gameLocal.mpGame.IsGametypeFlagBased() && team && player ) {
            idLocationEntity *locationEntity = gameLocal.LocationForPoint( player->GetEyePosition() );
            
            if ( locationEntity ) {
                idStr temp = "[";
                temp += locationEntity->GetLocation();
                temp += "] ";
                temp += text;
                text = temp;
            }
            
        }
#endif

        
        } else {
                name = "server";
        }

        if ( gameLocal.isClient ) {
                idBitMsg        outMsg;
                byte            msgBuf[ 256 ];
                outMsg.Init( msgBuf, sizeof( msgBuf ) );
                outMsg.WriteByte( team ? GAME_RELIABLE_MESSAGE_TCHAT : GAME_RELIABLE_MESSAGE_CHAT );
                outMsg.WriteString( name );
                outMsg.WriteString( text, -1, false );
                networkSystem->ClientSendReliableMessage( outMsg );
        } else {
                gameLocal.mpGame.ProcessChatMessage( gameLocal.localClientNum, team, name, text, NULL );
        }
}

/*
==================
Cmd_Say_f
==================
*/
static void Cmd_Say_f( const idCmdArgs &args ) {
        Cmd_Say( false, args );
}

/*
==================
Cmd_SayTeam_f
==================
*/
static void Cmd_SayTeam_f( const idCmdArgs &args ) {
        Cmd_Say( true, args );
}

/*
==================
Cmd_AddChatLine_f
==================
*/
static void Cmd_AddChatLine_f( const idCmdArgs &args ) {
        gameLocal.mpGame.AddChatLine( args.Argv( 1 ) );
}

/*
==================
Cmd_Kick_f
==================
*/
static void Cmd_Kick_f( const idCmdArgs &args ) {
        idPlayer *player;

        if ( !gameLocal.isMultiplayer ) {
                gameLocal.Printf( "kick can only be used in a multiplayer game\n" );
                return;
        }

        if ( gameLocal.isClient ) {
                gameLocal.Printf( "You have no such power. This is a server command\n" );
                return;
        }

        player = gameLocal.GetClientByCmdArgs( args );
        if ( !player ) {
                gameLocal.Printf( "usage: kick <client nickname> or kick <client index>\n" );
                return;
        }
        cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "say kicking out client %d '%s^0'\n", player->entityNumber, gameLocal.userInfo[ player->entityNumber ].GetString( "ui_name" ) ) );
        cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "kick %d\n", player->entityNumber ) );
}

/*
==================
Cmd_GetViewpos_f
==================
*/
void Cmd_GetViewpos_f( const idCmdArgs &args ) {
        idPlayer        *player;
        idVec3          origin;
        idMat3          axis;

        player = gameLocal.GetLocalPlayer();
        if ( !player ) {
                return;
        }

        const renderView_t *view = player->GetRenderView();
        if ( view ) {
                gameLocal.Printf( "(%s) %.1f\n", view->vieworg.ToString(), view->viewaxis[0].ToYaw() );
        } else {
                player->GetViewPos( origin, axis );
                gameLocal.Printf( "(%s) %.1f\n", origin.ToString(), axis[0].ToYaw() );
        }
}

/*
=================
Cmd_SetViewpos_f
=================
*/
void Cmd_SetViewpos_f( const idCmdArgs &args ) {
        idVec3          origin;
        idAngles        angles;
        int                     i;
        idPlayer        *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( ( args.Argc() != 4 ) && ( args.Argc() != 5 ) ) {
                gameLocal.Printf( "usage: setviewpos <x> <y> <z> <yaw>\n" );
                return;
        }

        angles.Zero();
        if ( args.Argc() == 5 ) {
                angles.yaw = atof( args.Argv( 4 ) );
        }

        for ( i = 0 ; i < 3 ; i++ ) {
                origin[i] = atof( args.Argv( i + 1 ) );
        }
        origin.z -= pm_normalviewheight.GetFloat() - 0.25f;

        player->Teleport( origin, angles, NULL );
}

/*
=================
Cmd_Teleport_f
=================
*/
void Cmd_Teleport_f( const idCmdArgs &args ) {
        idVec3          origin;
        idAngles        angles;
        idPlayer        *player;
        idEntity        *ent;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() != 2 ) {
                gameLocal.Printf( "usage: teleport <name of entity to teleport to>\n" );
                return;
        }

        ent = gameLocal.FindEntity( args.Argv( 1 ) );
        if ( !ent ) {
                gameLocal.Printf( "entity not found\n" );
                return;
        }

        angles.Zero();
        angles.yaw = ent->GetPhysics()->GetAxis()[ 0 ].ToYaw();
        origin = ent->GetPhysics()->GetOrigin();

        player->Teleport( origin, angles, ent );
}

/*
=================
Cmd_Trigger_f
=================
*/
void Cmd_Trigger_f( const idCmdArgs &args ) {
        idVec3          origin;
        idAngles        angles;
        idPlayer        *player;
        idEntity        *ent;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() != 2 ) {
                gameLocal.Printf( "usage: trigger <name of entity to trigger>\n" );
                return;
        }

        ent = gameLocal.FindEntity( args.Argv( 1 ) );
        if ( !ent ) {
                gameLocal.Printf( "entity not found\n" );
                return;
        }

        ent->Signal( SIG_TRIGGER );
        ent->ProcessEvent( &EV_Activate, player );
        ent->TriggerGuis();
}

/*
===================
Cmd_Spawn_f
===================
*/
void Cmd_Spawn_f( const idCmdArgs &args ) {
        const char *key, *value;
        int                     i;
        float           yaw;
        idVec3          org;
        idPlayer        *player;
        idDict          dict;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk( false ) ) {
                return;
        }

        if ( args.Argc() & 1 ) {        // must always have an even number of arguments
                gameLocal.Printf( "usage: spawn classname [key/value pairs]\n" );
                return;
        }

        yaw = player->viewAngles.yaw;

        value = args.Argv( 1 );
        dict.Set( "classname", value );
        dict.Set( "angle", va( "%f", yaw + 180 ) );

        org = player->GetPhysics()->GetOrigin() + idAngles( 0, yaw, 0 ).ToForward() * 80 + idVec3( 0, 0, 1 );
        dict.Set( "origin", org.ToString() );

        for( i = 2; i < args.Argc() - 1; i += 2 ) {

                key = args.Argv( i );
                value = args.Argv( i + 1 );

                dict.Set( key, value );
        }

        gameLocal.SpawnEntityDef( dict );
}

/*
==================
Cmd_Damage_f

Damages the specified entity
==================
*/
void Cmd_Damage_f( const idCmdArgs &args ) {
        if ( !gameLocal.GetLocalPlayer() || !gameLocal.CheatsOk( false ) ) {
                return;
        }
        if ( args.Argc() != 3 ) {
                gameLocal.Printf( "usage: damage <name of entity to damage> <damage>\n" );
                return;
        }

        idEntity *ent = gameLocal.FindEntity( args.Argv( 1 ) );
        if ( !ent ) {
                gameLocal.Printf( "entity not found\n" );
                return;
        }

        ent->Damage( gameLocal.world, gameLocal.world, idVec3( 0, 0, 1 ), "damage_moverCrush", atoi( args.Argv( 2 ) ), INVALID_JOINT );
}


/*
==================
Cmd_Remove_f

Removes the specified entity
==================
*/
void Cmd_Remove_f( const idCmdArgs &args ) {
        if ( !gameLocal.GetLocalPlayer() || !gameLocal.CheatsOk( false ) ) {
                return;
        }
        if ( args.Argc() != 2 ) {
                gameLocal.Printf( "usage: remove <name of entity to remove>\n" );
                return;
        }

        idEntity *ent = gameLocal.FindEntity( args.Argv( 1 ) );
        if ( !ent ) {
                gameLocal.Printf( "entity not found\n" );
                return;
        }

        delete ent;
}

/*
===================
Cmd_TestLight_f
===================
*/
void Cmd_TestLight_f( const idCmdArgs &args ) {
        int                     i;
        idStr           filename;
        const char *key, *value, *name;
        idPlayer *      player;
        idDict          dict;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk( false ) ) {
                return;
        }

        renderView_t    *rv = player->GetRenderView();

        float fov = tan( idMath::M_DEG2RAD * rv->fov_x / 2 );


        dict.SetMatrix( "rotation", mat3_default );
        dict.SetVector( "origin", rv->vieworg );
        dict.SetVector( "light_target", rv->viewaxis[0] );
        dict.SetVector( "light_right", rv->viewaxis[1] * -fov );
        dict.SetVector( "light_up", rv->viewaxis[2] * fov );
        dict.SetVector( "light_start", rv->viewaxis[0] * 16 );
        dict.SetVector( "light_end", rv->viewaxis[0] * 1000 );

        if ( args.Argc() >= 2 ) {
                value = args.Argv( 1 );
                filename = args.Argv(1);
                filename.DefaultFileExtension( ".tga" );
                dict.Set( "texture", filename );
        }

        dict.Set( "classname", "light" );
        for( i = 2; i < args.Argc() - 1; i += 2 ) {

                key = args.Argv( i );
                value = args.Argv( i + 1 );

                dict.Set( key, value );
        }

        for ( i = 0; i < MAX_GENTITIES; i++ ) {
                name = va( "spawned_light_%d", i );             // not just light_, or it might pick up a prelight shadow
                if ( !gameLocal.FindEntity( name ) ) {
                        break;
                }
        }
        dict.Set( "name", name );

        gameLocal.SpawnEntityDef( dict );

        gameLocal.Printf( "Created new light\n");
}

/*
===================
Cmd_TestPointLight_f
===================
*/
void Cmd_TestPointLight_f( const idCmdArgs &args ) {
        const char *key, *value, *name;
        int                     i;
        idPlayer        *player;
        idDict          dict;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk( false ) ) {
                return;
        }

        dict.SetVector("origin", player->GetRenderView()->vieworg);

        if ( args.Argc() >= 2 ) {
                value = args.Argv( 1 );
                dict.Set("light", value);
        } else {
                dict.Set("light", "300");
        }

        dict.Set( "classname", "light" );
        for( i = 2; i < args.Argc() - 1; i += 2 ) {

                key = args.Argv( i );
                value = args.Argv( i + 1 );

                dict.Set( key, value );
        }

        for ( i = 0; i < MAX_GENTITIES; i++ ) {
                name = va( "light_%d", i );
                if ( !gameLocal.FindEntity( name ) ) {
                        break;
                }
        }
        dict.Set( "name", name );

        gameLocal.SpawnEntityDef( dict );

        gameLocal.Printf( "Created new point light\n");
}

/*
==================
Cmd_PopLight_f
==================
*/
void Cmd_PopLight_f( const idCmdArgs &args ) {
        idEntity        *ent;
        idMapEntity *mapEnt;
        idMapFile       *mapFile = gameLocal.GetLevelMap();
        idLight         *lastLight;
        int                     last;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        bool removeFromMap = ( args.Argc() > 1 );

        lastLight = NULL;
        last = -1;
        for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                if ( !ent->IsType( idLight::Type ) ) {
                        continue;
                }

                if ( gameLocal.spawnIds[ ent->entityNumber ] > last ) {
                        last = gameLocal.spawnIds[ ent->entityNumber ];
                        lastLight = static_cast<idLight*>( ent );
                }
        }

        if ( lastLight ) {
                // find map file entity
                mapEnt = mapFile->FindEntity( lastLight->name );

                if ( removeFromMap && mapEnt ) {
                        mapFile->RemoveEntity( mapEnt );
                }
                gameLocal.Printf( "Removing light %i\n", lastLight->GetLightDefHandle() );
                delete lastLight;
        } else {
                gameLocal.Printf( "No lights to clear.\n" );
        }

}

/*
====================
Cmd_ClearLights_f
====================
*/
void Cmd_ClearLights_f( const idCmdArgs &args ) {
        idEntity *ent;
        idEntity *next;
        idLight *light;
        idMapEntity *mapEnt;
        idMapFile *mapFile = gameLocal.GetLevelMap();

        bool removeFromMap = ( args.Argc() > 1 );

        gameLocal.Printf( "Clearing all lights.\n" );
        for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = next ) {
                next = ent->spawnNode.Next();
                if ( !ent->IsType( idLight::Type ) ) {
                        continue;
                }

                light = static_cast<idLight*>( ent );
                mapEnt = mapFile->FindEntity( light->name );

                if ( removeFromMap && mapEnt ) {
                        mapFile->RemoveEntity( mapEnt );
                }

                delete light;
        }
}

/*
==================
Cmd_TestFx_f
==================
*/
void Cmd_TestFx_f( const idCmdArgs &args ) {
        idVec3          offset;
        const char *name;
        idPlayer *      player;
        idDict          dict;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        // delete the testModel if active
        if ( gameLocal.testFx ) {
                delete gameLocal.testFx;
                gameLocal.testFx = NULL;
        }

        if ( args.Argc() < 2 ) {
                return;
        }

        name = args.Argv( 1 );

        offset = player->GetPhysics()->GetOrigin() + player->viewAngles.ToForward() * 100.0f;

        dict.Set( "origin", offset.ToString() );
        dict.Set( "test", "1");
        dict.Set( "fx", name );
        gameLocal.testFx = ( idEntityFx * )gameLocal.SpawnEntityType( idEntityFx::Type, &dict );
}

#define MAX_DEBUGLINES  128

typedef struct {
        bool used;
        idVec3 start, end;
        int color;
        bool blink;
        bool arrow;
} gameDebugLine_t;

gameDebugLine_t debugLines[MAX_DEBUGLINES];

/*
==================
Cmd_AddDebugLine_f
==================
*/
static void Cmd_AddDebugLine_f( const idCmdArgs &args ) {
        int i, argNum;
        const char *value;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc () < 7 ) {
                gameLocal.Printf( "usage: addline <x y z> <x y z> <color>\n" );
                return;
        }
        for ( i = 0; i < MAX_DEBUGLINES; i++ ) {
                if ( !debugLines[i].used ) {
                        break;
                }
        }
        if ( i >= MAX_DEBUGLINES ) {
                gameLocal.Printf( "no free debug lines\n" );
                return;
        }
        value = args.Argv( 0 );
        if ( !idStr::Icmp( value, "addarrow" ) ) {
                debugLines[i].arrow = true;
        } else {
                debugLines[i].arrow = false;
        }
        debugLines[i].used = true;
        debugLines[i].blink = false;
        argNum = 1;
        debugLines[i].start.x = Cmd_GetFloatArg( args, argNum );
        debugLines[i].start.y = Cmd_GetFloatArg( args, argNum );
        debugLines[i].start.z = Cmd_GetFloatArg( args, argNum );
        debugLines[i].end.x = Cmd_GetFloatArg( args, argNum );
        debugLines[i].end.y = Cmd_GetFloatArg( args, argNum );
        debugLines[i].end.z = Cmd_GetFloatArg( args, argNum );
        debugLines[i].color = Cmd_GetFloatArg( args, argNum );
}

/*
==================
Cmd_RemoveDebugLine_f
==================
*/
static void Cmd_RemoveDebugLine_f( const idCmdArgs &args ) {
        int i, num;
        const char *value;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc () < 2 ) {
                gameLocal.Printf( "usage: removeline <num>\n" );
                return;
        }
        value = args.Argv( 1 );
        num = atoi(value);
        for ( i = 0; i < MAX_DEBUGLINES; i++ ) {
                if ( debugLines[i].used ) {
                        if ( --num < 0 ) {
                                break;
                        }
                }
        }
        if ( i >= MAX_DEBUGLINES ) {
                gameLocal.Printf( "line not found\n" );
                return;
        }
        debugLines[i].used = false;
}

/*
==================
Cmd_BlinkDebugLine_f
==================
*/
static void Cmd_BlinkDebugLine_f( const idCmdArgs &args ) {
        int i, num;
        const char *value;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc () < 2 ) {
                gameLocal.Printf( "usage: blinkline <num>\n" );
                return;
        }
        value = args.Argv( 1 );
        num = atoi( value );
        for ( i = 0; i < MAX_DEBUGLINES; i++ ) {
                if ( debugLines[i].used ) {
                        if ( --num < 0 ) {
                                break;
                        }
                }
        }
        if ( i >= MAX_DEBUGLINES ) {
                gameLocal.Printf( "line not found\n" );
                return;
        }
        debugLines[i].blink = !debugLines[i].blink;
}

/*
==================
PrintFloat
==================
*/
static void PrintFloat( float f ) {
        char buf[128], i;

        for ( i = sprintf( buf, "%3.2f", f ); i < 7; i++ ) {
                buf[i] = ' ';
        }
        buf[i] = '\0';
        gameLocal.Printf( buf );
}

/*
==================
Cmd_ListDebugLines_f
==================
*/
static void Cmd_ListDebugLines_f( const idCmdArgs &args ) {
        int i, num;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        num = 0;
        gameLocal.Printf( "line num: x1     y1     z1     x2     y2     z2     c  b  a\n" );
        for ( i = 0; i < MAX_DEBUGLINES; i++ ) {
                if ( debugLines[i].used ) {
                        gameLocal.Printf( "line %3d: ", num );
                        PrintFloat( debugLines[i].start.x );
                        PrintFloat( debugLines[i].start.y );
                        PrintFloat( debugLines[i].start.z );
                        PrintFloat( debugLines[i].end.x );
                        PrintFloat( debugLines[i].end.y );
                        PrintFloat( debugLines[i].end.z );
                        gameLocal.Printf( "%d  %d  %d\n", debugLines[i].color, debugLines[i].blink, debugLines[i].arrow );
                        num++;
                }
        }
        if ( !num ) {
                gameLocal.Printf( "no debug lines\n" );
        }
}

/*
==================
D_DrawDebugLines
==================
*/
void D_DrawDebugLines( void ) {
        int i;
        idVec3 forward, right, up, p1, p2;
        idVec4 color;
        float l;

        for ( i = 0; i < MAX_DEBUGLINES; i++ ) {
                if ( debugLines[i].used ) {
                        if ( !debugLines[i].blink || (gameLocal.time & (1<<9)) ) {
                                color = idVec4( debugLines[i].color&1, (debugLines[i].color>>1)&1, (debugLines[i].color>>2)&1, 1 );
                                gameRenderWorld->DebugLine( color, debugLines[i].start, debugLines[i].end );
                                //
                                if ( debugLines[i].arrow ) {
                                        // draw a nice arrow
                                        forward = debugLines[i].end - debugLines[i].start;
                                        l = forward.Normalize() * 0.2f;
                                        forward.NormalVectors( right, up);

                                        if ( l > 3.0f ) {
                                                l = 3.0f;
                                        }
                                        p1 = debugLines[i].end - l * forward + (l * 0.4f) * right;
                                        p2 = debugLines[i].end - l * forward - (l * 0.4f) * right;
                                        gameRenderWorld->DebugLine( color, debugLines[i].end, p1 );
                                        gameRenderWorld->DebugLine( color, debugLines[i].end, p2 );
                                        gameRenderWorld->DebugLine( color, p1, p2 );
                                }
                        }
                }
        }
}

/*
==================
Cmd_ListCollisionModels_f
==================
*/
static void Cmd_ListCollisionModels_f( const idCmdArgs &args ) {
        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        collisionModelManager->ListModels();
}

/*
==================
Cmd_CollisionModelInfo_f
==================
*/
static void Cmd_CollisionModelInfo_f( const idCmdArgs &args ) {
        const char *value;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc () < 2 ) {
                gameLocal.Printf( "usage: collisionModelInfo <modelNum>\n"
                                        "use 'all' instead of the model number for accumulated info\n" );
                return;
        }

        value = args.Argv( 1 );
        if ( !idStr::Icmp( value, "all" ) ) {
                collisionModelManager->ModelInfo( -1 );
        } else {
                collisionModelManager->ModelInfo( atoi(value) );
        }
}

/*
==================
Cmd_ExportModels_f
==================
*/
static void Cmd_ExportModels_f( const idCmdArgs &args ) {
        idModelExport   exporter;
        idStr                   name;

        // don't allow exporting models when cheats are disabled,
        // but if we're not in the game, it's ok
        if ( gameLocal.GetLocalPlayer() && !gameLocal.CheatsOk( false ) ) {
                return;
        }

        if ( args.Argc() < 2 ) {
                exporter.ExportModels( "def", ".def" );
        } else {
                name = args.Argv( 1 );
                name = "def/" + name;
                name.DefaultFileExtension( ".def" );
                exporter.ExportDefFile( name );
        }
}

/*
==================
Cmd_ReexportModels_f
==================
*/
static void Cmd_ReexportModels_f( const idCmdArgs &args ) {
        idModelExport   exporter;
        idStr                   name;

        // don't allow exporting models when cheats are disabled,
        // but if we're not in the game, it's ok
        if ( gameLocal.GetLocalPlayer() && !gameLocal.CheatsOk( false ) ) {
                return;
        }

        idAnimManager::forceExport = true;
        if ( args.Argc() < 2 ) {
                exporter.ExportModels( "def", ".def" );
        } else {
                name = args.Argv( 1 );
                name = "def/" + name;
                name.DefaultFileExtension( ".def" );
                exporter.ExportDefFile( name );
        }
        idAnimManager::forceExport = false;
}

/*
==================
Cmd_ReloadAnims_f
==================
*/
static void Cmd_ReloadAnims_f( const idCmdArgs &args ) {
        // don't allow reloading anims when cheats are disabled,
        // but if we're not in the game, it's ok
        if ( gameLocal.GetLocalPlayer() && !gameLocal.CheatsOk( false ) ) {
                return;
        }

        animationLib.ReloadAnims();
}

/*
==================
Cmd_ListAnims_f
==================
*/
static void Cmd_ListAnims_f( const idCmdArgs &args ) {
        idEntity *              ent;
        int                             num;
        size_t                  size;
        size_t                  alloced;
        idAnimator *    animator;
        const char *    classname;
        const idDict *  dict;
        int                             i;

        if ( args.Argc() > 1 ) {
                idAnimator animator;

                classname = args.Argv( 1 );

                dict = gameLocal.FindEntityDefDict( classname, false );
                if ( !dict ) {
                        gameLocal.Printf( "Entitydef '%s' not found\n", classname );
                        return;
                }
                animator.SetModel( dict->GetString( "model" ) );

                gameLocal.Printf( "----------------\n" );
                num = animator.NumAnims();
                for( i = 0; i < num; i++ ) {
                        gameLocal.Printf( "%s\n", animator.AnimFullName( i ) );
                }
                gameLocal.Printf( "%d anims\n", num );
        } else {
                animationLib.ListAnims();

                size = 0;
                num = 0;
                for( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                        animator = ent->GetAnimator();
                        if ( animator ) {
                                alloced = animator->Allocated();
                                size += alloced;
                                num++;
                        }
                }

                gameLocal.Printf( "%d memory used in %d entity animators\n", size, num );
        }
}

/*
==================
Cmd_AASStats_f
==================
*/
static void Cmd_AASStats_f( const idCmdArgs &args ) {
        int aasNum;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        aasNum = aas_test.GetInteger();
        idAAS *aas = gameLocal.GetAAS( aasNum );
        if ( !aas ) {
                gameLocal.Printf( "No aas #%d loaded\n", aasNum );
        } else {
                aas->Stats();
        }
}

/*
==================
Cmd_TestDamage_f
==================
*/
static void Cmd_TestDamage_f( const idCmdArgs &args ) {
        idPlayer *player;
        const char *damageDefName;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() < 2 || args.Argc() > 3 ) {
                gameLocal.Printf( "usage: testDamage <damageDefName> [angle]\n" );
                return;
        }

        damageDefName = args.Argv( 1 );

        idVec3  dir;
        if ( args.Argc() == 3 ) {
                float angle = atof( args.Argv( 2 ) );

                idMath::SinCos( DEG2RAD( angle ), dir[1], dir[0] );
                dir[2] = 0;
        } else {
                dir.Zero();
        }

        // give the player full health before and after
        // running the damage
        player->health = player->inventory.maxHealth;
        player->Damage( NULL, NULL, dir, damageDefName, 1.0f, INVALID_JOINT );
        player->health = player->inventory.maxHealth;
}

/*
==================
Cmd_TestBoneFx_f
==================
*/
static void Cmd_TestBoneFx_f( const idCmdArgs &args ) {
        idPlayer *player;
        const char *bone, *fx;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() < 3 || args.Argc() > 4 ) {
                gameLocal.Printf( "usage: testBoneFx <fxName> <boneName>\n" );
                return;
        }

        fx = args.Argv( 1 );
        bone = args.Argv( 2 );

        player->StartFxOnBone( fx, bone );
}

/*
==================
Cmd_TestDamage_f
==================
*/
static void Cmd_TestDeath_f( const idCmdArgs &args ) {
        idPlayer *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        idVec3 dir;
        idMath::SinCos( DEG2RAD( 45.0f ), dir[1], dir[0] );
        dir[2] = 0;

        g_testDeath.SetBool( 1 );
        player->Damage( NULL, NULL, dir, "damage_triggerhurt_1000", 1.0f, INVALID_JOINT );
        if ( args.Argc() >= 2) {
                player->SpawnGibs( dir, "damage_triggerhurt_1000" );
        }

}

/*
==================
Cmd_WeaponSplat_f
==================
*/
static void Cmd_WeaponSplat_f( const idCmdArgs &args ) {
        idPlayer *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        player->weapon.GetEntity()->BloodSplat( 2.0f );
}

/*
==================
Cmd_SaveSelected_f
==================
*/
static void Cmd_SaveSelected_f( const idCmdArgs &args ) {
        int i;
        idPlayer *player;
        idEntity *s;
        idMapEntity *mapEnt;
        idMapFile *mapFile = gameLocal.GetLevelMap();
        idDict dict;
        idStr mapName;
        const char *name;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        s = player->dragEntity.GetSelected();
        if ( !s ) {
                gameLocal.Printf( "no entity selected, set g_dragShowSelection 1 to show the current selection\n" );
                return;
        }

        if ( args.Argc() > 1 ) {
                mapName = args.Argv( 1 );
                mapName = "maps/" + mapName;
        }
        else {
                mapName = mapFile->GetName();
        }

        // find map file entity
        mapEnt = mapFile->FindEntity( s->name );
        // create new map file entity if there isn't one for this articulated figure
        if ( !mapEnt ) {
                mapEnt = new idMapEntity();
                mapFile->AddEntity( mapEnt );
                for ( i = 0; i < 9999; i++ ) {
                        name = va( "%s_%d", s->GetEntityDefName(), i );
                        if ( !gameLocal.FindEntity( name ) ) {
                                break;
                        }
                }
                s->name = name;
                mapEnt->epairs.Set( "classname", s->GetEntityDefName() );
                mapEnt->epairs.Set( "name", s->name );
        }

        if ( s->IsType( idMoveable::Type ) ) {
                // save the moveable state
                mapEnt->epairs.Set( "origin", s->GetPhysics()->GetOrigin().ToString( 8 ) );
                mapEnt->epairs.Set( "rotation", s->GetPhysics()->GetAxis().ToString( 8 ) );
        }
        else if ( s->IsType( idAFEntity_Generic::Type ) || s->IsType( idAFEntity_WithAttachedHead::Type ) ) {
                // save the articulated figure state
                dict.Clear();
                static_cast<idAFEntity_Base *>(s)->SaveState( dict );
                mapEnt->epairs.Copy( dict );
        }

        // write out the map file
        mapFile->Write( mapName, ".map" );
}

/*
==================
Cmd_DeleteSelected_f
==================
*/
static void Cmd_DeleteSelected_f( const idCmdArgs &args ) {
        idPlayer *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( player ) {
                player->dragEntity.DeleteSelected();
        }
}

/*
==================
Cmd_SaveMoveables_f
==================
*/
static void Cmd_SaveMoveables_f( const idCmdArgs &args ) {
        int e, i;
        idMoveable *m;
        idMapEntity *mapEnt;
        idMapFile *mapFile = gameLocal.GetLevelMap();
        idStr mapName;
        const char *name;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        for( e = 0; e < MAX_GENTITIES; e++ ) {
                m = static_cast<idMoveable *>(gameLocal.entities[ e ]);

                if ( !m || !m->IsType( idMoveable::Type ) ) {
                        continue;
                }

                if ( m->IsBound() ) {
                        continue;
                }

                if ( !m->IsAtRest() ) {
                        break;
                }
        }

        if ( e < MAX_GENTITIES ) {
                gameLocal.Warning( "map not saved because the moveable entity %s is not at rest", gameLocal.entities[ e ]->name.c_str() );
                return;
        }

        if ( args.Argc() > 1 ) {
                mapName = args.Argv( 1 );
                mapName = "maps/" + mapName;
        }
        else {
                mapName = mapFile->GetName();
        }

        for( e = 0; e < MAX_GENTITIES; e++ ) {
                m = static_cast<idMoveable *>(gameLocal.entities[ e ]);

                if ( !m || !m->IsType( idMoveable::Type ) ) {
                        continue;
                }

                if ( m->IsBound() ) {
                        continue;
                }

                // find map file entity
                mapEnt = mapFile->FindEntity( m->name );
                // create new map file entity if there isn't one for this articulated figure
                if ( !mapEnt ) {
                        mapEnt = new idMapEntity();
                        mapFile->AddEntity( mapEnt );
                        for ( i = 0; i < 9999; i++ ) {
                                name = va( "%s_%d", m->GetEntityDefName(), i );
                                if ( !gameLocal.FindEntity( name ) ) {
                                        break;
                                }
                        }
                        m->name = name;
                        mapEnt->epairs.Set( "classname", m->GetEntityDefName() );
                        mapEnt->epairs.Set( "name", m->name );
                }
                // save the moveable state
                mapEnt->epairs.Set( "origin", m->GetPhysics()->GetOrigin().ToString( 8 ) );
                mapEnt->epairs.Set( "rotation", m->GetPhysics()->GetAxis().ToString( 8 ) );
        }

        // write out the map file
        mapFile->Write( mapName, ".map" );
}

/*
==================
Cmd_SaveRagdolls_f
==================
*/
static void Cmd_SaveRagdolls_f( const idCmdArgs &args ) {
        int e, i;
        idAFEntity_Base *af;
        idMapEntity *mapEnt;
        idMapFile *mapFile = gameLocal.GetLevelMap();
        idDict dict;
        idStr mapName;
        const char *name;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() > 1 ) {
                mapName = args.Argv( 1 );
                mapName = "maps/" + mapName;
        }
        else {
                mapName = mapFile->GetName();
        }

        for( e = 0; e < MAX_GENTITIES; e++ ) {
                af = static_cast<idAFEntity_Base *>(gameLocal.entities[ e ]);

                if ( !af ) {
                        continue;
                }

                if ( !af->IsType( idAFEntity_WithAttachedHead::Type ) && !af->IsType( idAFEntity_Generic::Type ) ) {
                        continue;
                }

                if ( af->IsBound() ) {
                        continue;
                }

                if ( !af->IsAtRest() ) {
                        gameLocal.Warning( "the articulated figure for entity %s is not at rest", gameLocal.entities[ e ]->name.c_str() );
                }

                dict.Clear();
                af->SaveState( dict );

                // find map file entity
                mapEnt = mapFile->FindEntity( af->name );
                // create new map file entity if there isn't one for this articulated figure
                if ( !mapEnt ) {
                        mapEnt = new idMapEntity();
                        mapFile->AddEntity( mapEnt );
                        for ( i = 0; i < 9999; i++ ) {
                                name = va( "%s_%d", af->GetEntityDefName(), i );
                                if ( !gameLocal.FindEntity( name ) ) {
                                        break;
                                }
                        }
                        af->name = name;
                        mapEnt->epairs.Set( "classname", af->GetEntityDefName() );
                        mapEnt->epairs.Set( "name", af->name );
                }
                // save the articulated figure state
                mapEnt->epairs.Copy( dict );
        }

        // write out the map file
        mapFile->Write( mapName, ".map" );
}

/*
==================
Cmd_BindRagdoll_f
==================
*/
static void Cmd_BindRagdoll_f( const idCmdArgs &args ) {
        idPlayer *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( player ) {
                player->dragEntity.BindSelected();
        }
}

/*
==================
Cmd_UnbindRagdoll_f
==================
*/
static void Cmd_UnbindRagdoll_f( const idCmdArgs &args ) {
        idPlayer *player;

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( player ) {
                player->dragEntity.UnbindSelected();
        }
}

/*
==================
Cmd_GameError_f
==================
*/
static void Cmd_GameError_f( const idCmdArgs &args ) {
        gameLocal.Error( "game error" );
}

/*
==================
Cmd_SaveLights_f
==================
*/
static void Cmd_SaveLights_f( const idCmdArgs &args ) {
        int e, i;
        idLight *light;
        idMapEntity *mapEnt;
        idMapFile *mapFile = gameLocal.GetLevelMap();
        idDict dict;
        idStr mapName;
        const char *name;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() > 1 ) {
                mapName = args.Argv( 1 );
                mapName = "maps/" + mapName;
        }
        else {
                mapName = mapFile->GetName();
        }

        for( e = 0; e < MAX_GENTITIES; e++ ) {
                light = static_cast<idLight*>(gameLocal.entities[ e ]);

                if ( !light || !light->IsType( idLight::Type ) ) {
                        continue;
                }

                dict.Clear();
                light->SaveState( &dict );

                // find map file entity
                mapEnt = mapFile->FindEntity( light->name );
                // create new map file entity if there isn't one for this light
                if ( !mapEnt ) {
                        mapEnt = new idMapEntity();
                        mapFile->AddEntity( mapEnt );
                        for ( i = 0; i < 9999; i++ ) {
                                name = va( "%s_%d", light->GetEntityDefName(), i );
                                if ( !gameLocal.FindEntity( name ) ) {
                                        break;
                                }
                        }
                        light->name = name;
                        mapEnt->epairs.Set( "classname", light->GetEntityDefName() );
                        mapEnt->epairs.Set( "name", light->name );
                }
                // save the light state
                mapEnt->epairs.Copy( dict );
        }

        // write out the map file
        mapFile->Write( mapName, ".map" );
}


/*
==================
Cmd_SaveParticles_f
==================
*/
static void Cmd_SaveParticles_f( const idCmdArgs &args ) {
        int e;
        idEntity *ent;
        idMapEntity *mapEnt;
        idMapFile *mapFile = gameLocal.GetLevelMap();
        idDict dict;
        idStr mapName, strModel;

        if ( !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() > 1 ) {
                mapName = args.Argv( 1 );
                mapName = "maps/" + mapName;
        }
        else {
                mapName = mapFile->GetName();
        }

        for( e = 0; e < MAX_GENTITIES; e++ ) {

                ent = static_cast<idStaticEntity*> ( gameLocal.entities[ e ] );

                if ( !ent ) {
                        continue;
                }

                strModel = ent->spawnArgs.GetString( "model" );
                if ( strModel.Length() && strModel.Find( ".prt") > 0 ) {
                        dict.Clear();
                        dict.Set( "model", ent->spawnArgs.GetString( "model" ) );
                        dict.SetVector( "origin", ent->GetPhysics()->GetOrigin() );

                        // find map file entity
                        mapEnt = mapFile->FindEntity( ent->name );
                        // create new map file entity if there isn't one for this entity
                        if ( !mapEnt ) {
                                continue;
                        }
                        // save the particle state
                        mapEnt->epairs.Copy( dict );
                }
        }

        // write out the map file
        mapFile->Write( mapName, ".map" );
}


/*
==================
Cmd_DisasmScript_f
==================
*/
static void Cmd_DisasmScript_f( const idCmdArgs &args ) {
        gameLocal.program.Disassemble();
}

/*
==================
Cmd_TestSave_f
==================
*/
static void Cmd_TestSave_f( const idCmdArgs &args ) {
        idFile *f;

        f = fileSystem->OpenFileWrite( "test.sav" );
        gameLocal.SaveGame( f );
        fileSystem->CloseFile( f );
}

/*
==================
Cmd_RecordViewNotes_f
==================
*/
static void Cmd_RecordViewNotes_f( const idCmdArgs &args ) {
        idPlayer *player;
        idVec3 origin;
        idMat3 axis;

        if ( args.Argc() <= 3 ) {
                return;
        }

        player = gameLocal.GetLocalPlayer();
        if ( !player ) {
                return;
        }

        player->GetViewPos( origin, axis );

        // Argv(1) = filename for map (viewnotes/mapname/person)
        // Argv(2) = note number (person0001)
        // Argv(3) = comments

        idStr str = args.Argv(1);
        str.SetFileExtension( ".txt" );

#ifdef _D3XP
        idFile *file = fileSystem->OpenFileAppend( str, false, "fs_cdpath" );
#else
        idFile *file = fileSystem->OpenFileAppend( str );
#endif

        if ( file ) {
                file->WriteFloatString( "\"view\"\t( %s )\t( %s )\r\n", origin.ToString(), axis.ToString() );
                file->WriteFloatString( "\"comments\"\t\"%s: %s\"\r\n\r\n", args.Argv(2), args.Argv(3) );
                fileSystem->CloseFile( file );
        }

        idStr viewComments = args.Argv(1);
        viewComments.StripLeading("viewnotes/");
        viewComments += " -- Loc: ";
        viewComments += origin.ToString();
        viewComments += "\n";
        viewComments += args.Argv(3);
        player->hud->SetStateString( "viewcomments", viewComments );
        player->hud->HandleNamedEvent( "showViewComments" );
}

/*
==================
Cmd_CloseViewNotes_f
==================
*/
static void Cmd_CloseViewNotes_f( const idCmdArgs &args ) {
        idPlayer *player = gameLocal.GetLocalPlayer();

        if ( !player ) {
                return;
        }
        
        player->hud->SetStateString( "viewcomments", "" );
        player->hud->HandleNamedEvent( "hideViewComments" );
}

/*
==================
Cmd_ShowViewNotes_f
==================
*/
static void Cmd_ShowViewNotes_f( const idCmdArgs &args ) {
        static idLexer parser( LEXFL_ALLOWPATHNAMES | LEXFL_NOSTRINGESCAPECHARS | LEXFL_NOSTRINGCONCAT | LEXFL_NOFATALERRORS );
        idToken token;
        idPlayer *player;
        idVec3 origin;
        idMat3 axis;

        player = gameLocal.GetLocalPlayer();

        if ( !player ) {
                return;
        }

        if ( !parser.IsLoaded() ) {
                idStr str = "viewnotes/";
                str += gameLocal.GetMapName();
                str.StripFileExtension();
                str += "/";
                if ( args.Argc() > 1 ) {
                        str += args.Argv( 1 );
                } else {
                        str += "comments";
                }
                str.SetFileExtension( ".txt" );
                if ( !parser.LoadFile( str ) ) {
                        gameLocal.Printf( "No view notes for %s\n", gameLocal.GetMapName() );
                        return;
                }
        }

        if ( parser.ExpectTokenString( "view" ) && parser.Parse1DMatrix( 3, origin.ToFloatPtr() ) && 
                parser.Parse1DMatrix( 9, axis.ToFloatPtr() ) && parser.ExpectTokenString( "comments" ) && parser.ReadToken( &token ) ) {
                player->hud->SetStateString( "viewcomments", token );
                player->hud->HandleNamedEvent( "showViewComments" );
                player->Teleport( origin, axis.ToAngles(), NULL );
        } else {
                parser.FreeSource();
                player->hud->HandleNamedEvent( "hideViewComments" );
                return;
        }
}

/*
=================
FindEntityGUIs

helper function for Cmd_NextGUI_f.  Checks the passed entity to determine if it
has any valid gui surfaces.
=================
*/
bool FindEntityGUIs( idEntity *ent, const modelSurface_t ** surfaces,  int maxSurfs, int &guiSurfaces ) {
        renderEntity_t                  *renderEnt;
        idRenderModel                   *renderModel;
        const modelSurface_t    *surf;
        const idMaterial                *shader;
        int                                             i;

        assert( surfaces != NULL );
        assert( ent != NULL );

        memset( surfaces, 0x00, sizeof( modelSurface_t *) * maxSurfs );
        guiSurfaces = 0;

        renderEnt  = ent->GetRenderEntity();
        renderModel = renderEnt->hModel;
        if ( renderModel == NULL ) {
                return false;
        }

        for( i = 0; i < renderModel->NumSurfaces(); i++ ) {
                surf = renderModel->Surface( i );
                if ( surf == NULL ) {
                        continue;
                }
                shader = surf->shader;
                if ( shader == NULL ) {
                        continue;
                }
                if ( shader->GetEntityGui() > 0 ) {
                        surfaces[ guiSurfaces++ ] = surf;
                }
        }

        return ( guiSurfaces != 0 );
}

/*
=================
Cmd_NextGUI_f
=================
*/
void Cmd_NextGUI_f( const idCmdArgs &args ) {
        idVec3                                  origin;
        idAngles                                angles;
        idPlayer                                *player;
        idEntity                                *ent;
        int                                             guiSurfaces;
        bool                                    newEnt;
        renderEntity_t                  *renderEnt;
        int                                             surfIndex;
        srfTriangles_t                  *geom;
        idMat4                                  modelMatrix;
        idVec3                                  normal;
        idVec3                                  center;
        const modelSurface_t    *surfaces[ MAX_RENDERENTITY_GUI ];

        player = gameLocal.GetLocalPlayer();
        if ( !player || !gameLocal.CheatsOk() ) {
                return;
        }

        if ( args.Argc() != 1 ) {
                gameLocal.Printf( "usage: nextgui\n" );
                return;
        }

        // start at the last entity
        ent = gameLocal.lastGUIEnt.GetEntity();

        // see if we have any gui surfaces left to go to on the current entity.
        guiSurfaces = 0;
        newEnt = false;
        if ( ent == NULL ) {
                newEnt = true;
        } else if ( FindEntityGUIs( ent, surfaces, MAX_RENDERENTITY_GUI, guiSurfaces ) == true ) {
                if ( gameLocal.lastGUI >= guiSurfaces ) {
                        newEnt = true;
                }
        } else {
                // no actual gui surfaces on this ent, so skip it
                newEnt = true;
        }

        if ( newEnt == true ) {
                // go ahead and skip to the next entity with a gui...
                if ( ent == NULL ) {
                        ent = gameLocal.spawnedEntities.Next();
                } else {
                        ent = ent->spawnNode.Next();
                }

                for ( ; ent != NULL; ent = ent->spawnNode.Next() ) {
                        if ( ent->spawnArgs.GetString( "gui", NULL ) != NULL ) {
                                break;
                        }
                        
                        if ( ent->spawnArgs.GetString( "gui2", NULL ) != NULL ) {
                                break;
                        }

                        if ( ent->spawnArgs.GetString( "gui3", NULL ) != NULL ) {
                                break;
                        }
                        
                        // try the next entity
                        gameLocal.lastGUIEnt = ent;
                }

                gameLocal.lastGUIEnt = ent;
                gameLocal.lastGUI = 0;

                if ( !ent ) {
                        gameLocal.Printf( "No more gui entities. Starting over...\n" );
                        return;
                }
        }

        if ( FindEntityGUIs( ent, surfaces, MAX_RENDERENTITY_GUI, guiSurfaces ) == false ) {
                gameLocal.Printf( "Entity \"%s\" has gui properties but no gui surfaces.\n", ent->name.c_str() );
        }

        if ( guiSurfaces == 0 ) {
                gameLocal.Printf( "Entity \"%s\" has gui properties but no gui surfaces!\n", ent->name.c_str() );
                return;
        }

        gameLocal.Printf( "Teleporting to gui entity \"%s\", gui #%d.\n" , ent->name.c_str (), gameLocal.lastGUI );

        renderEnt = ent->GetRenderEntity();
        surfIndex = gameLocal.lastGUI++;
        geom = surfaces[ surfIndex ]->geometry;
        if ( geom == NULL ) {
                gameLocal.Printf( "Entity \"%s\" has gui surface %d without geometry!\n", ent->name.c_str(), surfIndex );
                return;
        }

        assert( geom->facePlanes != NULL );

        modelMatrix = idMat4( renderEnt->axis, renderEnt->origin );     
        normal = geom->facePlanes[ 0 ].Normal() * renderEnt->axis;
        center = geom->bounds.GetCenter() * modelMatrix;

        origin = center + (normal * 32.0f);
        origin.z -= player->EyeHeight();
        normal *= -1.0f;
        angles = normal.ToAngles ();

        //      make sure the player is in noclip
        player->noclip = true;
        player->Teleport( origin, angles, NULL );
}

#ifdef _D3XP
void Cmd_SetActorState_f( const idCmdArgs &args ) {

        if ( args.Argc() != 3 ) {
                common->Printf( "usage: setActorState <entity name> <state>\n" );
                return;
        }

        idEntity* ent;
        ent = gameLocal.FindEntity( args.Argv( 1 ) );
        if ( !ent ) {
                gameLocal.Printf( "entity not found\n" );
                return;
        }

        
        if(!ent->IsType(idActor::Type)) {
                gameLocal.Printf( "entity not an actor\n" );
                return;
        }

        idActor* actor = (idActor*)ent;
        actor->PostEventMS(&AI_SetState, 0, args.Argv(2));
}
#endif

static void ArgCompletion_DefFile( const idCmdArgs &args, void(*callback)( const char *s ) ) {
        cmdSystem->ArgCompletion_FolderExtension( args, callback, "def/", true, ".def", NULL );
}

/*
===============
Cmd_TestId_f
outputs a string from the string table for the specified id
===============
*/
void Cmd_TestId_f( const idCmdArgs &args ) {
        idStr   id;
        int             i;
        if ( args.Argc() == 1 ) {
                common->Printf( "usage: testid <string id>\n" );
                return;
        }

        for ( i = 1; i < args.Argc(); i++ ) {
                id += args.Argv( i );
        }
        if ( idStr::Cmpn( id, STRTABLE_ID, STRTABLE_ID_LENGTH ) != 0 ) {
                id = STRTABLE_ID + id;
        }
        gameLocal.mpGame.AddChatLine( common->GetLanguageDict()->GetString( id ), "<nothing>", "<nothing>", "<nothing>" );      
}

/*
=================
idGameLocal::InitConsoleCommands

Let the system know about all of our commands
so it can perform tab completion
=================
*/
void idGameLocal::InitConsoleCommands( void ) {
        cmdSystem->AddCommand( "listTypeInfo",                  ListTypeInfo_f,                         CMD_FL_GAME,                            "list type info" );
        cmdSystem->AddCommand( "writeGameState",                WriteGameState_f,                       CMD_FL_GAME,                            "write game state" );
        cmdSystem->AddCommand( "testSaveGame",                  TestSaveGame_f,                         CMD_FL_GAME|CMD_FL_CHEAT,       "test a save game for a level" );
        cmdSystem->AddCommand( "game_memory",                   idClass::DisplayInfo_f,         CMD_FL_GAME,                            "displays game class info" );
        cmdSystem->AddCommand( "listClasses",                   idClass::ListClasses_f,         CMD_FL_GAME,                            "lists game classes" );
        cmdSystem->AddCommand( "listThreads",                   idThread::ListThreads_f,        CMD_FL_GAME|CMD_FL_CHEAT,       "lists script threads" );
        cmdSystem->AddCommand( "listEntities",                  Cmd_EntityList_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "lists game entities" );
        cmdSystem->AddCommand( "listActiveEntities",    Cmd_ActiveEntityList_f,         CMD_FL_GAME|CMD_FL_CHEAT,       "lists active game entities" );
        cmdSystem->AddCommand( "listMonsters",                  idAI::List_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "lists monsters" );
        cmdSystem->AddCommand( "listSpawnArgs",                 Cmd_ListSpawnArgs_f,            CMD_FL_GAME|CMD_FL_CHEAT,       "list the spawn args of an entity", idGameLocal::ArgCompletion_EntityName );
        cmdSystem->AddCommand( "say",                                   Cmd_Say_f,                                      CMD_FL_GAME,                            "text chat" );
        cmdSystem->AddCommand( "sayTeam",                               Cmd_SayTeam_f,                          CMD_FL_GAME,                            "team text chat" );
        cmdSystem->AddCommand( "addChatLine",                   Cmd_AddChatLine_f,                      CMD_FL_GAME,                            "internal use - core to game chat lines" );
        cmdSystem->AddCommand( "gameKick",                              Cmd_Kick_f,                                     CMD_FL_GAME,                            "same as kick, but recognizes player names" );
        cmdSystem->AddCommand( "give",                                  Cmd_Give_f,                                     CMD_FL_GAME|CMD_FL_CHEAT,       "gives one or more items" );
        cmdSystem->AddCommand( "centerview",                    Cmd_CenterView_f,                       CMD_FL_GAME,                            "centers the view" );
        cmdSystem->AddCommand( "god",                                   Cmd_God_f,                                      CMD_FL_GAME|CMD_FL_CHEAT,       "enables god mode" );
        cmdSystem->AddCommand( "notarget",                              Cmd_Notarget_f,                         CMD_FL_GAME|CMD_FL_CHEAT,       "disables the player as a target" );
        cmdSystem->AddCommand( "noclip",                                Cmd_Noclip_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "disables collision detection for the player" );
        cmdSystem->AddCommand( "kill",                                  Cmd_Kill_f,                                     CMD_FL_GAME,                            "kills the player" );
        cmdSystem->AddCommand( "where",                                 Cmd_GetViewpos_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "prints the current view position" );
        cmdSystem->AddCommand( "getviewpos",                    Cmd_GetViewpos_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "prints the current view position" );
        cmdSystem->AddCommand( "setviewpos",                    Cmd_SetViewpos_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "sets the current view position" );
        cmdSystem->AddCommand( "teleport",                              Cmd_Teleport_f,                         CMD_FL_GAME|CMD_FL_CHEAT,       "teleports the player to an entity location", idGameLocal::ArgCompletion_EntityName );
        cmdSystem->AddCommand( "trigger",                               Cmd_Trigger_f,                          CMD_FL_GAME|CMD_FL_CHEAT,       "triggers an entity", idGameLocal::ArgCompletion_EntityName );
        cmdSystem->AddCommand( "spawn",                                 Cmd_Spawn_f,                            CMD_FL_GAME|CMD_FL_CHEAT,       "spawns a game entity", idCmdSystem::ArgCompletion_Decl<DECL_ENTITYDEF> );
        cmdSystem->AddCommand( "damage",                                Cmd_Damage_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "apply damage to an entity", idGameLocal::ArgCompletion_EntityName );
        cmdSystem->AddCommand( "remove",                                Cmd_Remove_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "removes an entity", idGameLocal::ArgCompletion_EntityName );
        cmdSystem->AddCommand( "killMonsters",                  Cmd_KillMonsters_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "removes all monsters" );
        cmdSystem->AddCommand( "killMoveables",                 Cmd_KillMovables_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "removes all moveables" );
        cmdSystem->AddCommand( "killRagdolls",                  Cmd_KillRagdolls_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "removes all ragdolls" );
        cmdSystem->AddCommand( "addline",                               Cmd_AddDebugLine_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "adds a debug line" );
        cmdSystem->AddCommand( "addarrow",                              Cmd_AddDebugLine_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "adds a debug arrow" );
        cmdSystem->AddCommand( "removeline",                    Cmd_RemoveDebugLine_f,          CMD_FL_GAME|CMD_FL_CHEAT,       "removes a debug line" );
        cmdSystem->AddCommand( "blinkline",                             Cmd_BlinkDebugLine_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "blinks a debug line" );
        cmdSystem->AddCommand( "listLines",                             Cmd_ListDebugLines_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "lists all debug lines" );
        cmdSystem->AddCommand( "playerModel",                   Cmd_PlayerModel_f,                      CMD_FL_GAME|CMD_FL_CHEAT,       "sets the given model on the player", idCmdSystem::ArgCompletion_Decl<DECL_MODELDEF> );
        cmdSystem->AddCommand( "testFx",                                Cmd_TestFx_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "tests an FX system", idCmdSystem::ArgCompletion_Decl<DECL_FX> );
        cmdSystem->AddCommand( "testBoneFx",                    Cmd_TestBoneFx_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "tests an FX system bound to a joint", idCmdSystem::ArgCompletion_Decl<DECL_FX> );
        cmdSystem->AddCommand( "testLight",                             Cmd_TestLight_f,                        CMD_FL_GAME|CMD_FL_CHEAT,       "tests a light" );
        cmdSystem->AddCommand( "testPointLight",                Cmd_TestPointLight_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "tests a point light" );
        cmdSystem->AddCommand( "popLight",                              Cmd_PopLight_f,                         CMD_FL_GAME|CMD_FL_CHEAT,       "removes the last created light" );
        cmdSystem->AddCommand( "testDeath",                             Cmd_TestDeath_f,                        CMD_FL_GAME|CMD_FL_CHEAT,       "tests death" );
        cmdSystem->AddCommand( "testSave",                              Cmd_TestSave_f,                         CMD_FL_GAME|CMD_FL_CHEAT,       "writes out a test savegame" );
        cmdSystem->AddCommand( "testModel",                             idTestModel::TestModel_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "tests a model", idTestModel::ArgCompletion_TestModel );
        cmdSystem->AddCommand( "testSkin",                              idTestModel::TestSkin_f,                        CMD_FL_GAME|CMD_FL_CHEAT,       "tests a skin on an existing testModel", idCmdSystem::ArgCompletion_Decl<DECL_SKIN> );
        cmdSystem->AddCommand( "testShaderParm",                idTestModel::TestShaderParm_f,          CMD_FL_GAME|CMD_FL_CHEAT,       "sets a shaderParm on an existing testModel" );
        cmdSystem->AddCommand( "keepTestModel",                 idTestModel::KeepTestModel_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "keeps the last test model in the game" );
        cmdSystem->AddCommand( "testAnim",                              idTestModel::TestAnim_f,                        CMD_FL_GAME|CMD_FL_CHEAT,       "tests an animation", idTestModel::ArgCompletion_TestAnim );
        cmdSystem->AddCommand( "testParticleStopTime",  idTestModel::TestParticleStopTime_f,CMD_FL_GAME|CMD_FL_CHEAT,   "tests particle stop time on a test model" );
        cmdSystem->AddCommand( "nextAnim",                              idTestModel::TestModelNextAnim_f,       CMD_FL_GAME|CMD_FL_CHEAT,       "shows next animation on test model" );
        cmdSystem->AddCommand( "prevAnim",                              idTestModel::TestModelPrevAnim_f,       CMD_FL_GAME|CMD_FL_CHEAT,       "shows previous animation on test model" );
        cmdSystem->AddCommand( "nextFrame",                             idTestModel::TestModelNextFrame_f,      CMD_FL_GAME|CMD_FL_CHEAT,       "shows next animation frame on test model" );
        cmdSystem->AddCommand( "prevFrame",                             idTestModel::TestModelPrevFrame_f,      CMD_FL_GAME|CMD_FL_CHEAT,       "shows previous animation frame on test model" );
        cmdSystem->AddCommand( "testBlend",                             idTestModel::TestBlend_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "tests animation blending" );
        cmdSystem->AddCommand( "reloadScript",                  Cmd_ReloadScript_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "reloads scripts" );
        cmdSystem->AddCommand( "script",                                Cmd_Script_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "executes a line of script" );
        cmdSystem->AddCommand( "listCollisionModels",   Cmd_ListCollisionModels_f,      CMD_FL_GAME,                            "lists collision models" );
        cmdSystem->AddCommand( "collisionModelInfo",    Cmd_CollisionModelInfo_f,       CMD_FL_GAME,                            "shows collision model info" );
        cmdSystem->AddCommand( "reexportmodels",                Cmd_ReexportModels_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "reexports models", ArgCompletion_DefFile );
        cmdSystem->AddCommand( "reloadanims",                   Cmd_ReloadAnims_f,                      CMD_FL_GAME|CMD_FL_CHEAT,       "reloads animations" );
        cmdSystem->AddCommand( "listAnims",                             Cmd_ListAnims_f,                        CMD_FL_GAME,                            "lists all animations" );
        cmdSystem->AddCommand( "aasStats",                              Cmd_AASStats_f,                         CMD_FL_GAME,                            "shows AAS stats" );
        cmdSystem->AddCommand( "testDamage",                    Cmd_TestDamage_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "tests a damage def", idCmdSystem::ArgCompletion_Decl<DECL_ENTITYDEF> );
        cmdSystem->AddCommand( "weaponSplat",                   Cmd_WeaponSplat_f,                      CMD_FL_GAME|CMD_FL_CHEAT,       "projects a blood splat on the player weapon" );
        cmdSystem->AddCommand( "saveSelected",                  Cmd_SaveSelected_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "saves the selected entity to the .map file" );
        cmdSystem->AddCommand( "deleteSelected",                Cmd_DeleteSelected_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "deletes selected entity" );
        cmdSystem->AddCommand( "saveMoveables",                 Cmd_SaveMoveables_f,            CMD_FL_GAME|CMD_FL_CHEAT,       "save all moveables to the .map file" );
        cmdSystem->AddCommand( "saveRagdolls",                  Cmd_SaveRagdolls_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "save all ragdoll poses to the .map file" );
        cmdSystem->AddCommand( "bindRagdoll",                   Cmd_BindRagdoll_f,                      CMD_FL_GAME|CMD_FL_CHEAT,       "binds ragdoll at the current drag position" );
        cmdSystem->AddCommand( "unbindRagdoll",                 Cmd_UnbindRagdoll_f,            CMD_FL_GAME|CMD_FL_CHEAT,       "unbinds the selected ragdoll" );
        cmdSystem->AddCommand( "saveLights",                    Cmd_SaveLights_f,                       CMD_FL_GAME|CMD_FL_CHEAT,       "saves all lights to the .map file" );
        cmdSystem->AddCommand( "saveParticles",                 Cmd_SaveParticles_f,            CMD_FL_GAME|CMD_FL_CHEAT,       "saves all lights to the .map file" );
        cmdSystem->AddCommand( "clearLights",                   Cmd_ClearLights_f,                      CMD_FL_GAME|CMD_FL_CHEAT,       "clears all lights" );
        cmdSystem->AddCommand( "gameError",                             Cmd_GameError_f,                        CMD_FL_GAME|CMD_FL_CHEAT,       "causes a game error" );

#ifndef ID_DEMO_BUILD
        cmdSystem->AddCommand( "disasmScript",                  Cmd_DisasmScript_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "disassembles script" );
        cmdSystem->AddCommand( "recordViewNotes",               Cmd_RecordViewNotes_f,          CMD_FL_GAME|CMD_FL_CHEAT,       "record the current view position with notes" );
        cmdSystem->AddCommand( "showViewNotes",                 Cmd_ShowViewNotes_f,            CMD_FL_GAME|CMD_FL_CHEAT,       "show any view notes for the current map, successive calls will cycle to the next note" );
        cmdSystem->AddCommand( "closeViewNotes",                Cmd_CloseViewNotes_f,           CMD_FL_GAME|CMD_FL_CHEAT,       "close the view showing any notes for this map" );
        cmdSystem->AddCommand( "exportmodels",                  Cmd_ExportModels_f,                     CMD_FL_GAME|CMD_FL_CHEAT,       "exports models", ArgCompletion_DefFile );

        // multiplayer client commands ( replaces old impulses stuff )
        cmdSystem->AddCommand( "clientDropWeapon",              idMultiplayerGame::DropWeapon_f, CMD_FL_GAME,                   "drop current weapon" );
        cmdSystem->AddCommand( "clientMessageMode",             idMultiplayerGame::MessageMode_f, CMD_FL_GAME,                  "ingame gui message mode" );
        // FIXME: implement
//      cmdSystem->AddCommand( "clientVote",                    idMultiplayerGame::Vote_f,      CMD_FL_GAME,                            "cast your vote: clientVote yes | no" );
//      cmdSystem->AddCommand( "clientCallVote",                idMultiplayerGame::CallVote_f,  CMD_FL_GAME,                    "call a vote: clientCallVote si_.. proposed_value" );
        cmdSystem->AddCommand( "clientVoiceChat",               idMultiplayerGame::VoiceChat_f, CMD_FL_GAME,                    "voice chats: clientVoiceChat <sound shader>" );
        cmdSystem->AddCommand( "clientVoiceChatTeam",   idMultiplayerGame::VoiceChatTeam_f,     CMD_FL_GAME,            "team voice chats: clientVoiceChat <sound shader>" );

        // multiplayer server commands
        cmdSystem->AddCommand( "serverMapRestart",              idGameLocal::MapRestart_f,      CMD_FL_GAME,                            "restart the current game" );
        cmdSystem->AddCommand( "serverForceReady",      idMultiplayerGame::ForceReady_f,CMD_FL_GAME,                            "force all players ready" );
        cmdSystem->AddCommand( "serverNextMap",                 idGameLocal::NextMap_f,         CMD_FL_GAME,                            "change to the next map" );
#endif

        // localization help commands
        cmdSystem->AddCommand( "nextGUI",                               Cmd_NextGUI_f,                          CMD_FL_GAME|CMD_FL_CHEAT,       "teleport the player to the next func_static with a gui" );
        cmdSystem->AddCommand( "testid",                                Cmd_TestId_f,                           CMD_FL_GAME|CMD_FL_CHEAT,       "output the string for the specified id." );

#ifdef _D3XP
        cmdSystem->AddCommand( "setActorState",                 Cmd_SetActorState_f,            CMD_FL_GAME|CMD_FL_CHEAT,       "Manually sets an actors script state", idGameLocal::ArgCompletion_EntityName );
#endif
}

/*
=================
idGameLocal::ShutdownConsoleCommands
=================
*/
void idGameLocal::ShutdownConsoleCommands( void ) {
        cmdSystem->RemoveFlaggedCommands( CMD_FL_GAME );
}