Engine.GameInfo

//=============================================================================
// GameInfo.
//
// 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) either the DefaultGameType if specified in the LevelInfo, or the 
// DefaultGame entry in the game's .ini file (in the Engine.Engine section), unless 
// its a network game in which case the DefaultServerGame entry is used.  
//
//=============================================================================
class GameInfo extends Info
	native;

//-----------------------------------------------------------------------------
// Variables.

var protected globalconfig byte Difficulty;				//NEW (mdf) 0=easiest, MaxDifficulty=Hardest.
var protected config byte MaxDifficulty;				//NEW (mdf)
//OLD (mdf) var byte  Difficulty;						// 0=easy, 1=medium, 2=hard, 3=very hard.
var bool				      bRestartLevel;			// Level should be restarted when player dies
var bool				      bPauseable;				// Whether the game is pauseable.
var config bool				  bCoopWeaponMode;			// Whether or not weapons stay when picked up.
var	bool				      bCanChangeSkin;			// Allow player to change skins in game.
var bool				      bTeamGame;				// This is a team game.
var	bool					  bGameEnded;				// set when game ends
var	bool					  bOverTime;
var localized bool			  bAlternateMode;
var	bool					  bCanViewOthers;
var bool					  bDelayedStart;
var bool					  bWaitingToStartMatch;
var globalconfig bool		  bChangeLevels;
var		bool				  bAlreadyChanged;

//NEW (mdf) infinite ammo support
var bool bInfiniteAmmo;							// if true, weapons will always have enough ammo to fire
var bool bReloadsEnabled;						// if false, reloading is disabled
//OLD

var	  globalconfig int		  GameFlags;				//NEW (mdf)

var   globalconfig bool       bAllowGore;				//NEW (mwp)
var   globalconfig float	  AutoAim;					// How much autoaiming to do (1 = none, 0 = always).
														// (cosine of max error to correct)
var   globalconfig float	  GameSpeed;				// Scale applied to game rate.
var   float                   StartTime;

var   string				  DefaultPlayerClassName;

var() bool                    bDisplayHud;				//NEW (mwp) UI components hide themselves when GameInfo.bDisplayHud is false
var config bool               bCutsceneInputHandling;	//NEW (mwp) <Esc>/<Space> = "NextLevel", ignore all other keys/events
var bool					  bSaveDisabled;			//NEW (mib)

var int                       PauseKey;					//NEW (arl) For locking SetPause.

// user interface
var	  string				  ScoreBoardType;
var   string			      BotMenuType;				// Type of bot menu to display.
var   string			      RulesMenuType;			// Type of rules menu to display.
var   string				  SettingsMenuType;			// Type of settings menu to display.
var   string				  GameUMenuType;			// Type of Game dropdown to display.
var   string				  MultiplayerUMenuType;		// Type of Multiplayer dropdown to display.
var   string				  GameOptionsMenuType;		// Type of options dropdown to display.
var	  string				  HUDType;					// HUD class this game uses.
var   string				  MapListType;				// Maplist this game uses.
var   string			      MapPrefix;				// Prefix characters for names of maps for this game type.
var   string			      BeaconName;				// Identifying string used for finding LAN servers.

var   globalconfig int	      MaxSpectators;			// Maximum number of spectators.
var	  int					  NumSpectators;			// Current number of spectators.
var   globalconfig int		  MaxPlayers; 
var   int					  NumPlayers;				// number of human players
var	  int					  NumBots;					// number of non-human players (AI controlled but participating as a player)
var   int					  CurrentID;
var localized string	      DefaultPlayerName;
var localized string	      GameName;

// Message classes.
var class<LocalMessage>		  DeathMessageClass;
var class<GameMessage>		  GameMessageClass;

//-------------------------------------
// GameInfo components
var string MutatorClass;
var Mutator BaseMutator;				// linked list of Mutators (for modifying actors as they enter the game)
var string AccessControlClass;
var AccessControl AccessControl;		// AccessControl controls whether players can enter and/or become admins
var GameRules GameRulesModifiers;		// linked list of modifier classes which affect game rules
var string BroadcastHandlerClass;
var BroadcastHandler BroadcastHandler;	// handles message (text and localized) broadcasts

var class<PlayerController> PlayerControllerClass;	// type of player controller to spawn for players logging in
//NEW (mdf) temporary hack?
var config string PlayerControllerClassName;
/*OLD
var string PlayerControllerClassName;
*/

// ReplicationInfo
var() class<GameReplicationInfo> GameReplicationInfoClass;
var GameReplicationInfo GameReplicationInfo;

// Statistics Logging
var StatLog						StatLog;
var globalconfig bool			bLocalLog;
var globalconfig bool			bWorldLog;
var bool						bLoggingGame;			// Does this gametype log?
var class<StatLog>				StatLogClass;
var() bool bNoisyWeaponChanges;				// if true, weapon switches call MakeNoise (so NPCs can hear these)

var array<Name> LocalGameEvents;	// game events local to this level
var array<Name> TravelGameEvents;	// game events which travel from level to level.  FIXME - make them travel!!!

native final function AddLocalGameEvent(name Event);
native final function AddTravelGameEvent(name Event);
native final function RemoveGameEvent(name Event);
native final function bool GameEventRegistered(name Event);

//NEW (mwp) Cutscene support
event NotifyLevelChange();		// about to transition to a new level
event NotifyLevelChangeEnd();	// transitioned to a new level
event NotifyAudioSystemReset();	// audio system is re-initializing
event NotifyLevelRestart();		// about to restart level
event NotifyHack();			//!!arl remove this once PostLogin can be hooked again in CutsceneGameInfo.uc
event NextLevel();
event NextScene();
//OLD
//NEW (mib) In-game cutscene notifications
function NotifyCutSceneStart();
function NotifyCutSceneEnd();

//OLD

//------------------------------------------------------------------------------
// Engine notifications.

event PreBeginPlay()
{
	StartTime = 0;
	SetGameSpeed(GameSpeed);
	GameReplicationInfo = Spawn(GameReplicationInfoClass);
	InitGameReplicationInfo();
}

//NEW: Fix
event Destroyed()
{
	if( GameReplicationInfo != None )
	{
		GameReplicationInfo.Destroy();
		GameReplicationInfo = None;
	}

	Super.Destroyed();
}
//OLD

event PostBeginPlay()
{
	InitLogging();
	Super.PostBeginPlay();
}

//NEW (arl)
event DispatchMusicEvent( string Event )
{
	TriggerEvent(StringToName(Event),None,None);
}
//OLD

/* Reset() 
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
	Super.Reset();
	bGameEnded = false;
	bOverTime = false;
	bWaitingToStartMatch = true;
	InitGameReplicationInfo();
}

/* InitLogging()
Set up statistics logging
*/
function InitLogging()
{
	local bool bLoggingWorld;

	if ( !bLoggingGame )
		return;

	bLoggingWorld = bWorldLog &&
		((Level.NetMode == NM_DedicatedServer) || (Level.NetMode == NM_ListenServer));
	if ( bLocalLog || bLoggingWorld )
	{
		StatLog = spawn(StatLogClass);
		Log("Initiating logging using "$StatLog$" class "$Statlogclass);
		StatLog.GenerateLogs(bLocalLog, bLoggingWorld);
		StatLog.StartLog();
		LogGameParameters();
	}
}

