
                          Unreal Console Commands

Command Line Parameters

                      -profile: When C++ is compiled with DO_SLOW_GUARD=1, generates an
                                UnrealScript function profile using the timings in the
                                most recently played level only.
                      -nosound: Disables sound.
                     -nodsound: Disables DirectSound support.
                      -noddraw: Disables DirectDraw support.
                       -nohard: Disables 3d hardware support.
                          -log: Runs with the log window initially visible.
                     -firstrun: Re-asks the "First Run" questions in Unreal.
                     -nologwin: Don't output to log window, useful for debugging when
                                printing so many log messages that performance is slowed
                                down by window updates.
                    -conflicts: Show objects of different classes whose names conflict.
                         -nok6: Disable AMD K6-3D support.
                        -nommx: Disables MMX support.
                    -noreplace: Don't automatically replace textures, sounds, and music if
                                they are not found.
                         -make: Rebuilds all .u files from their source .uc files.
                      -make -h: Rebuilds all .u files from their source .uc files and
                                generate a C++ header for each package.
                       -editor: Runs Unreal for editing.
                       -server: Runs as a dedicated server.
                       -strict: Treat all script warnings as critical errors; useful for
                                tracking down the call stack when debugging scripts.
                       -nobind: Don't treat UnrealScript/C++ binding errors as critical,
                                for rebuilding scripts and avoiding the chicken-and-egg
                                binding problem.
                      -showdep: Causes script compiler to log dependency information when
                                recompiling scripts.
                         -nogc: Disables garbage collection.
                     -alladmin: Enable all players administrative access to the server.
               LOG=logfilename: Uses the specified log file instead of Unreal.log.
                                Useful  when running multiple copies on the same
                                machine.
               INI=inifilename: Sets the .ini file to use for configuration,
                                normally Unreal.ini.
           READINI=inifilename: Sets the .ini file for reading only (not for
                                writing); overrides the INI= option.
                      PORT=num: Sets the UDP port number for the Internet server.
         MULTIHOME=12.34.56.78: Sets the "home" ip address (in numerical format)
                                for Unreal of a machine with multiple network cards.

