Legacy:GameInfo

See GameInfo_(UT) for the UT version of this class.

The GameInfo defines the game being played: the game rules, scoring, what actors are allowed to exist in this game type, and who may enter the game. While the GameInfo class is the public interface, much of this functionality is delegated to several classes to allow easy modification of specific game components. These classes include GameInfo, AccessControl, Mutator, BroadcastHandler, and GameRules. A GameInfo actor is instantiated when the level is initialized for gameplay (in C++ UGameEngine::LoadMap( ) ). The class of this GameInfo actor is determined by (in order):

the DefaultGameType is specified in the LevelInfo
the DefaultGame entry in the game ini file (in the Engine.Engine section), unless it's a network game in which case the DefaultServerGame entry is used.

Structs[edit]

KeyValuePair[edit]

Contains a string key with a corresponding string value.

string Key
string Value

PlayerResponseLine (native export)[edit]

Contains information about the player,

int PlayerNum: The number given to the player.
string PlayerName: The name of the player.
int Ping: The ping from the server to the player.
int Score: The score of the player.
int StatsID: The ID used to maintain stats about the player

ServerResponseLine (native export)[edit]

int ServerID: The ID of the server.
string IP: The IP adress of the server.
int Port: The port that the Unreal Server is running on.
int QueryPort
string ServerName: The name of the Server.
string MapName: The name of the current map.
string GameType: The name of the current game.
int CurrentPlayers: The current number of players on the server.
int MaxPlayers: The maximum number of players allowed in the game.
int Ping: The ping to the server.
array<KeyValuePair> ServerInfo: A detailed list of what is loaded on the server (Mutators,GameRules,etc...).
array<PlayerResponseLine> PlayerInfo: A list of the Players on the server.

VoiceChatterInfo[edit]

Controller Controller
int IpAddr
int Handle

Properties[edit]

Globalconfig[edit]

bool bChangeLevels: True if the game is allowed to change levels and false if the game is not allowed to change levels.
bool bEnableStatLogging: True the game will be enabled to track stats and false the game will not track stats.
bool bAdminCanPause: True the game is pauseable by the admin and false if the game is not pauseable by the admin.
bool bWeaponShouldViewShake: True the weapon will shake the view and false the weapon will not shake the view.
float GameDifficulty
int GoreLevel: 0 is normal gore, while increasing the value will yield less gore.
float AutoAim: 1 is no aiming and 0 is always auto-aiming (cosine of max error to correct).
float GameSpeed: The scale applied to the rate of the game.
int MaxSpectators: The Maximum number of spectators.
int MaxPlayers: The Maximum number of players.
string AccessControlClass: The class name of the AccessControl class.
string GameStatsClass: The class name of the GameStats class.

Config[edit]

bool bWeaponStay: True the weapons stay when picked up and False they do not stay when picked up.
bool bAllowWeaponThrowing: True if the Pawn is allowed to throw their weapon and false if they are not allowed to throw their weapons.
bool bAllowBehindView: True if the PlayerController is allowed to view their Pawn from behind and false if the behind view is not allowed.
int GoalScore: The goal score of the level.
int MaxLives: The maximum lives a player has on the level. (0 means there is not limit).
int TimeLimit: The time limit of the game.

Localized[edit]

bool bAlternateMode: Used when setting the gore level of the game.
string DefaultPlayerName: The default name of the player when they have not specified a name.
string GameName: The name of the game.

Main[edit]