event Timer()
{
	BroadcastHandler.UpdateSentText();
}

// Called when game shutsdown.
event GameEnding()
{
	EndLogging("serverquit");
}

//------------------------------------------------------------------------------
// Replication

function InitGameReplicationInfo()
{
	GameReplicationInfo.bTeamGame = bTeamGame;
	GameReplicationInfo.GameName = GameName;
	GameReplicationInfo.GameClass = string(Class);
}

native function string GetNetworkNumber();

//------------------------------------------------------------------------------
// Game Querying.

//NEW (mwp)
function string GetCustomMapName( string MapName )
{
	return MapName;
}
//OLD

function string GetInfo()
{
	local string ResultSet;

	// World logging enabled and working
	if ( StatLog.bWorld && !StatLog.bWorldBatcherError )
		ResultSet = "\\worldlog\\true";
	else
		ResultSet = "\\worldlog\\false";

	// World logging activated
	if ( StatLog.bWorld )
		ResultSet = ResultSet$"\\wantworldlog\\true";
	else
		ResultSet = ResultSet$"\\wantworldlog\\false";

	return ResultSet;
}

function string GetRules()
{
	local string ResultSet;
	local Mutator M;
	local string NextMutator, NextDesc;
	local string EnabledMutators;
	local int Num, i;

	ResultSet = "";

	EnabledMutators = "";
	for (M = BaseMutator.NextMutator; M != None; M = M.NextMutator)
	{
		Num = 0;
		NextMutator = "";
		GetNextIntDesc("Engine.Mutator", 0, NextMutator, NextDesc);
		while( (NextMutator != "") && (Num < 50) )
		{
			if(NextMutator ~= string(M.Class))
			{
				i = InStr(NextDesc, ",");
				if(i != -1)
					NextDesc = Left(NextDesc, i);

				if(EnabledMutators != "")
					EnabledMutators = EnabledMutators $ ", ";
				 EnabledMutators = EnabledMutators $ NextDesc;
				 break;
			}
			
			Num++;
			GetNextIntDesc("Engine.Mutator", Num, NextMutator, NextDesc);
		}
	}
	if(EnabledMutators != "")
		ResultSet = ResultSet $ "\\mutators\\"$EnabledMutators;

	ResultSet = ResultSet $ "\\listenserver\\"$string(Level.NetMode==NM_ListenServer);
	Resultset = ResultSet$"\\changelevels\\"$bChangeLevels;
	if ( GameRulesModifiers != None )
		ResultSet = ResultSet$GameRulesModifiers.GetRules();

	return ResultSet;
}

// Return the server's port number.
function int GetServerPort()
{
	local string S;
	local int i;

	// Figure out the server's port.
	S = Level.GetAddressURL();
	i = InStr( S, ":" );
	assert(i>=0);
	return int(Mid(S,i+1));
}

function bool SetPause( BOOL bPause, PlayerController P, optional int Key )
{
//NEW
	if( bPauseable )
/*OLD
	if( bPauseable || P.IsA('Admin') || Level.Netmode==NM_Standalone )
*/
	{
//NEW
		if (PauseKey?)		// locked
		{
			if (PauseKey==Key) PauseKey=0;	// unlock.
			if (PauseKey?) return True;	// check if still locked.
		}
		else				// unlocked
		{
			PauseKey=Key;					// lock if set.
		}
//OLD
		if( bPause )
		{
			Level.Pauser=P.PlayerReplicationInfo;
			PauseAudio( false ); //NEW (mwp)
		}
		else
		{
			Level.Pauser=None;
			UnPauseAudio(); //NEW (mwp)
		}
		return True;
	}
//NEW (mwp) avoid PlayerController exec Pause() handling
	return true;
//OLD	else return False;
}

//NEW
function SetInfiniteAmmo( bool bVal )
{
	local Weapon W;

	bInfiniteAmmo = bVal;

	if( bInfiniteAmmo )
	{
		// make sure all held weapons have at least their default amount of ammo
		foreach AllActors( class'Weapon', W )
		{
			if( Pawn(W.Owner) != None )
				W.GiveAmmo( Pawn(W.Owner) );
		}
	}
}

function bool GetInfiniteAmmo()
{
	return bInfiniteAmmo;
}

function SetReloadsEnabled( bool bVal )
{
	bReloadsEnabled = bVal;
}

function bool GetReloadsEnabled()
{
	return bReloadsEnabled;
}
//OLD

//NEW - CDH
// Ragdoll detail level - 0=Off, 1=Low, 2=Medium, 3=High
function int GetRagdollDetailLevel() { return 0; }
function int GetActiveRagDollDeaths()	{ return 0; }
function int GetMaxRagDollDeaths() { return 0; }
function IncActiveRagDollDeaths();
function DecActiveRagDollDeaths();

//------------------------------------------------------------------------------
// Stat Logging.

function LogGameParameters()
{
	local Mutator M;

	for (M = BaseMutator; M != None; M = M.NextMutator)
		StatLog.LogMutator(M);

	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"GameName"$Chr(9)$GameName);
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"GameClass"$Chr(9)$Class);// <-- Move to c++
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"GameVersion"$Chr(9)$Level.EngineVersion);
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"MinNetVersion"$Chr(9)$Level.MinNetVersion);
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"WeaponsStay"$Chr(9)$bCoopWeaponMode);
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"TeamGame"$Chr(9)$bTeamGame);
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"GameSpeed"$Chr(9)$int(GameSpeed*100));
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"MaxSpectators"$Chr(9)$MaxSpectators);
	StatLog.LogEventString(StatLog.GetTimeStamp()$Chr(9)$"game"$Chr(9)$"MaxPlayers"$Chr(9)$MaxPlayers);
}

//------------------------------------------------------------------------------
// Game parameters.

//
// Set gameplay speed.
//
function SetGameSpeed( Float T )
{
	local float OldSpeed;

	OldSpeed = GameSpeed;
//NEW (mdf)
	GameSpeed = FClamp( T, 0.01, 100.0 );
/*OLD
	GameSpeed = FMax(T, 0.1);
*/
	Level.TimeDilation = GameSpeed;
/*OLD (mdf) don't save new setting so slomo changes will only be in effect for this level?
	if ( GameSpeed != OldSpeed )
		SaveConfig();
*/
	SetTimer(Level.TimeDilation, true);

	DM( "GameSpeed: " $ Level.TimeDilation ); //NEW (mdf) display current speed
}

//
//
//
simulated function float GetGameSpeed()
{
	return GameSpeed;
}

event NotifyGameSpeedChanged( float OldSpeed, float NewSpeed);

//
//
//
simulated function SetAutoAim( float F )
{
	AutoAim = F;
}

//
//
//
simulated function float GetAutoAim()
{
	return AutoAim;
}

//NEW (mb)
// directory for dialog files (hook for dialog engine)
event string GetDialogDirectory()
{
	return Level.MapName;
}
//OLD