C++ Console Commands (Only works on the local machine)

                    BRIGHTNESS: Cycle through 10 screen brightness values.
                          CHAT: Brings up a prompt to type chat text.
                        CANCEL: Cancels an "open" command in progress that is
                                trying to connect to a network server.
                   CDTRACK num: Play the specified CD track.
                  CONSOLE FULL: Make the console fullscreen.
                  CONSOLE HIDE: Hide the console.
                  CONSOLE SHOW: Show the console.
                   DEBUG CRASH: Test crashing the game by appError.
                  DEBUG EATMEM: Test allocating memory until it fills up.
                     DEBUG GPF: Test a general protection fault.
                 DEBUG RECURSE: Test crash by infinite recursion.
                     DUMPCACHE: Display the contents of the memory cache GCache.
                DUMPINTRINSICS: Display a list of unused intrinsic function ids.
     EDITACTOR CLASS=classname: During game play, edits the properties of the
                                nearest actor belonging to that class. Cool for
                                debugging.
                 ENDFULLSCREEN: Go back to playing in a window.
                 EXEC filename: Execute the console commands in the filename,
                                default is in the System directory.
                          EXIT: Exit the program.
                         FLUSH: Flush all caches. Regenerates all lighting, 3d
                                hardware textures, etc.
                    HIDEACTORS: Hide actors during game play.
                  JUMPTO x y z: In UnrealEd, move the viewport to a certain X,Y,Z
                                location, useful in conjunction with tester reports
                            generated with the REPORT command.
                  LOADGAME num: Load a game in position 0-9.
                          MARK: Mark all objects that are in memory (for garbage
                                collection debugging in conjunction with MARKCHECK).
                     MARKCHECK: Display a list of all unmarked objects that are in
                                memory (for garbage collection debugging in conjunction
                                with MARK).
                           MEM: List memory usage; only works when Unreal is compiled
                                with the memory-tracking option (it's usually not).
                       MEMSTAT: Show Windows overall memory statistics.
                MUSICORDER num: Change to a certain track in the song (0=ambient,
                                1=action, 2=suspense).
                   OBJ CLASSES: Prints a list of all loaded classes.
OBJ DEPENDENCIES PACKAGE=pkgname EXCLUDE1=otherpackage
  EXCLUDE2=otherpackage...: !!
                   OBJ GARBAGE: Collect and purge garbage ("garbage" means
                                objects which are no longer in use).
                      OBJ HASH: Show object hashing statistics.
    OBJ LIST CLASS=objectclass: List all objects belonging to the class
                                (if the class isn't specified, lists ALL
                                objects).  Gives a summary of memory usage.
                                This is very useful during game play for
                                figuring out how much memory is being used.
                                In UnrealEd, this statistic isn't useful
                                because a huge amount of extra stuff is
                                loaded which might not be used by your map.
OBJ REFS CLASS=objectclass NAME=objectname: Show a list of objects which reference
                                the object you specify.  When trimming
                                memory usage, this is useful for figuring
                                out why some object is being loaded.
                      OPEN url: Opens a local map (i.e. "unreal.unr") or an
                                Internet server (i.e. "200.0.1.16" or
                                "unreal.epicgames.com").
                   PREFERENCES: Displays the preferences in a window.
                        REPORT: Copies a report of the current gameplay
                                situation to the clipboard. You can then
                                paste the resulting text into an email
                                program, Notepad, etc. Extremely useful
                                for beta testers, because it dumps the
                                player's X,Y,Z location, the difficulty
                                level, etc.
                         RMODE: Set the rendering mode. 0-9.
                  SAVEGAME num: Save the game in a specified position, 0-9.
                          SHOT: Take a screenshot and save it in the System
                                directory with a consecutive name like
                                Shot0001.bmp.
                    SHOWACTORS: Shows actors during gameplay.
                       SOCKETS: In network play, shows a list of network
                                sockets (UNetConnection's) in use.
                    STAT ACTOR: Shows various statistics.                STAT CACHE
                                STAT CLIP
                                STAT FILTER
                                STAT FPS
                                STAT GAME
                                STAT GLOBAL
                                STAT HARDWARE
                                STAT ILLUM
                                STAT LIGHT
                                STAT MESH
                                STAT POLYC
                                STAT POLYV
                                STAT REJECT
                                STAT OCCLUSION
                                STAT SOFT
                                STAT SPAN
                                STAT ZONE
              TOGGLEFULLSCREEN: Toggles fullscreen mode on and off.
                          TYPE: Types text on the console.
                   URL urlname: In network play, parses a URL and displays
                                its components.
                        VIEWUP: Sizes the view up.
                      VIEWDOWN: Sizes the view down.

UnrealScript console commands (Can be used by remote administrators)

               ADDBOTS <number>: Adds more bots to the game.
                        ALLAMMO: Gives you all the ammo for your current weapons.
                            GOD: Makes you invincible.
                      INVISIBLE: Makes you invisible.
           KILLALL <class name>: Kills all actors of a certain class, for example
                                 "KILLALL UNREALI.BRUTE".
                      KILLPAWNS: Kills all monsters.
                    PLAYERSONLY: Pauses all non-player actors in the game. Cool for
                                 debugging scripts, taking screenshots.
           SAY <message string>: Broadcast a message to other players in the game.
                 SLOMO <number>: Sets the game speed, 1.0 is normal.
            SUMMON <class name>: Spawns an actor of the specified class (for example,
                                 SUMMON UNREALI.BRUTE) in front of the player.
SWITCHCOOPLEVEL <new level URL>: Causes the server (or local machine, in a
                                 single-player game) to switch to a new level with
                                 coop-style weapon carrying between levels.
    SWITCHLEVEL <new level URL>: Causes the server (or local machine, in a
                                 single-player game) to switch to a new level.

Console configuration commands

    GET <classname> <variablename>
Gets a configurable class parameter.  <classname> may be a partial classname,
such as "playerpawn", or a qualified classname such as "engine.playerpawn".  The
class must be loaded in memory, otherwise GET returns an empty string.
<variablename> must be the name of a variable that is designated as configurable
(either in UnrealScript using the "config" keyword or in C++ using CPF_Config).
This returns the value of the configured variable, converted to a string.  The
value returned by GET reflects the class's default value (for scripted classes,
this is the default value that was set for the class using its property sheet).
At any time, zero or more instances of objects belonging to <classname> may be
in memory, and may have modified values of <variablename>, and they don't affect
the value returned by "GET".

    SET <classname> <variablename> <value>
Sets the default value of a class's variable.  If the class is designated as
configurable (using the "config" keyword in UnrealScript or CLASS_Config in
C++), and so is the variable, this function updates the Unreal.ini file to
reflect the new default value. If any instances of objects belonging to
<classname> are in memory, all of those objects are updated.  When an object's
config variables are updated, they are notified as follows:
    The object's PreEditChange() function is called, basically saying "Get ready
    to be modified!"
    The object's configurable variables are updated with the newly configured
    values.
    The object's PostEditChange() function is called, saying "You've been
    modified, so validate and update yourself".
This procedure enables objects to validate their configurable properties and
update themselves.  For example, the audio subsystem's PostEditChange() function
clamps the sound volume to a safe range of 0.0 - 1.0 (because the SET command
enables users to set it to ridiculous values) and then updates the actual volume
of the sound effects that are playing.