bool bRestartLevel: True if the level needs to be restarted and false if it does not need to be restarted.
bool bPauseable: True if the game is pauseable and false if the game is not pauseable.
bool bCanChangeSkin: True if the Controller can change the skin of the of the Pawn.
bool bTeamGame: True if the game is a team game and false if the game is not a team game.
bool GameEnded: True if the game has ended and false if the game has not ended.
bool bOverTime: True if the game is in overtime (because a win condition hasn't been met) and false if the game is not in overtime.
bool bCanViewOthers: True if a PlayerController is able to view other players in spectator mode and false if they are unable to view other players.
bool bDelayedStart: True if the start of a Controller's game start is delayed and false if it is not delayed.
bool bWaitingToStartMatch: True if the match is being waiting to start and false if the game has started.
bool bAlreadyChanged
bool bLoggingGame: True if the game is a logged game and false if the game is not being logged.
bool bGameRestarted
bool bModViewShake: True if the game allows for weapon shaking and false if the game does not allow weapon shaking.
bool bForceClassicView
float StartTime
string ScoreBoardType: The class name of the ScoreBoard that is loaded for this game.
string BotMenuType: The class name of the GUIComponent that is loaded for this game to control the game bots.
string RulesMenuType: The class name of the GUIComponent that is loaded for this game to control the rules.
string SettingsMenuType: The class name of the GUIComponent that is loaded for this game to control the game settings.
string GameUMenuType: The class name of the GUIComponent that is loaded for this game dropdown.
string MultiplayerUMenuType: The class name of the GUIComponent that is loaded for multiplayer dropdown.
string GameOptionsMenuType: The class name of the GUIComponent that is loaded for options dropdown.
string HUDType: The class name of the HUD that is loaded for the game.
string MapListType: The class name of the MapList that is loaded for this game.
string MapPrefix: The prefix designation that the game uses for it's maps.
string BeaconName: Identifying string used for finding LAN servers.
int NumSpectators: The current number of spectators in the game.
int NumPlayers: The current number of players in the game.
int NumBots: The current number of bots in the game.
int CurrentID: The game server ID.
float FearCostFallOff: The rate at which the FearCost in NavigationPoints decreases over time.
class<LocalMessage> DeathMessageClass: The message class that handles the messages concerned with death of a Pawn.
class<GameMessage> GameMessageClass: The message class that handles the messages in the game.
name OtherMesgGroup
string MutatorClass: The class name of the BaseMutator.
Mutator BaseMutator: The reference to the first mutator in the linked list of Mutators.
AccessControl AccessControl: The instance of the AccessControl class that handles the security, banning and various other administrative tasks.
GameRules GameRulesModifiers: The reference to the Linked-List of GameRules.
string BroadcaseHandlerClass: The class name for the BroadCastHandler.
BroadcastHandler BroadcastHandler: The reference to the Linked-List of BroadCastHandler.
class<PlayerController> PlayerControllerClass: The specific class of the PlayerController in this game.
string PlayerControllerClassName: The class name of the PlayerControllerClass. This should be set while the PlayerControllerClass is dynamically loaded using this string.
class<GameReplicationInfo> GameReplicationInfoClass: The class that contains Replication info about the game.
GameReplicationInfo GameReplicationInfo: The instance of the GameReplicationInfo class that contains important information concerning the game and the server.
bool bWelcomePending: True if the welcome message is still needed to be given to a new player, and False if the welcome message has already been presented.
GameStats GameStats: The instance of the GameStats where events and information are logged.
array<VoiceChatterInfo> VoiceChatters
String ScreenShotName
String DecoTextName
String Acronym
GameProfile CurrentGameProfile (transient): Persistant game data management.
Manifest SaveGameManifest (private const): persistant game data management.
bool bAttractCam

Methods[edit]

Inherited From Actor[edit]

Destroyed(): Used to destroy the GameInfo object. Destroys the GameProfile and then calls Actor's Destroy.
PostBeginPlay(): Called right after play starts. This function is used to initialize variables and objects that are set after play has just begun or gotten underway.
PreBeginPlay(): Called before play starts. This function is used to initialize varibles and objects that need to be set before the game begins. In this case, GameInfo sets start time, gamespeed and starts logging and the game replication info.
Reset(): Used for restarting the level. Returns the GameInfo Object to it's initial state.
Timer(): Used to handle events at a given time interval that is important to the GameInfo object. In this case it makes sure that all players have been welcomed to the server.
UpdatePrecacheMaterials(): Precaches textures used in the map by calling PrecacheGameTextures.
UpdatePrecacheStaticMeshes(): Precaches the static meshes used in the map by calling PrecacheGameStaticMeshes.

Inherited From Info[edit]

FillPlayInfo( PlayInfo PlayInfo ) (static): Used to load a PlayInfo with appropriate information about the game. Which should be added to the GameReplicationInfo so that the information is retreivable by all players.

Events[edit]

AcceptInventory( Pawn PlayerPawn ): Examine the passed player's inventory, and accept or discard each item. AcceptInventory needs to gracefully handle the case of some inventory being accepted but other inventory not being accepted (such as the default weapon). There are several things that can go wrong: A weapon's AmmoType not being accepted but the weapon being accepted – the weapon should be killed off. Or the player's selected inventory item, active weapon, etc. not being accepted, leaving the player weaponless or leaving the HUD inventory rendering messed up (AcceptInventory should pick another applicable weapon/item as current).
PreLogin( string Options, string Address, string PlayerID, out string Error, out string FailCode ): Accept or reject a player on the server. Fails login if you set the Error to a non-empty string.
Broadcast( Actor Sender, coerce string Msg, optional name Type ): Passes this information on to the BroadCastHandler object's method Broadcast.
DetailChange(): This event takes place when the detail level changes from low to high or high to low.
string GetBeaconText(): Return beacon text for serverbeacon.
InitGame( string Options, out string Error ): The GameInfo's InitGame( ) function is called before any other scripts (including PreBeginPlay( ) ), and is used by the GameInfo to initialize parameters and spawn its helper classes. Warning: this is called before actors' PreBeginPlay. The Options string contains the key-value pairs of options for the game. Error contains error information during the initializing of the game. In this case, it loads all the game speed, max players, password, mutators, game rules, etc...
PlayerController Login( string Portal, string Options, out string Error ): Fails login if you set the Error string. PreLogin is called before Login, but significant game time may pass before Login is called, especially if content is downloaded.

Exec Functions[edit]

AdminSay( string Msg ): Sends Msg to to all PlayerControllers.
KillBots( int num ): This methods destroys num bots.

Iterators[edit]

AllDataObjects( class objClass, out Object obj, string packageName ) (native, final): Iterates through all data objects in a package created with the SavePackage function.

Native Functions[edit]

string GetNetworkNumber(): Replication related function.
LoadMapList( string MapPrefix, out array<string> Maps ) (static, final): Returns an array of Map names with the following MapPrefix.
string ParseKillMessage( string KillerName, string VictimName, string DeathMessage ) [static]

DataObject Functions[edit]

Manifest GetSavedGames() (final): Returns a Manifest of saved games.
Object CreateDataObject( class objClass, string objName, string packageName ) (final)
Object LoadDataObject( class objClass, string objName, string packageName ) (final): Creates an instance of the objClass from the packageName with the packageName as its name.
bool DeleteDataObject( class objClass, string objName, string packageName ) (final): Returns true if this method is able to delete the instance of the object.
bool SavePackage( string packageName ) (final): Returns true if the package labeled packageName has been saved and returns false if the package was not saved.
bool DeletePackage( string packageName ) (final): Returns true if the package labeled packageName has been deleted and false if the package was not deleted.

Other Methods[edit]

AddDefaultInventory( Pawn PlayerPawn ): Add to the Pawn specific Inventory items required for the game. In this case, the base mutator is queried for the default weapon and it is added to the inventory and made so it is not throwable. Then it calls SetPlayerDefaults.
AddGameSpecificInventory( Pawn p ): Add to the Pawn specific Inventory items required for the game. This is the same as AddDefaultInventory method except that it does not call SetPlayerDefaults when it is done.
AddMutator( string mutname, optional bool bUserAdded ): Utility function that creates a physical instance of the mutname class and then adds it to the BaseMutator variable.
bool AtCapacity( bool bSpectator ): Returns true if the game is at capacity and returns false if the the server is not at capacity. bSpectator is used to specify for which type of capactity. if bSpectator is false then you are asking if there is room for more players. If bSpectator is true then you are asking if there is room for more spectators.
BroadcastDeathMessage( Controller Killer, Controller Other, class<DamageType> damageType ): Broadcase a message that Controller Killer has killed himself or another player.
BroadcastLocalized( Actor Sender, class<LocalMessage> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject ): Broadcast a localized message to all players. Most message deal with 0 to 2 related PRIs. The LocalMessage class defines how the PRI's and optional actor are used.
BroadcastTeam( Controller Sender, coerce string Msg, optional name Type ): Passes this information on to the BroadCastHandler object's method BroadcastTeam.
bool CanSpectate( PlayerController Viewer, bool bOnlySpectator, Actor ViewTarget ): Returns true if the Viewer is able to spectate in the game of the following Actor ViewTarget and returns false if the Viewer may not. In this case it always returns true.
ChangeMap( int ContextID ): Changes the map that is currently being played to the one specified by the ContextID.
ChangeName( Controller Other, coerce string S, bool bNameChange ): If bNameChange is allowing name changes then change the name of Controller Other's name to S.
bool ChangeTeam( Controller Other, int N, bool bNewTeam ): If bNewTeam is allowing team changes then change Controller Other's team to team number N.
ChangeVoiceChatter( Controller Client, int IpAddr, int Handle, bool Add )
bool CheckEndGame( PlayerReplicationInfo Winner, string Reason ): Called when the game is over. Allows GameRules in the GameRulesModifiers linked-list a chance to handle the end game. In this case, if no GameRules modifies the end game then it loops through each Controller and calls ClientGameEnded and GameHasEnded.
CheckScore( PlayerReplicationInfo Scorer ): Sees if this score means the game ends. This method should allow GameRules in the GameRulesModifiers linked-list a chance to augment the determination of the end game for this Scorer.
DiscardInventory( Pawn Other ): Removes and destroys all the Inventory of the Pawn Other's Inventory.
EndGame( PlayerReplicationInfo Winner, string Reason ): The end of the game has been reached. In this case, it calls CheckEndGame to see if perhaps the winning conditions have not been reached. Then sets the bGameEnded to false and then Triggers the event EndGame.
EndLogging( string Reason ): Used to close and destroy all the logging classes in the GameInfo class.
string FindPlayerByID( int PlayerID ): Returns the name of the player given a playerID.
NavigationPoint FindPlayerStart( Controller Player, option byte inTeam, optional string incomingName ): Return the 'best' player start for this player to start from.
Actor FindSpecGoalFor( PlayerReplicationInfo PRI, int TeamIndex ): Returns an actor that has special goal or situation taking place. For example, in xBombingRun games the Pawn with the xBombFlag is returned or the bomb itself if no one has control of it.
string FindTeamDesignation( GameReplicationInfo GRI, Actor A ) (static): Used to determine the team's designation of the Actor A. Returns the string name of the team.
GameEnding(): Handles the action when a game ends. In this case it simply turns off the logging.
class<Pawn> GetDefaultPlayerClass( Controller C ): Returns an instance of the Pawn class that the Controller C is using as their Pawn. This is called from inside RestartPlayer(), if C.PawnClass couldn't be spawend. RestartPlayer may be overriden and may not call this in your case.
int GetIntOption( string Options, string ParseString, int CurrentValue ): Returns the int value from a key-value pair. Options is the string you is the string of options. ParseString is the key. CurrentValue is a default value that the option is set at before calling this method.
GetKeyValue( string Pair, out string Key, out string Value ): This utility function breaks the string Pair into it's key and value. The key-value pair is a string in the form of "key=value"
MapList GetMapList( string MapListType ): Returns an instance of the class MapListType.
int GetNumPlayers(): Used to return the number of players in the game.
GetServerDetails( out ServerResponseLine ServerState ): Used to return detailed information about the server in the ServerResponseLine struct defined above.
GetServerInfo( out ServerResponseLine ServerState ): Used to return information about the server in the ServerResponseLine struct defined above.
GetServerPlayers( out ServerResponseLine ServerState ): Used to return the information about the players using the PlayerResponseLine struct defined above.
int GetServerPort(): Returns the port that the server is operating on.
bool GrabOption( out string Options, out string Result ): This utility function is used to grab options from a string. The option is in the form of "?option1?option2".
bool HasOption( string Options, string InKey ): Returns true if the InKey key has a value in the option string. False is returned if the InKey doesn't exist as a key in the Options string.
InitGameReplicationInfo(): Starts the appropriate game information to the GameReplicationInfo object. In this case it copies whether it is a team game, the game name, the game class, and the max lives.
InitLogging(): Starts the logging for the game. Usually a GameStats object that is instantiated specified with a specific class specified by the string GameStatsClass.
bool IsOnTeam( Controller Other, int TeamNum ): Returns true if the Controller Other is on TeamNum and returns false of the Other is not on the TeamNum.
Kick( string S ): S is the name of the player that is being kicked off the game server.
KickBan( string S ): S is the name of the player that is being kicked off and banned from the game server. The KickBan function denies them based on the player's IP address.
Killed( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> damageType ): This function handles calling the KillEvent for the appropriate logging and then handles the death and removal of inventory of the KilledPawn.
KillEvent( string Killtype, PlayerReplicationInfo Killer, PlayerReplicationInfo Victim, class<DamageType> Damage ): Call when a kill event has taken place. In this case, the GameStats object logs the KillEvent.
Logout( Controller Exiting ): When a player logs out of the game. Exiting is the Controller that is leaving the game.
NotifyKilled( Controller Killer, Controller Killed, Pawn KilledPawn ): Used to notify the death of Killed. In this case, each Controller calls NotifiedKilled.
TeamInfo OtherTeam( TeamInfo Requester ): Returns the opposing team's information. In TeamGame if you are the first team it returns the second team's information.
string ParseChatPercVar( Mutator BaseMutator, Controller Who, string Cmd ) (static): Calls the BaseMutator method ParseChatPercVar and accepts the string that returns. Then calls the Controller Who method ParseChatPercVar and returns that string. Used for Adreneline and Sheild count?
string ParseMessageString( Mutator BaseMutator, Controller Who, String Message ) (static): Parse out the % vars from the Message. In this case, it simply returns the Message.
string ParseOption( string Options, string InKey ): This utility function returns the value of the InKey parameter from the key-value pair.
byte PickTeam( byte Current, Controller C ): Allows the Controller C to pick the team Current if it wasn't already given a team number.
bool PickupQuery( Pawn Other, Pickup item ): Called when the Pawn Other touches a Pickup and returns true if the Pawn is able and wants to pick it up and returns false if the Pawn is not able or doesn't want to pick it up.
PostLogin( PlayerController NewPlayer ): Called after a successful login. This is the first place it is safe to call replicated functions on the PlayerPawn. NewPlayer is the PlayerController that has successfully logged in.
PrecacheGameStaticMeshes( LevelInfo myLevel ) (static)
PrecacheGameTextures( LevelInfo myLevel ) (static)
bool PreventDeath( Pawn Killed, Controller Killer, class<DamageType> damageType, vector HitLocation ): Allows GameRules in the GameRulesModifiers linked-list a chance to prevent the death of the the Killed Pawn. Returns true if Pawn is to remain alive.
bool PreventSever( Pawn Killed, Name boneName, int Damage, class<DamageType> DamageType ): Allows GameRules in the GameRulesModifiers linked-list a chance to prevent the severing of limb of the the Killed Pawn.
ProcessServerTravel( string URL, bool bItems ): This method handles moving the PlayerController objects to a new URL. bItems is a flag that is set to true if items are to move with players and false if they are to lose them upon traveling. In this case, the method checks with the Mutator list and then calls each individual PlayerController method ClientTravel.
float RatePlayerStart( NavigationPoint N, byte Team, Controller Player ): Rate whether player should choose this NavigationPoint as its start default implementation is for single player game.
string RecommendCombo( string ComboName ): Returns a string name of an Adrenaline Combo that the method recommends to the player. This is a Combo that could be randomly selected or based on the ComboName parameter.
int ReduceDamage( int Damage, Pawn injured, Pawn instigatedBy, vector HitLocation, out vector Momentum, class<DamageType> DamageType ): Determins if the damage should be reduced. Should allow GameRules in the GameRulesModifiers linked-list a chance to reduce damage of the injured Pawn. In this case, it checks whether the injured is a neutral zone, in GodMode, or wearing armor.
RestartGame(): Restart the game. Allows the GameRules GameRulesModifier list to handle the game restart. If no GameRules modify how the game restarts then handle the restart of the game.
RestartPlayer( Controller aPlayer ): Restart a player.
ReviewJumpSpots( name TestLabel ): Overridden in DeathMatch to test all the JumpSpots in the level.
ScoreEvent( PlayerReplicationInfo Who, float Points, string Desc ): When a score event takes place, this method has the Who, the Points, and the description Desc of the score event. In this case, GameStats object ScoreEvent method is called with the above information.
ScoreKill( Controller Killer, Controller Other ): Determines if the death was caused by surroundings, suicide, or another player and scores the event respectively. Allows the GameRules GameRulesModifier list to handle the ScoreKill.
ScoreObjective( PlayerReplicationInfo Scorer, Int Score ): Handles the scoring of Scorer. This method should allow GameRules in the GameRulesModifiers linked-list a chance to augment the score of the Scorer.see if this score means the game ends
SendPlayer( PlayerController aPlayer, string URL ): Sends PlayerController aPlayer to the URL specified. This is used when a player changes maps.
SessionKickBan( string S ): Ban's the player by calling the AccessControl method SessionKickBan which removes the player and blocks the IP address from joining again.
SetGameSpeed( float T ): Sets the speed of the game. In this instance it sets the game speed and the time dilation of the level and then stores any changes of game speed.
bool SetPause( bool bPause, PlayerController P ): Pauses/Unpauses the game if the PlayerController is allowed to pause/unpause the game.
SetPlayerDefaults( Pawn PlayerPawn ): Sets the default characteristics of the PlayerPawn. In this case they sit AirControl, GroundSpeed, WaterSpeed, AirSpeed, Acceleration, JumpZ. Then it allows the Mutator list to augment these values.
SetWeaponViewShake( PlayerController P ): Sets the PlayerController weapon to shake. In this case it it determines whether bWeaponShouldViewShake and bModViewShake are both true and then calls PlayerController's ClientSetWeaponViewShake.
bool ShouldRespawn( Pickup Other ): Returns true if the Pickup should respawn and false if it should not respawn. In this case, it checks what the game type (Standalone games do not respawn) and then with the RespawnTime of the item.
StartMatch(): Starts the game. Informs all actors that the match is starting and spawn player's pawns.
TeamScoreEvent( int Team, float Points, string Desc ): When a team score event takes place, this method has the Who, the Points, and the description Desc of the team score event. In this case, GameStats object TeamScoreEvent method is called with the above information.
bool TooManyBots( Controller botToRemove ): Returns true if there are too many bots and returns false if there are not too many bots. In this case, it always returns false.
bool UseLowGore() (static): Returns whether to display less gore. (i.e., green blood instead of red blood and no gibs)

Known Subclasses[edit]

GameInfo
   +- CinematicGame
   +- UnrealMPGameInfo
       +- DeathMatch
            +- TeamGame
            |   +- CTFGame
            |   |   +- xCTFGame
            |   |       +- InstagibCTF (UT200x)
            |   |       +- xVehicleCTFGame (UT2004)
            |   +- xBombingRun (UT200x)
            |   +- xDoubleDom (UT200x)
            |   +- xTeamGame
            |       +- ASGameInfo (UT2004)
            |       +- Invasion (UT2004)
            |       +- ONSOnslaughtGame (UT2004)
            +- xDeathMatch
               +- BossDM
               +- xLastManStandingGame (UT2004)
               +- xMutantGame (UT2004)

JCBDigger: Anyone have some example code for GetServerDetails( ... ) and GetServerInfo( ... ) for a mutator. I have been trying to get the MapName back to display on a menu from a mutator, but just get blank strings!

For anyone interested, I used a different method to get what I wanted.

The parent class of Mutator is the Map Name I needed.

class MyMutator extends Mutator;
 
function string GetThisMapName()
{
  local string sParentClass, sClassTree, sThisClass< SEMI >
  sClassTree = string(self);    // e.g. DM-1on1-MyLevel.MyMutator
  sThisClass = string(self.name);    // e.g. MyMutator
  // take one from the other to leave DM-1on1-MyLevel
  sParentClass = left(sClassTree, (InStr(sClassTree,sThisClass) -1));  // e.g. DM-1on1-MyLevel
  return sParentClass< SEMI >
}

There must be a better way.

Mortal Monkey: Try this:

sClassTree = string(self.class);

Other that that you coud use Actor's string GetURLMap(), or find the map's title in LevelInfo.Title.

Wormbo: To get the map's package name you can just use string(Outer) in any Actor. For the map's title you'd use Level.Title, again this works in every Actor.

OlympusMons: Maybe a GameInfo (UT2003) or GameInfo (UT2004) page is in order then.

Category:Legacy Class (UT2004) – Looks like there are enough differences that 2k4 should have it's own version of this page.
Category:Legacy Class (UT2003)
Category:Legacy Class Tree