//
// Called after setting low or high detail mode.
//
event DetailChange()
{
	local actor A;
	local zoneinfo Z;
	local skyzoneinfo S;

	if( !Level.bHighDetailMode )
	{
		foreach DynamicActors(class'Actor', A)
		{
			if( A.bHighDetail && !A.bGameRelevant )
				A.Destroy();
		}
	}
	foreach AllActors(class'ZoneInfo', Z)
		Z.LinkToSkybox();
}

//NEW PWC 2002.10.23 need to access this info from FlameDamager
function float GetDamageByPlayerScalar();
function float GetDamageToPlayerScalar();

//------------------------------------------------------------------------------
// Player start functions

//
// Grab the next option from a string.
//
function bool GrabOption( out string Options, out string Result )
{
	if( Left(Options,1)=="?" )
	{
		// Get result.
		Result = Mid(Options,1);
		if( InStr(Result,"?")>=0 )
			Result = Left( Result, InStr(Result,"?") );

		// Update options.
		Options = Mid(Options,1);
		if( InStr(Options,"?")>=0 )
			Options = Mid( Options, InStr(Options,"?") );
		else
			Options = "";

		return true;
	}
	else return false;
}

//
// Break up a key=value pair into its key and value.
//
function GetKeyValue( string Pair, out string Key, out string Value )
{
	if( InStr(Pair,"=")>=0 )
	{
		Key   = Left(Pair,InStr(Pair,"="));
		Value = Mid(Pair,InStr(Pair,"=")+1);
	}
	else
	{
		Key   = Pair;
		Value = "";
	}
}

/* ParseOption()
 Find an option in the options string and return it.
*/
function string ParseOption( string Options, string InKey )
{
	local string Pair, Key, Value;
	while( GrabOption( Options, Pair ) )
	{
		GetKeyValue( Pair, Key, Value );
		if( Key ~= InKey )
			return Value;
	}
	return "";
}

/* Initialize the game.
 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.
*/
event InitGame( string Options, out string Error )
{
	local string InOpt, LeftOpt;
	local int pos;
	local class<Mutator> MClass;
	local class<AccessControl> ACClass;
	local class<GameRules> GRClass;
	local class<BroadcastHandler> BHClass;

	log( "InitGame:" @ Options );
	MaxPlayers = Min( 32,GetIntOption( Options, "MaxPlayers", MaxPlayers ));
	InOpt = ParseOption( Options, "Difficulty" );
	if( InOpt != "" )
		Difficulty = int(InOpt);

//NEW (mdf)
	Difficulty = Clamp( Difficulty, 0, MaxDifficulty );
//OLD

	InOpt = ParseOption( Options, "GameSpeed");
	if( InOpt != "" )
	{
		log("GameSpeed"@InOpt);
		SetGameSpeed(float(InOpt));
	}

	MClass = class<Mutator>(DynamicLoadObject(MutatorClass, class'Class'));
	BaseMutator = spawn(MClass);

	//NEW MJL: levellists
	Spawn(class'EngineLevelListInfo');
	//OLD
	BHClass = class<BroadcastHandler>(DynamicLoadObject(BroadcastHandlerClass,Class'Class'));
	BroadcastHandler = spawn(BHClass);

	InOpt = ParseOption( Options, "AccessControl");
	if( InOpt != "" )
		ACClass = class<AccessControl>(DynamicLoadObject(InOpt, class'Class'));
	if ( ACClass != None )
		AccessControl = Spawn(ACClass);
	else
	{
		ACClass = class<AccessControl>(DynamicLoadObject(AccessControlClass, class'Class'));
		AccessControl = Spawn(ACClass);
	}

	InOpt = ParseOption( Options, "AdminPassword");
	if( InOpt!="" )
		AccessControl.SetAdminPassword(InOpt);

	InOpt = ParseOption( Options, "GameRules");
	if ( InOpt != "" )
	{
		log("Game Rules"@InOpt);
		while ( InOpt != "" )
		{
			pos = InStr(InOpt,",");
			if ( pos > 0 )
			{
				LeftOpt = Left(InOpt, pos);
				InOpt = Right(InOpt, Len(InOpt) - pos - 1);
			}
			else
			{
				LeftOpt = InOpt;
				InOpt = "";
			}
			log("Add game rules "$LeftOpt);
			GRClass = class<GameRules>(DynamicLoadObject(LeftOpt, class'Class'));
			if ( GRClass != None )
			{
				if ( GameRulesModifiers == None )
					GameRulesModifiers = Spawn(GRClass);
				else	
					GameRulesModifiers.AddGameRules(Spawn(GRClass));
			}
		}
	}

	log("Base Mutator is "$BaseMutator);
	InOpt = ParseOption( Options, "Mutator");
	if ( InOpt != "" )
	{
		log("Mutators"@InOpt);
		while ( InOpt != "" )
		{
			pos = InStr(InOpt,",");
			if ( pos > 0 )
			{
				LeftOpt = Left(InOpt, pos);
				InOpt = Right(InOpt, Len(InOpt) - pos - 1);
			}
			else
			{
				LeftOpt = InOpt;
				InOpt = "";
			}
			log("Add mutator "$LeftOpt);
			MClass = class<Mutator>(DynamicLoadObject(LeftOpt, class'Class'));
			if ( MClass != None )	
				BaseMutator.AddMutator(Spawn(MClass));
		}
	}

	InOpt = ParseOption( Options, "GamePassword");
	if( InOpt != "" )
	{
		AccessControl.SetGamePassWord(InOpt);
		log( "GamePassword" @ InOpt );
	}

	InOpt = ParseOption( Options, "LocalLog");
	if( InOpt ~= "true" )
		bLocalLog = True;

	InOpt = ParseOption( Options, "WorldLog");
	if( InOpt ~= "true" )
		bWorldLog = True;
}

//
// Return beacon text for serverbeacon.
//
event string GetBeaconText()
{	
	return
		Level.ComputerName
	@	Left(Level.Title,24) 
	@	BeaconName
	@	NumPlayers
	$	"/"
	$	MaxPlayers;
}

/* ProcessServerTravel()
 Optional handling of ServerTravel for network games.
*/
function ProcessServerTravel( string URL, bool bItems )
{
	local playercontroller P, LocalPlayer;

	EndLogging("mapchange");

	// Notify clients we're switching level and give them time to receive.
	// We call PreClientTravel directly on any local PlayerPawns (ie listen server)
//NEW (mdf)
	log( Level.TimeSeconds $ " ProcessServerTravel: " $ URL $ " bItems: " $ bItems );
/*OLD	
	log("ProcessServerTravel:"@URL);
*/	
	foreach DynamicActors( class'PlayerController', P )
		if( NetConnection( P.Player)!=None )
			P.ClientTravel( URL, TRAVEL_Relative, bItems );
		else
		{	
			LocalPlayer = P;
			P.PreClientTravel();
		}

	if ( (Level.NetMode == NM_ListenServer) && (LocalPlayer != None) )
		Level.NextURL = Level.NextURL$"?Skin="$LocalPlayer.GetDefaultURL("Skin")
					 $"?Face="$LocalPlayer.GetDefaultURL("Face")
					 $"?Team="$LocalPlayer.GetDefaultURL("Team")
					 $"?Name="$LocalPlayer.GetDefaultURL("Name")
					 $"?Class="$LocalPlayer.GetDefaultURL("Class");

	// Switch immediately if not networking.
	if( Level.NetMode!=NM_DedicatedServer && Level.NetMode!=NM_ListenServer )
		Level.NextSwitchCountdown = 0.0;
}

//
// Accept or reject a player on the server.
// Fails login if you set the Error to a non-empty string.
//
event PreLogin
(
	string Options,
	string Address,
	out string Error,
	out string FailCode
)
{
	local bool bSpectator;
	local string spec;

	spec = ParseOption ( Options, "SpectatorOnly" );	
	bSpectator = ( spec != "" );

	AccessControl.PreLogin(Options, Address, Error, FailCode, bSpectator);
}

function int GetIntOption( string Options, string ParseString, int CurrentValue)
{
	local string InOpt;

	InOpt = ParseOption( Options, ParseString );
	if ( InOpt != "" )
	{
		log(ParseString@InOpt);
		return int(InOpt);
	}	
	return CurrentValue;
}

function bool AtCapacity(bool bSpectator)
{
	if ( Level.NetMode == NM_Standalone )
		return false;

	if ( bSpectator )
		return ( (NumSpectators >= MaxSpectators)
			&& ((Level.NetMode != NM_ListenServer) || (NumPlayers > 0)) );
	else
		return ( (MaxPlayers>0) && (NumPlayers>=MaxPlayers) );
}

//NEW: (mwp) new interface -- allow GameInfo subclass to enforce "required" Pawn class
function AdjustPawnClass( out string InClass );
//OLD

//
// Log a player in.
// 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.
//
event PlayerController Login
(
	string Portal,
	string Options,
	out string Error
)
{
	local NavigationPoint StartSpot;
	local PlayerController NewPlayer;
	local class<Pawn> DesiredPawnClass;
	local Pawn      TestPawn;
	local string          InName, InPassword, InChecksum, InClass;
	local byte            InTeam;
	local bool bSpectator;
	local int i;
	local Actor A;

	bSpectator = ( ParseOption( Options, "SpectatorOnly" ) != "" );

	// Make sure there is capacity. (This might have changed since the PreLogin call).
	if ( AtCapacity(bSpectator) )
	{
		Error=GameMessageClass.Default.MaxedOutMessage;
		return None;
	}

	BaseMutator.ModifyLogin(Portal, Options);

	// Get URL options.
	InName     = Left(ParseOption ( Options, "Name"), 20);
	InTeam     = GetIntOption( Options, "Team", 255 ); // default to "no team"
	InPassword = ParseOption ( Options, "Password" );
	InChecksum = ParseOption ( Options, "Checksum" );

	log( "Login:" @ InName );
	if( InPassword != "" )
		log( "Password"@InPassword );
	
	// Pick a team (if need teams)
	InTeam = PickTeam(InTeam);
		 
	// Find a start spot.
	StartSpot = FindPlayerStart( None, InTeam, Portal );

	if( StartSpot == None )
	{
		Error = GameMessageClass.Default.FailedPlaceMessage;
		return None;
	}

	// Init player's administrative privileges

//NEW MJL: support for login as admin to use bAdmin
	if ( PlayerControllerClass == None )
		PlayerControllerClass = class<PlayerController>(DynamicLoadObject(PlayerControllerClassName, class'Class'));

//NEW (mdf) possible player start fix?
	NewPlayer = spawn( PlayerControllerClass,,, StartSpot.Location + vect(0,0,1)*(PlayerControllerClass.default.CollisionHeight - StartSpot.CollisionHeight), StartSpot.Rotation );
/*OLD
	NewPlayer = spawn(PlayerControllerClass,,,StartSpot.Location,StartSpot.Rotation);
*/

	if ( AccessControl.AdminLogin(NewPlayer, InPassword) )
		NewPlayer.PlayerReplicationInfo.bAdmin = true;

/*OLD
	if ( AccessControl.AdminLogin(NewPlayer, InPassword) )
	{
		NewPlayer = spawn(AccessControl.AdminClass,,,StartSpot.Location,StartSpot.Rotation);
		bSpectator = true;
	}
	else
	{
		if ( PlayerControllerClass == None )
			PlayerControllerClass = class<PlayerController>(DynamicLoadObject(PlayerControllerClassName, class'Class'));
		NewPlayer = spawn(PlayerControllerClass,,,StartSpot.Location,StartSpot.Rotation);
	}
*/

	// Handle spawn failure.
	if( NewPlayer == None )
	{
		log("Couldn't spawn player controller of class "$PlayerControllerClass);
		Error = GameMessageClass.Default.FailedSpawnMessage;
		return None;
	}

	NewPlayer.StartSpot = StartSpot;

	// Init player's name
	if( InName=="" )
		InName=DefaultPlayerName;
	if( Level.NetMode!=NM_Standalone || NewPlayer.PlayerReplicationInfo.PlayerName==DefaultPlayerName )
		ChangeName( NewPlayer, InName, false );

	// Init player's replication info
	NewPlayer.GameReplicationInfo = GameReplicationInfo;

//NEW
	NewPlayer.GotoState( PlayerController.SpectatingState );
/*OLD
	NewPlayer.GotoState('Spectating');
*/

	if ( bSpectator )
	{
		NewPlayer.bOnlySpectator = true;
		NumSpectators++;
		return NewPlayer;
	}

	// Change player's team.
	if ( !ChangeTeam(newPlayer, InTeam) )
	{
		Error = GameMessageClass.Default.FailedTeamMessage;
		return None;
	}

	// Set the player's ID.
	NewPlayer.PlayerReplicationInfo.PlayerID = CurrentID++;

	InClass = ParseOption( Options, "Class" );
//NEW
	AdjustPawnClass( InClass );
//OLD
	if ( InClass != "" )
	{
		DesiredPawnClass = class<Pawn>(DynamicLoadObject(InClass, class'Class'));
		if ( DesiredPawnClass != None )
			NewPlayer.PawnClass = DesiredPawnClass;
	}

	// Log it.
	if ( StatLog != None )
		StatLog.LogPlayerConnect(NewPlayer);
	NewPlayer.ReceivedSecretChecksum = !(InChecksum ~= "NoChecksum");

	NumPlayers++;

	// If we are a server, broadcast a welcome message.
	if( Level.NetMode==NM_DedicatedServer || Level.NetMode==NM_ListenServer )
		BroadcastLocalizedMessage(GameMessageClass, 1, NewPlayer.PlayerReplicationInfo);

	// if delayed start, don't give a pawn to the player yet
	// Normal for multiplayer games
	if ( bDelayedStart )
	{
//NEW
		NewPlayer.GotoState( PlayerController.PlayerWaitingState );
/*OLD
		NewPlayer.GotoState('PlayerWaiting');
*/
		return NewPlayer;	
	}

	// Try to match up to existing unoccupied player in level,
	// for savegames and coop level switching.
	ForEach DynamicActors(class'Pawn', TestPawn )
	{
		if ( (TestPawn!=None) && (PlayerController(TestPawn.Controller)!=None) 
			&& (PlayerController(TestPawn.Controller).Player==None) 
			&& (TestPawn.Health > 0)
			&& (TestPawn.OwnerName~=InName) )
		{
			NewPlayer.Destroy();
			TestPawn.SetRotation(TestPawn.Controller.Rotation);
			return PlayerController(TestPawn.Controller);
		}
	}

	// start match, or let player enter, immediately
	bRestartLevel = false;	// let player spawn once in levels that must be restarted after every death
	if ( bWaitingToStartMatch )
		StartMatch();
	else
		RestartPlayer(newPlayer);
	bRestartLevel = Default.bRestartLevel;
	return newPlayer;
}	

/* StartMatch()
Start the game - inform all actors that the match is starting, and spawn player pawns
*/
function StartMatch()
{	
	local Controller P;
	local Actor A; 

	if (StatLog != None)
		StatLog.LogGameStart();

	// tell all actors the game is starting
	ForEach AllActors(class'Actor', A)
		A.MatchStarting();

	// start human players first
	for ( P = Level.ControllerList; P!=None; P=P.nextController )
		if ( P.IsA('PlayerController') && (P.Pawn == None) )
		{
			if ( bGameEnded ) return; // telefrag ended the game with ridiculous frag limit
			else if ( !PlayerController(P).bOnlySpectator  )
				RestartPlayer(P);
			SendStartMessage(PlayerController(P));
		}

	// start AI players
	for ( P = Level.ControllerList; P!=None; P=P.nextController )
		if ( P.bIsPlayer && !P.IsA('PlayerController') )
			RestartPlayer(P);

	bWaitingToStartMatch = false;
}

//
// Restart a player.
//
function RestartPlayer( Controller aPlayer )	
{
	local NavigationPoint startSpot;
	local bool foundStart;
	local int TeamNum,i;
	local class<Pawn> DefaultPlayerClass;
	
	//if( bDelayedStart )
	//	DM( "GameInfo.RestartPlayer #1 " $ aPlayer @ aPlayer.Pawn );

	if( bRestartLevel && Level.NetMode!=NM_DedicatedServer && Level.NetMode!=NM_ListenServer )
		return;

	//if( bDelayedStart )
	//	DM( "GameInfo.RestartPlayer #2 " $ aPlayer @ aPlayer.Pawn );

	if ( (aPlayer.PlayerReplicationInfo == None) || (aPlayer.PlayerReplicationInfo.Team == None) )
		TeamNum = 255;
	else
		TeamNum = aPlayer.PlayerReplicationInfo.Team.TeamIndex;

	startSpot = FindPlayerStart(aPlayer, TeamNum);
	if( startSpot == None )
	{
		log(" Player start not found!!!");
		return;
	}	

	if ( (aPlayer.PlayerReplicationInfo.Team != None)
		&& ((aPlayer.PawnClass == None) || !aPlayer.PlayerReplicationInfo.Team.BelongsOnTeam(aPlayer.PawnClass)) )
			aPlayer.PawnClass = class<Pawn>(DynamicLoadObject(aPlayer.PlayerReplicationInfo.Team.DefaultPlayerClassName, class'Class'));

	if ( aPlayer.PawnClass != None )
		aPlayer.Pawn = Spawn(aPlayer.PawnClass,,,StartSpot.Location,StartSpot.Rotation);

	if( aPlayer.Pawn == None )
	{
		DefaultPlayerClass = class<Pawn>(DynamicLoadObject(GetDefaultPlayerClassName(aPlayer), class'Class'));
		aPlayer.Pawn = Spawn(DefaultPlayerClass,,,StartSpot.Location,StartSpot.Rotation);
	}
	if ( aPlayer.Pawn == None )
	{
		log("Couldn't spawn player of type "$aPlayer.PawnClass$" at "$StartSpot);
//NEW
		aPlayer.GotoState( PlayerController.DeadState );
/*OLD
		aPlayer.GotoState('Dead');
*/
		return;
	}

	aPlayer.Possess(aPlayer.Pawn);
	aPlayer.PawnClass = aPlayer.Pawn.Class;

	PlayTeleportEffect(aPlayer, true, true);
	aPlayer.ClientSetRotation(aPlayer.Pawn.Rotation);

//NEW (mdf) BIG ASS HACK so we don't add inventory which travels in singleplayer?
	RestartPlayerAddDefaultInventory( aPlayer.Pawn );
/*OLD
	AddDefaultInventory(aPlayer.Pawn);
*/	
	TriggerEvent( StartSpot.Event, StartSpot, aPlayer.Pawn);

	//if( bDelayedStart )
	//	DM( "GameInfo.RestartPlayer #3 " $ aPlayer @ aPlayer.Pawn );
}

function string GetDefaultPlayerClassName(Controller C)
{
	return DefaultPlayerClassName;
}

function SendStartMessage(PlayerController P)
{
	P.ClearProgressMessages();
}

//NEW (mdf) BIG ASS HACK so we don't add inventory which travels in singleplayer?
function PostLoginAddDefaultInventory( Pawn P, bool bUseDefaultInventory )
{
	if( !bDelayedStart && bUseDefaultInventory )
		AddDefaultInventory( P );
}

function RestartPlayerAddDefaultInventory( Pawn P )
{
	if( bDelayedStart )
		AddDefaultInventory( P );
}
//OLD

//
// Called after a successful login. This is the first place
// it is safe to call replicated functions on the PlayerPawn.
//
//NEW (mib) travel support
event PostLogin( PlayerController NewPlayer, bool bUseDefaultInventory )
/*OLD
event PostLogin( PlayerController NewPlayer )
*/
{
	local Controller P;
	local class<Scoreboard> S;
	local class<HUD> H;

//NEW (mdf) BIG ASS HACK moved here so we don't add inventory which travels?
	PostLoginAddDefaultInventory( NewPlayer.Pawn, bUseDefaultInventory );
//OLD
	
	// Start player's music.
	NewPlayer.ClientSetMusic( Level.Song, MTRAN_Fade );
	
	// tell client what hud and scoreboard to use
//NEW:
	if( HUDType != "" )
		H = class<HUD>(DynamicLoadObject( HUDType, class'Class') );
	if( ScoreboardType != "" )
		S = class<Scoreboard>(DynamicLoadObject( ScoreboardType, class'Class') );
/*OLD
	H = class<HUD>(DynamicLoadObject(HUDType, class'Class'));
	S = class<Scoreboard>(DynamicLoadObject(ScoreboardType, class'Class'));
*/
	NewPlayer.ClientSetHUD(H,S);

	// Replicate skins - to avoid loading pauses in multiplayer games
	if ( Level.NetMode != NM_Standalone )
	{
		for ( P=Level.ControllerList; P!=None; P=P.NextController )
			if ( P != NewPlayer )
			{
				// send other players' skins to new player
				if ( P.Pawn != None )
				{
					NewPlayer.ClientReplicateSkins(P.Pawn.Skins[0], P.Pawn.Skins[1], P.Pawn.Skins[2], P.Pawn.Skins[3]);
				}
								
				// send new player's skins to any player which hasn't started play yet
				if ( (NewPlayer.Pawn != None)
					&& (P.PlayerReplicationInfo != None) 
					&& P.PlayerReplicationInfo.bWaitingPlayer 
					&& (PlayerController(P) != None) )
				{
					PlayerController(P).ClientReplicateSkins(NewPlayer.Skins[0], NewPlayer.Skins[1], NewPlayer.Skins[2], NewPlayer.Skins[3]);
				}						
			}
	}

	if ( NewPlayer.Pawn != None )
		NewPlayer.Pawn.ClientSetRotation(NewPlayer.Pawn.Rotation);
//NEW
	SendStartMessage( NewPlayer );
//OLD

}

//
// Player exits.
//
function Logout( Controller Exiting )
{
	local bool bMessage;

	bMessage = true;
	if ( PlayerController(Exiting) != None )
	{
		if ( PlayerController(Exiting).bOnlySpectator )
		{
			bMessage = false;
			if ( Level.NetMode == NM_DedicatedServer )
				NumSpectators--;
		}
		else
			NumPlayers--;
	}
	if( bMessage && (Level.NetMode==NM_DedicatedServer || Level.NetMode==NM_ListenServer) )
		BroadcastLocalizedMessage(GameMessageClass, 4, Exiting.PlayerReplicationInfo);

	if ( StatLog != None )
		StatLog.LogPlayerDisconnect(Exiting);
}

//
// 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).
//
event AcceptInventory(pawn PlayerPawn)
{
	//default accept all inventory except default weapon (spawned explicitly)
}

//
// Spawn any default inventory for the player.
//
function AddDefaultInventory( pawn PlayerPawn )
{
	local Weapon newWeapon;
	local class<Weapon> WeapClass;

	// Spawn default weapon.
	WeapClass = BaseMutator.GetDefaultWeapon();
	if( (WeapClass!=None) && (PlayerPawn.FindInventoryType(WeapClass)==None) )
	{
		newWeapon = Spawn(WeapClass,,,PlayerPawn.Location);
		if( newWeapon != None )
		{
			newWeapon.GiveTo(PlayerPawn);
			newWeapon.BringUp();
			newWeapon.bCanThrow = false; // don't allow default weapon to be thrown out
		}
	}
	SetPlayerDefaults(PlayerPawn);
}

/* SetPlayerDefaults()
 first make sure pawn properties are back to default, then give mutators an opportunity
 to modify them
*/
function SetPlayerDefaults(Pawn PlayerPawn)
{
	PlayerPawn.JumpZ = PlayerPawn.Default.JumpZ;
	PlayerPawn.AirControl = PlayerPawn.Default.AirControl;
	BaseMutator.ModifyPlayer(PlayerPawn);
}

//NEW (mdf)
function NotifyKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType )
{
	local Controller C;

	for ( C=Level.ControllerList; C!=None; C=C.nextController )
		C.NotifyKilled( Killer, Killed, KilledPawn, DamageType );
}
/*OLD
function NotifyKilled(Controller Killer, Controller Killed, Pawn KilledPawn )
{
	local Controller C;

	for ( C=Level.ControllerList; C!=None; C=C.nextController )
		C.NotifyKilled(Killer, Killed, KilledPawn);
}
*/

function Killed( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> damageType )
{
	local Controller C;
	local String Message, KillerWeapon, OtherWeapon;
	local name logtype;

	//-------------------------------------------------------------------------
	// !!mdf-tbr: dump controller status for debugging
	//DM( " " );
	//DM( "Killed -- dumping Controllers BEGIN" );
	//for( C=Level.ControllerList; C!=None; C=C.NextController )
	//	C.DMTNS( "Pawn=" $ C.Pawn $ " Enemy=" $ C.ControllerEnemy );
	//DM( "Killed -- dumping Controllers END" );
	//DM( " " );
	// !!mdf-tbr: dump controller status for debugging
	//-------------------------------------------------------------------------

//NEW (mdf)
	NotifyKilled( Killer, Killed, KilledPawn, DamageType );
/*OLD
	NotifyKilled(Killer,Killed,KilledPawn);
*/

	if ( Killed.bIsPlayer )
	{
//NEW (mdf) -- this probably isn't supposed to be here -- deaths getting incremented 2x, once here, once in ScoreKill
/*
		Killed.PlayerReplicationInfo.Deaths += 1;
*/
		BroadcastDeathMessage(Killer, Killed, damageType);
		if ( (StatLog != None) && (Killer != None) && Killer.bIsPlayer )
		{
			if ( DamageType.Default.DamageWeaponName != "" )
				KillerWeapon = DamageType.Default.DamageWeaponName;
			else
				KillerWeapon = "None";

			if (KilledPawn.Weapon != None)
				OtherWeapon = KilledPawn.Weapon.ItemName;
			else
				OtherWeapon = "None";
			StatLog.LogKill(
				Killer.PlayerReplicationInfo,
				Killed.PlayerReplicationInfo,
				KillerWeapon,
				OtherWeapon,
				damageType
			);
		}
	}
	ScoreKill(Killer, Killed);
	if( KilledPawn.bCanDiscardInventory )	//NEW (arl) Looks dumb when the player throws the weapon in the new GameOver handling.
		DiscardInventory(KilledPawn);
}

function bool PreventDeath(Pawn Killed, Controller Killer, class<DamageType> damageType, vector HitLocation)
{
	if ( GameRulesModifiers == None )
		return false;
	return GameRulesModifiers.PreventDeath(Killed,Killer, damageType,HitLocation);
}

function BroadcastDeathMessage(Controller Killer, Controller Other, class<DamageType> damageType)
{
	if ( (Killer == Other) || (Killer == None) )
		BroadcastLocalizedMessage(DeathMessageClass, 1, None, Other.PlayerReplicationInfo, damageType);
	else 
		BroadcastLocalizedMessage(DeathMessageClass, 0, Killer.PlayerReplicationInfo, Other.PlayerReplicationInfo, damageType);
}


// %k = Owner's PlayerName (Killer)
// %o = Other's PlayerName (Victim)
// %w = Owner's Weapon ItemName
static native function string ParseKillMessage( string KillerName, string VictimName, string DeathMessage );

function Kick( string S )
{
	AccessControl.Kick(S);
}
function KickBan( string S )
{
	AccessControl.KickBan(S);
}

function bool IsOnTeam(Controller Other, int TeamNum)
{
	if ( bTeamGame && (Other != None) && (Other.PlayerReplicationInfo.Team.TeamIndex == TeamNum) )
		return true;
	return false;
}

//-------------------------------------------------------------------------------------
// Level gameplay modification.

//
// Return whether Viewer is allowed to spectate from the
// point of view of ViewTarget.
//
function bool CanSpectate( PlayerController Viewer, actor ViewTarget )
{
	return true;
}

/* Use reduce damage for teamplay modifications, etc.
*/
//NEW (mdf) refactored ReduceDamage (U2 doesn't call the Super directly)
function int ArmorReduceDamage( int Damage, Pawn Injured, class<DamageType> DamageType, vector HitLocation )
{
	local Armor FirstArmor;
	
	FirstArmor = Injured.Inventory.PrioritizeArmor( Damage, DamageType, HitLocation );
	while( FirstArmor != None && Damage > 0 )
	{
		Damage = FirstArmor.ArmorAbsorbDamage( Damage, DamageType, HitLocation );
		FirstArmor = FirstArmor.nextArmor;
	} 
	
	return Damage;
}

function int ReduceDamage( int Damage, Pawn Injured, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local int OriginalDamage;

	OriginalDamage = Damage;

	if( Injured.PhysicsVolume.bNeutralZone )
		Damage = 0;
	else if ( Injured.InGodMode() ) // God mode
		Damage = 0;
	else if ( (Injured.Inventory != None) && (damage > 0) ) //then check if carrying armor
		Damage = ArmorReduceDamage( Damage, Injured, DamageType, HitLocation );

	if ( GameRulesModifiers != None )
		return GameRulesModifiers.NetDamage( OriginalDamage, Damage, Injured, Instigator, HitLocation, Momentum, DamageType );

	return Damage;
}
/*OLD
function int ReduceDamage( int Damage, pawn injured, pawn instigatedBy, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local int OriginalDamage;
	local armor FirstArmor;
	local int ArmorDamage;

	OriginalDamage = Damage;

	if( injured.PhysicsVolume.bNeutralZone )
		Damage = 0;
	else if ( injured.InGodMode() ) // God mode
		Damage = 0;
	else if ( (injured.Inventory != None) && (damage > 0) ) //then check if carrying armor
	{
		FirstArmor = injured.inventory.PrioritizeArmor(Damage, DamageType, HitLocation);
		while( (FirstArmor != None) && (Damage > 0) )
		{
			Damage = FirstArmor.ArmorAbsorbDamage(Damage, DamageType, HitLocation);
			FirstArmor = FirstArmor.nextArmor;
		} 
	}

	if ( GameRulesModifiers != None )
		return GameRulesModifiers.NetDamage( OriginalDamage, Damage,injured,instigatedBy,HitLocation,Momentum,DamageType );

	return Damage;
}
*/
//
// Return whether an item should respawn.
//
function bool ShouldRespawn( Pickup Other )
{
	if( Level.NetMode == NM_StandAlone )
		return false;

	return Other.ReSpawnTime!=0.0;
}

/* Called when pawn has a chance to pick Item up (i.e. when 
   the pawn touches a weapon pickup). Should return true if 
   he wants to pick it up, false if he does not want it.
*/
function bool PickupQuery( Pawn Other, Pickup item )
{
	local byte bAllowPickup;

	if ( (GameRulesModifiers != None) && GameRulesModifiers.OverridePickupQuery(Other, item, bAllowPickup) )
		return (bAllowPickup == 1);

	if ( Other.Inventory == None )
		return true;
	else
		return !Other.Inventory.HandlePickupQuery(Item);
}
		
/* Discard a player's inventory after he dies.
*/
function DiscardInventory( Pawn Other )
{
	local actor dropped;
	local inventory Inv,Next;
	local float speed;

	if( (Other.Weapon!=None) && Other.Weapon.bCanThrow && Other.Weapon.HasAmmo() )
	{
		if ( Other.Weapon.PickupAmmoCount == 0 )
			Other.Weapon.PickupAmmoCount = 1;
//NEW
		Other.TossWeapon(Other.Velocity*0.75);
/*OLD
		speed = VSize(Other.Velocity);
		if (speed != 0)
			Other.TossWeapon(Normal(Other.Velocity/speed + 0.5 * VRand()) * (speed + 280));
		else 
			Other.TossWeapon(vect(0,0,0));
*/
	}
//NEW
	if( Other.Weapon != None )
		Other.Weapon.ClearWeaponEffects();
//OLD

//NEW
	DestroyInventory( Other );
/*OLD
	Other.Weapon = None;
	Other.SelectedItem = None;
    Inv = Other.Inventory;
	while ( Inv != None )
	{
		Next = Inv.Inventory;
		Inv.Destroy();
		Inv = Next;
	}	
*/
}

//NEW 
function DestroyInventory( Pawn PlayerPawn )
{
	local Inventory Inv, NextInv;

	// destroy all inventory except our weapon weapon which is tossed
	// and will be added to the pickup's inventory
	Inv = PlayerPawn.Inventory;
	while( Inv != None )
	{
		if( Inv != PlayerPawn.Weapon )
		{
			NextInv = Inv.Inventory;
			Inv.Destroy();
			Inv = NextInv;
		}
		else
			Inv = Inv.Inventory;
	}

	PlayerPawn.Inventory = None;
	PlayerPawn.Weapon = None;
	PlayerPawn.SelectedItem = None;
}
//OLD


/* Try to change a player's name.
*/	
function ChangeName( Controller Other, coerce string S, bool bNameChange )
{
	if( S == "" )
		return;
	if ( StatLog != None)
		StatLog.LogNameChange(Other);
	Other.PlayerReplicationInfo.SetPlayerName(S);
	if( bNameChange && (PlayerController(Other) != None) )
		BroadcastLocalizedMessage( GameMessageClass, 2, Other.PlayerReplicationInfo );			
}

/* Return whether a team change is allowed.
*/
function bool ChangeTeam(Controller Other, int N)
{
	return true;
}

/* Return a picked team number if none was specified
*/
function byte PickTeam(byte Current)
{
	return Current;
}

/* Play an inventory respawn effect.
*/
function float PlaySpawnEffect( pickup P )
{
	return 0.3;
}

/* Send a player to a URL.
*/
function SendPlayer( PlayerController aPlayer, string URL )
{
	aPlayer.ClientTravel( URL, TRAVEL_Relative, true );
}

/* Play a teleporting special effect.
*/
function PlayTeleportEffect( actor Incoming, bool bOut, bool bSound)
{
	Incoming.MakeNoise(1.0);
}

/* Restart the game.
*/
function RestartGame()
{
	local string NextMap;
	local MapList myList;
	local class<MapList> ML;

	if ( (GameRulesModifiers != None) && GameRulesModifiers.HandleRestartGame() )
		return;

	// these server travels should all be relative to the current URL
	if ( bChangeLevels && !bAlreadyChanged && (MapListType != "") )
	{
		// open a the nextmap actor for this game type and get the next map
		bAlreadyChanged = true;
		ML = class<MapList>(DynamicLoadObject(MapListType, class'Class'));
		myList = spawn(ML);
		NextMap = myList.GetNextMap();
		myList.Destroy();
		if ( NextMap == "" )
			NextMap = GetMapName(MapPrefix, NextMap,1);

		if ( NextMap != "" )
		{
			Level.ServerTravel(NextMap, false);
			return;
		}
	}

	Level.ServerTravel( "?Restart", false );
}

//==========================================================================
// Message broadcasting functions (handled by the BroadCastHandler)

event Broadcast( Actor Sender, coerce string Msg, optional name Type )
{
	BroadcastHandler.Broadcast(Sender,Msg,Type);
}

function BroadcastTeam( Controller Sender, coerce string Msg, optional name Type )
{
	BroadcastHandler.BroadcastTeam(Sender,Msg,Type);
}

/*
 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.
*/
event BroadcastLocalized( actor Sender, class<LocalMessage> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject )
{
	BroadcastHandler.AllowBroadcastLocalized(Sender,Message,Switch,RelatedPRI_1,RelatedPRI_2,OptionalObject);
}

//==========================================================================

//NEW	
function CheckForEndGame()					{}
function float GetLevelRatingOffensive()	{ return -1.0; }	// help NPCs (mainly bots) decide if they have enough offensive inventory to attack with
function float GetLevelRatingDefensive()	{ return -1.0; }	// help NPCs (mainly bots) decide if they have enough defensive inventory to attack with
//OLD

function bool CheckEndGame(PlayerReplicationInfo Winner, string Reason)
{
	local Controller P;

	if ( (GameRulesModifiers != None) && !GameRulesModifiers.CheckEndGame(Winner, Reason) )
		return false;

	// all player cameras focus on winner or final scene (picked by gamerules)
	for ( P=Level.ControllerList; P!=None; P=P.NextController )
	{
		P.ClientGameEnded();
//NEW
		P.GotoState( PlayerController.GameEndedState );
/*OLD
		P.GotoState('GameEnded');
*/
	}	
	return true;
}

/* End of game.
*/
function EndGame( PlayerReplicationInfo Winner, string Reason )
{
	// don't end game if not really ready
	if ( !CheckEndGame(Winner, Reason) )
	{
		bOverTime = true;
		return;
	}

	bGameEnded = true;
	TriggerEvent('EndGame', self, None);
	EndLogging(Reason);
}

function EndLogging(string Reason)
{
	if ( StatLog == None )
		return;
	StatLog.LogGameEnd(Reason);
	StatLog.StopLog();
	StatLog.Destroy();
	StatLog = None;
}

/* Return the 'best' player start for this player to start from.
 */
function NavigationPoint FindPlayerStart( Controller Player, optional byte InTeam, optional string incomingName )
{
	local NavigationPoint N, BestStart;
	local Teleporter Tel;
	local float BestRating, NewRating;
	local byte Team;

	// always pick StartSpot at start of match
	if ( (Player != None) && (Player.StartSpot != None)
		&& (bWaitingToStartMatch || ((Player.PlayerReplicationInfo != None) && Player.PlayerReplicationInfo.bWaitingPlayer))  )
	{
		return Player.StartSpot;
	}	

	if ( GameRulesModifiers != None )
	{
		N = GameRulesModifiers.FindPlayerStart(Player,InTeam,incomingName);
		if ( N != None )
		    return N;
	}

	// if incoming start is specified, then just use it
	if( incomingName!="" )
		foreach AllActors( class 'Teleporter', Tel )
			if( string(Tel.Tag)~=incomingName )
				return Tel;

	// use InTeam if player doesn't have a team yet
	if ( (Player != None) && (Player.PlayerReplicationInfo != None) )
	{
		if ( Player.PlayerReplicationInfo.Team != None )
			Team = Player.PlayerReplicationInfo.Team.TeamIndex;
		else
			Team = 0;
	}
	else
		Team = InTeam;

	for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
	{
//NEW (mdf) fix
		if( !N.bDeleteMe )
			NewRating = RatePlayerStart(N,InTeam,Player);
		else
			NewRating = -1.0;
/*OLD
		NewRating = RatePlayerStart(N,InTeam,Player);
*/
//NEW (mdf) -- otherwise BestStart never gets set in many cases...?
		if ( NewRating >= BestRating )
/*OLD
		if ( NewRating > BestRating )
*/
		{
			BestRating = NewRating;
			BestStart = N;
		}
	}
	
	if ( BestStart == None )
	{
		log("Warning - PATHS NOT DEFINED or NO PLAYERSTART");			
		foreach AllActors( class 'NavigationPoint', N )
		{
			NewRating = RatePlayerStart(N,0,Player);
			if ( NewRating > BestRating )
			{
				BestRating = NewRating;
				BestStart = N;	
			}
		}
	}

	return BestStart;
}

/* Rate whether player should choose this NavigationPoint as its start
default implementation is for single player game
*/
function float RatePlayerStart(NavigationPoint N, byte Team, Controller Player)
{
	local PlayerStart P;

	P = PlayerStart(N);
	if ( P != None )
	{
		if ( P.bSinglePlayerStart )
		{
			if ( P.bEnabled )
				return 1000;
			return 20;
		}
		return 10;
	}
	return 0;
}

function ScoreObjective(PlayerReplicationInfo Scorer, Int Score)
{
	if ( Scorer != None )
	{
		Scorer.Score += Score;
		if ( Scorer.Team != None )
			Scorer.Team.Score += Score;
	}
	if ( GameRulesModifiers != None )
		GameRulesModifiers.ScoreObjective(Scorer,Score);

	CheckScore(Scorer);
}

/* CheckScore()
see if this score means the game ends
*/
function CheckScore(PlayerReplicationInfo Scorer)
{
	if ( (GameRulesModifiers != None) && GameRulesModifiers.CheckScore(Scorer) )
		return;
}
	
function ScoreKill(Controller Killer, Controller Other)
{
	if( (killer == Other) || (killer == None) )
//NEW (mdf) Fix
	{
		if ( Other.PlayerReplicationInfo != None )
			Other.PlayerReplicationInfo.Score -= 1;
	}
/*OLD
		Other.PlayerReplicationInfo.Score -= 1;
*/
	else if ( killer.PlayerReplicationInfo != None )
		killer.PlayerReplicationInfo.Score += 1;

	if ( GameRulesModifiers != None )
		GameRulesModifiers.ScoreKill(Killer, Other);

//NEW (mdf) Fix - grr
	if( Killer != None )
//OLD
	CheckScore(Killer.PlayerReplicationInfo);
}

//NEW (mdf)
function byte GetDifficulty()
{
	return Difficulty;
}

function SetDifficulty( byte _Difficulty )
{
	 Difficulty = Clamp( _Difficulty, 0, MaxDifficulty );
}

function byte GetMaxDifficulty()
{
	return MaxDifficulty;
}

function float GetNormalizedDifficulty()
{
	return Difficulty / float(MaxDifficulty);
}
//OLD

defaultproperties
{
	Difficulty=1
	MaxDifficulty=2
	bRestartLevel=true
	bPauseable=true
	bCanChangeSkin=true
	bCanViewOthers=true
	bWaitingToStartMatch=true
	bChangeLevels=true
	bReloadsEnabled=true
	bAllowGore=true
	AutoAim=0.930000
	GameSpeed=1.000000
	bDisplayHud=true
	HUDType="Engine.HUD"
	MaxSpectators=2
	MaxPlayers=16
	DefaultPlayerName="Player"
	GameName="Game"
	DeathMessageClass=Class'Engine.LocalMessage'
	GameMessageClass=Class'Engine.GameMessage'
	MutatorClass="Engine.Mutator"
	AccessControlClass="Engine.AccessControl"
	BroadcastHandlerClass="Engine.BroadcastHandler"
	PlayerControllerClassName="U2.U2PlayerNetTestController"
	GameReplicationInfoClass=Class'Engine.GameReplicationInfo'
	bLocalLog=true
	bWorldLog=true
	StatLogClass=Class'Engine.StatLogFile'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}