U2.U2GameInfo

//=============================================================================
// $Workfile: U2GameInfo.uc $
// Created By: Mark Poesch
// Created On: 9/1/2000
// $Author: Mfox $
// $Date: 3/03/03 5:39p $
// $Revision: 98 $
//=============================================================================
class U2GameInfo extends DialogGameInfo;

/*-----------------------------------------------------------------------------
NOTE: See CutsceneGameInfo.uc comments. In some (probably rare) cases, changes 
to this class will need to be reflected in CutsceneGameInfo and vice-versa.
*/

const MaxTeams = 4;							// max # teams for any game type

const GF_NOIMPACTS			= 0x01;			// disable impacts

struct TPrecacheInfo
{
	var class<Actor> ActorClass;
	var vector SpawnLocation;
};

var() config float FriendlyDamageScale;		// scale friendly fire damage by this value
var() config float DamageToPlayerScalars[3];// scale damage to player based on game difficulty (singleplayer only, hard-coded to 3 difficulty levels)
var() config float DamageByPlayerScalars[3];// scale damage to player based on game difficulty (singleplayer only, hard-coded to 3 difficulty levels)
var() config float PlayerDamageScaleMin;	// scale player damage by this value at min difficulty
var() config float PlayerDamageScaleMax;	// scale player damage by this value at max difficulty
var config float AirControl;				// air control varies from one gametype to another
var config float SpeedRatio;				// non-player speed boosted in DM/CTF/XMP, reduced on the Atlantis
var config float PlayerSpeedRatio;			// player speed boosted in DM/CTF/XMP, reduced on the Atlantis
var() bool bSinglePlayerMission;			//
var() float RespawnAppearanceDelay;			//

var config bool	bForcedWeaponSwitch;		// if true, game forces switch to new weapons regardless of priority
var config bool bMultiWeaponStay;			// weapons stay parameter for DM and sub game types
var config int MinPlayers;					// bots fill in to guarantee this level in net game 
var int NumBots;							// number of Bots active in the game

var() bool bUseCombatSounds;
var() bool bGiveDefaultWeapon;
var() bool bKeepTossedPickups;				// set to false to allow tossed pickups to destroy themselves after a while

var float DefaultFOV;						// if non-zero this will be used for the player's initial fov

var SoundSlotTimerListImpl SoundSlotTimerList;

var() globalconfig bool bBroadcastObjectives;

var float BSMTime;
var Color BSMColor;

// Ragdoll detail level, 0=Off, 1=Low, 2=Medium, 3=High
// For non-zero values, mesh agents can choose to use ragdoll or not based on this
// level (it's passed in as an agent input), since the mesh knows how complex/slow
// it is ragdoll-wise (based on solid & joint count etc).
var() globalconfig int RagdollDetailLevel; //NOTE (mdf): controls ragdoll hits
var() globalconfig int MaxRagdollDeaths;

var int ActiveRagdollDeaths;

var array<ComponentHandle> UIComponents;

//-----------------------------------------------------------------------------
// AI data
//-----------------------------------------------------------------------------

var config array<string> GameAIControllerClasses;
var array<GameAIControllerInterf> GameAIControllers;

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

event PreBeginPlay()
{
	Super.PreBeginPlay();

	if( InStr( GetCommandLine(), "newai" ) != -1 )
		Log( "Warning: newai forced!" );
	if( InStr( GetCommandLine(), "oldai" ) != -1 )
		Log( "Warning: oldai forced!" );

	AllocateSoundSlotTimerList();
	
	PrecacheItems( Self );
}

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

event PostBeginPlay()
{
	Super.PostBeginPlay();

	// note: needs to be done after all other actors spawned so flags found etc.
	AllocateGameAIControllers();
}

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

event PostLogin( PlayerController NewPlayer, bool bUseDefaultInventory )
{
	Super.PostLogin( NewPlayer, bUseDefaultInventory );
	if( bUseDefaultInventory )
	{
		//DMTNS("PostLogin -- switching to bestest weapon");
		NewPlayer.SwitchToBestWeapon();
	}
}

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

event Destroyed()
{
	local int ii;
	
	if( SoundSlotTimerList != None )
	{
		SoundSlotTimerList.Delete();
		SoundSlotTimerList = None;
	}
	
	for( ii=0; ii<GameAIControllers.Length; ii++ )
	{
		GameAIControllers[ ii ].Cleanup();
		GameAIControllers[ ii ] = None;
	}
	GameAIControllers.Length = 0;
	
	Super.Destroyed();
}
		
//-----------------------------------------------------------------------------

function SoundSlotTimerListImpl GetSoundSlotTimerList( name Tag )
{
	local SoundSlotTimerListImpl Iter;

	// search by tag
	if( Tag != '' )
	{
		foreach AllActors( class'SoundSlotTimerListImpl', Iter, Tag )
			return Iter;

		// couldn't find list by tag
		DMT("Unable to find sound slot timer list with tag: '" $ Tag $ "'" );
	}

	// use default
	return SoundSlotTimerList;
}

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

static function SpawnTemporaryPrecacheInstance( Actor ContextActor, class<Actor> ActorClass, vector TargetLocation )
{
	local Actor A;

	// don't check for collision / encroachment when spawning actor
	A = ContextActor.Spawn( ActorClass, /*SpawnOwner*/, /*SpawnTag*/, TargetLocation, /*SpawnRotation*/, /*SpawnTemplate*/, /*Spawner*/, true );
	if( A != None )
	{
		A.SetDrawScale( 0.001 );
		A.Lifespan = 0.0001;
		A.SetPhysics( PHYS_None );
		A.SetCollision( false, false, false ); // or get a crash if location on/near a mover like in TutB?
		A.bCollideWorld = false;
		A.AnimFrame = 0.0;
		A.AnimRate = 0.0;
		A.AmbientSound = None;
		//2002.12.15 borks deletion of actor if doing restart level (other?) since never ticked?
		//A.bStasis = true;
		if( Pawn(A) != None )
		{
			Pawn(A).Alertness = 0.0;
			Pawn(A).SightRadius = 0.0;
			Pawn(A).SightRadiusFriend = 0.0;
			Pawn(A).SightRadiusFriendAlert = 0.0;
			Pawn(A).HearingThreshold = 0.0;
			Pawn(A).Visibility = -1;
			Pawn(A).SeenRadius = 0.0;
			
			LicenseePawn(A).WentDormant( true );
			//NOTE: making the Controller bStasis=true crashes TutB (something interacts with mover?)
		}
		ContextActor.DM( "    SpawnTemporaryPrecacheInstance spawned " $ A );
	}
	else
	{
		ContextActor.DM( "    SpawnTemporaryPrecacheInstance failed to spawn a " $ ActorClass $ " at " $ TargetLocation );
		//AddCylinder( TargetLocation, ActorClass.default.CollisionRadius, ActorClass.default.CollisionHeight, ColorOrange() );
	}
}

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

static function GetActorFactoryItems( Actor ContextActor, out array<TPrecacheInfo> PrecacheList )
{
	local ActorFactory AF;
	local SpawnPoint SP, TargetSpawnPoint;
	local bool bFound;
	local int ii, ListLen, AddedCount;
			
	foreach ContextActor.DynamicActors( class'ActorFactory', AF )
	{
		if( AF.ProtoType == None )
		{
			ContextActor.DM( "  WARNING (GetActorFactoryItems): actor factory " $ AF $ " has no ProtoType?" );
			continue;
		}
			
		// see if class already in list
		bFound = false;
		ListLen = PrecacheList.Length;
		for( ii=0; ii<ListLen && !bFound; ii++ )
		{
			if( PrecacheList[ ii ].ActorClass == AF.ProtoType )
				bFound = true;
		}
		
		if( !bFound )
		{
			// find at least one of the SpawnPoints associated with this actor 
			// factory (which may not have been initialized yet)
			foreach ContextActor.AllActors( class'SpawnPoint', SP, AF.Tag )
				TargetSpawnPoint = SP;
		
			if( TargetSpawnPoint != None )
			{
				PrecacheList.Length = PrecacheList.Length + 1;
				PrecacheList[ ListLen ].ActorClass = AF.ProtoType;
				PrecacheList[ ListLen ].SpawnLocation = TargetSpawnPoint.Location;
				AddedCount++;
			}
			else
			{
				ContextActor.DM( "  WARNING (GetActorFactoryItems): actor factory " $ AF $ " has no SpawnPoints?" );
			}
		}
	}

	ContextActor.DM( "  ActorFactory added: " $ AddedCount $ " classes" );
}

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

static function GetLevelInfoItems( Actor ContextActor, out array<TPrecacheInfo> PrecacheList )
{
	local bool bFoundTargetActor;
	local vector TargetLocation;
	local NavigationPoint Nav;
	local bool bFound;
	local int ii, jj, ListLen, AddedCount;

	// spawn them in front of the PlayerStart?
	TargetLocation = vect(0,0,0);
	for( Nav = ContextActor.Level.NavigationPointList; Nav != None && !bFoundTargetActor; Nav = Nav.NextNavigationPoint )
	{
		if( PlayerStart(Nav) != None )
		{
			TargetLocation = Nav.Location + 128.0*vector(Nav.Rotation);
			bFoundTargetActor = true;
		}
	}

	if( bFoundTargetActor )
	{
		for( ii=0; ii<ContextActor.Level.PrecacheList.Length; ii++ )
		{
			bFound = false;
			ListLen = PrecacheList.Length;
			for( jj=0; jj<ListLen && !bFound; jj++ )
			{
				if( PrecacheList[ jj ].ActorClass == ContextActor.Level.PrecacheList[ ii ] )
					bFound = true;
			}
		
			if( !bFound )
			{
				PrecacheList.Length = PrecacheList.Length + 1;
				PrecacheList[ ListLen ].ActorClass = ContextActor.Level.PrecacheList[ ii ];
				PrecacheList[ ListLen ].SpawnLocation = TargetLocation;
				AddedCount++;
			}				
		}
	}
	else
	{
		ContextActor.DM( "  WARNING (GetLevelInfoItems): couldn't find PlayerStart?" );
	}
	
	ContextActor.DM( "  LevelInfo.PreCacheList added: " $ AddedCount $ " classes" );	
}

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

static function PrecacheItems( Actor ContextActor )
{
	local int ii;
	local array<TPrecacheInfo> LocalPrecacheList;
	
	if( ContextActor.Level.bPrecacheActors )
	{		
		ContextActor.DM( "precaching actors" );
		LocalPrecacheList.Length = 0;
		GetActorFactoryItems( ContextActor, LocalPrecacheList );
		GetLevelInfoItems( ContextActor, LocalPrecacheList );
		
		for( ii=0; ii<LocalPrecacheList.Length; ii++ )
			SpawnTemporaryPrecacheInstance( ContextActor, LocalPrecacheList[ ii ].ActorClass, LocalPrecacheList[ ii ].SpawnLocation );
	}
	else
	{
		ContextActor.DM( "NOT precaching actors" );
	}
}

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

function AllocateSoundSlotTimerList()
{
	if( SoundSlotTimerList == None )
		SoundSlotTimerList = Spawn( class'SoundSlotTimerListU2' );
}

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

//Fix ARL: Add support for being able to specify different HUD in .ini (e.g. botpack one for using HUD mutator...)

//ARL (mwp) Mulitplayer StartServer UI should have "Dedicated | Listen" menu option and one "Start" button.
//          Then, when "Listen server" is selected, MaxSpectators can be forced to stay 0.

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

function NotifyKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType )
{
	local SceneManager SM;
	local U2Pawn KP;

	Super.NotifyKilled( Killer, Killed, KilledPawn, DamageType );

	// turn off matinee while player is dying
	if( KilledPawn.IsRealPlayer() )
	{
		foreach AllActors( class'SceneManager', SM )
			SM.Disable( 'Trigger' );
	}
	
	KP = U2Pawn( KilledPawn );
	if( KP? )
	{
		// Save off PowerSuit Energy so DroppedEnergy has something to work with.
		KP.RemainingPowerSuitEnergy = KP.GetPowerSuit();
	}
}


//-----------------------------------------------------------------------------
// team games
//-----------------------------------------------------------------------------

function TeamInfo GetTeam( int InTeamNumber );

//-----------------------------------------------------------------------------
// XMP
//-----------------------------------------------------------------------------

function ScoreReplicatorShutdown( Pawn Other );

//-----------------------------------------------------------------------------
// Inventory
//-----------------------------------------------------------------------------

function AddDefaultInventory( Pawn PlayerPawn )
{
	local int i;

	super.AddDefaultInventory( PlayerPawn );

	// add default inventory and weapon for Bots and Players -- handling for NPCs is implemented within U2Pawn.uc Possess()
	U2Pawn(PlayerPawn).AssignDefaultInventory();
	if( bGiveDefaultWeapon )
		class'UtilGame'.static.GiveInventoryString( PlayerPawn, U2Pawn(PlayerPawn).DefaultWeapon );
	
	// add level-specific default inventory to the player
	assert( PlayerPawn != None );
	if( PlayerPawn.IsHumanControlled() )
	{
		for( i = 0; i < Level.DefaultInventory.Length; i++ )
		{
			if( Level.DefaultInventory[i] != None )
				assert( class'UtilGame'.static.GiveInventoryClass( PlayerPawn, Level.DefaultInventory[i] ) != None );
		}
	}
}

//-----------------------------------------------------------------------------
// MISC
//-----------------------------------------------------------------------------

function SetDifficulty( byte _Difficulty )
{
	Super.SetDifficulty(_Difficulty);
	if(Difficulty==0)	bBroadcastObjectives=true;
	else				bBroadcastObjectives=false;
}

function UpdateObjective( name Tag, LevelInfo.ELevelObjectiveStatus Status, sound NotifySound )
{
	local Controller C;
	local array<string> Text;
	local int i;

	Text = Level.UpdateObjective( Tag, Status );

	if( !NotifySound )
		return;

	if( bBroadcastObjectives && Text.length>0 )
	{
		for(i=0;i<Text.length;i++)
		{
			class'UIConsole'.static.BroadcastStatusMessage( Self,
				Text[i],
				8.0 /*time*/, /*font*/, /*color*/,
				NotifySound, /*volume*/, /*pitch*/,
				"ObjectiveHolder", false/*clear existing*/, 574 );

			NotifySound=None;
		}
	}
	else
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
			if( PlayerController(C)? )
				C.PlaySound(NotifySound);

		switch(Status)
		{
		case OBJECTIVE_Incomplete:	class'UIConsole'.static.SendEvent("NewObjective");			break;
		case OBJECTIVE_Completed:	class'UIConsole'.static.SendEvent("ObjectiveCompleted");	break;
		case OBJECTIVE_Failed:		class'UIConsole'.static.SendEvent("ObjectiveFailed");		break;
		}
	}
}

function array<string> GetObjectives()
{
	return Level.GetObjectives();
}

static function ScaleMovementSpeeds( Pawn P )
{
	if( P.IsRealPlayer() )
		P.GroundSpeed	= default.PlayerSpeedRatio * P.default.GroundSpeed;
	else
		P.GroundSpeed	= default.SpeedRatio * P.default.GroundSpeed;
		
	P.AirSpeed		= default.SpeedRatio * P.default.AirSpeed;
	P.WaterSpeed	= default.SpeedRatio * P.default.WaterSpeed;
	P.LadderSpeed	= default.SpeedRatio * P.default.LadderSpeed;

	LicenseePawn(P).UpdateWalkingPct();
}


function SetPlayerDefaults( Pawn PlayerPawn ) // override GameInfo.SetPlayerDefaults()
{
	PlayerPawn.JumpZ = PlayerPawn.Default.JumpZ; 
	PlayerPawn.AirControl = AirControl;
	ScaleMovementSpeeds( PlayerPawn );
	PlayerPawn.DamageScaling = PlayerPawn.default.DamageScaling;

	BaseMutator.ModifyPlayer( PlayerPawn );
}


function bool ShouldRespawn( Pickup Other )
{
	return false;
}


function float PlaySpawnEffect( Pickup Inv )
{
	// do nothing
	return RespawnAppearanceDelay;
}


function PlayTeleportEffect( Actor Incoming, bool bOut, bool bSound ); // do nothing

function int ReduceFriendlyDamage( int Damage, Pawn Injured, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	if( DamageType == class'Suicided' )
		return Damage;
		
	return ( Damage * FriendlyDamageScale );
}

function float GetDamageToPlayerScalar()
{
	return DamageToPlayerScalars[ Difficulty ];
}

function float GetDamageByPlayerScalar()
{
	return DamageByPlayerScalars[ Difficulty ];
}

function int ScaleDamageToPlayer( int Damage, Pawn Injured, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local float DamageFloat;
	
	if( DamageType == class'DamageTypeImpact' )
		return Damage;

	DamageFloat = Damage * GetDamageToPlayerScalar();
			
	return FMax( 1.0, Round( DamageFloat ) );
}

function int ScaleDamageByPlayer( int Damage, Pawn Injured, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local float DamageFloat;
	
	DamageFloat = Damage * GetDamageByPlayerScalar();
	
	return FMax( 1.0, Round( DamageFloat ) );
}

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

	// valid pawn check
	if( Injured == None || Injured.bDeleteMe )
		Damage = 0;

	// god mode check
	if( Damage > 0 && Injured.InGodMode() )
		Damage = 0;

	// no damage zone check
	if( Injured.PhysicsVolume.bNeutralZone )
		Damage = 0;
		
	// reduce damage due to friendly fire		
	//DMTNS( "&&& Damage before ReduceFriendlyDamage: " $ Damage );
	if( Damage > 0 && Instigator != None && Instigator != Injured && Injured.SameTeam( Instigator ) )
		Damage = ReduceFriendlyDamage( Damage, Injured, Instigator, HitLocation, Momentum, DamageType );
	//DMTNS( "&&& Damage after ReduceFriendlyDamage:  " $ Damage );
		
	// reduce damage for player getting hit
	//DMTNS( "&&& Damage before ReduceDamageTo/ByPlayer:  " $ Damage );
	if( Damage > 0 )
	{
		if( Injured != None && Injured.bIsRealPlayer )
			Damage = ScaleDamageToPlayer( Damage, Injured, Instigator, HitLocation, Momentum, DamageType );
		else if( Instigator != None && Instigator.bIsRealPlayer )
			Damage = ScaleDamageByPlayer( Damage, Injured, Instigator, HitLocation, Momentum, DamageType );
	}
	//DMTNS( "&&& Damage after ReduceDamageTo/ByPlayer:  " $ Damage );
		
	// let armor filter damage
	//DMTNS( "&&& Damage before ArmorReduceDamage:  " $ Damage );
 	if( Damage > 0 && Injured.Inventory != None )
		Damage = ArmorReduceDamage( Damage, Injured, DamageType, HitLocation );
	//DMTNS( "&&& Damage after ArmorReduceDamage:  " $ Damage );

	if( Damage > 0 )
	{
		// apply additional (e.g. artifact) filters?
		DamageFloat = U2Pawn(Injured).AdjustWeaponDamage( Damage );

		//DMTNS( "&&& Damage before ApplyAdditionalDamageFilters: " $ Damage );
		Damage = U2Pawn(Injured).ApplyAdditionalDamageFilters( DamageFloat );
		//DMTNS( "&&& Damage after ApplyAdditionalDamageFilters:  " $ DamageFloat );
	}
			
	//DMTNS( "&&& ReduceDamage returning Damage: " $ Damage );

	// apply pawn-level filters
	//DMTNS( "Returned Damage before filter: " $ Damage );
	if( U2Pawn(Injured).DamageFilterClass? ) 
		U2Pawn(Injured).DamageFilterClass.static.ApplyFilter( Damage, Momentum, DamageType );
	//DMTNS( "&&& Filtered Damage: " $ Damage );

	// apply game rules filters
	if( GameRulesModifiers != None )
		return GameRulesModifiers.NetDamage( OriginalDamage, Damage, Injured, Instigator, HitLocation, Momentum, DamageType );
	
	Damage = U2Pawn(Injured).AdjustFinalDamage( Damage );

	return Damage;
}


function RestartPlayer( Controller aPlayer )	
{
	if( !bSinglePlayerMission || PlayerController(aPlayer)!=None )
		super.RestartPlayer( aPlayer );
}

function bool ForceAddBot()
{
	return false;
}

//NEW - CDH
function int GetRagdollDetailLevel()
{
	return RagdollDetailLevel;
}

function int GetActiveRagDollDeaths()	
{ 
	return ActiveRagdollDeaths; 
}

function int GetMaxRagDollDeaths() 
{ 
	return MaxRagdollDeaths; 
}

function IncActiveRagDollDeaths()
{
	ActiveRagdollDeaths++;
}

function DecActiveRagDollDeaths()
{ 
	ActiveRagdollDeaths--;
	if( ActiveRagdollDeaths < 0 )
		ActiveRagdollDeaths = 0;
}

//-----------------------------------------------------------------------------
// AI
//-----------------------------------------------------------------------------

function float SpawnWait( U2NPCController aNPC ) { return 0.0; }
function bool TooManyBots() { return false; }

//!!mdf-tbd no longer called or no implementation (some of these may have to come back, possibly elsewhere)

// Interface for DeathMatch
//!!mdf-tbd: function byte AssessBotAttitude( U2NPCController aNPC, Pawn Other ) { return 0; }
//!!mdf-tbd: function float GameThreatAdd( U2NPCController aNPC, Pawn Other ) { return 0.0; }
//!!mdf-tbd: function bool NeverStakeOut( U2NPCController Other ) { return false; }
//!!mdf-tbd: function bool OneOnOne() { return false; }
//!!mdf-tbd: function PickAmbushSpotFor( U2NPCController aNPCController );

// Interface for TeamGame
//!!mdf-tbd: function AssessBotDamage( Pawn Injured, Pawn Instigator );
//!!mdf-tbd: function Actor SetDefenseFor( U2NPCController aNPC ) { return None; }
//!!mdf-tbd: bool FindSpecialAttractionFor( U2NPCController aNPC ) { return false; }
//!!mdf-tbd: function SetAttractionStateFor( U2NPCController aNPC );
//!!mdf-tbd: function byte PriorityObjective( U2NPCController aNPC ) { return 0; }
//!!mdf-tbd: function bool WaitForPoint( U2NPCController aNPC ) { return false; }
//!!mdf-tbd: function bool SendBotToGoal( U2NPCController aNPC ) { return false; }
//!!mdf-tbd: function bool HandleTieUp( U2NPCController Bumper, U2NPCController Bumpee ) { return false; }

function AllocateGameAIControllers()
{
	local int ii;
	local class<GameAIControllerInterf> GameAIClass;
	local string GameAIClassString;
	local GameAIControllerInterf NewGameAIController;
	
	for( ii=0; ii<GameAIControllerClasses.Length; ii++ )
	{
		// Each team has its own GameAIController. Generally we will only have 
		// GameAIControllerClasses[0] set so all GameAIControllers will be the same
		// but for testing (or for fun) we can have different teams use different
		// GameAIController classes, e.g. to determine which stategy is better
		// by pitting teams using 2 GameAIControllers against each other.
		if( GameAIControllerClasses[ii] == "" )
			GameAIClassString = GameAIControllerClasses[0];
		else
			GameAIClassString = GameAIControllerClasses[ii];

		if( GameAIClassString != "" )
		{
			GameAIClass = class<GameAIControllerInterf>(DynamicLoadObject( GameAIClassString, class'class' ));
			if( GameAIClass != None )
				NewGameAIController = new(Self) GameAIClass;
				
			if( NewGameAIController != None )
			{
				NewGameAIController.Initialize( ii );
				GameAIControllers[ GameAIControllers.Length ] = NewGameAIController;
			}			
		}

		if( GameAIControllers[ii] == None )
		{
			DM( "WARNING: could not allocate GameAIController #" $ ii $ "(" $ GameAIClassString $ ")!" );
		}
	}

	DM( "Allocated Game AI Controllers: " $ GameAIControllers.Length );
}


function GameEvent( name EventName, Actor Instigator, optional Actor OtherActor, optional name OtherInfo )
{
	GameAIControllers[0].GameEvent( EventName, Instigator, OtherActor, OtherInfo );
}

/*-----------------------------------------------------------------------------
Add calls to GameEvent for any events that could affect NPC behavior (see
initial list of game events in GameAIControllerImpl).

In addition, the GameAIControllers might monitor special "events" themselves e.g.
they might generate an internal event every time, say, 10% of the game time elapses, 
possibly increasing frequency as the end of the game nears? Or, if a flag is dropped
the tendency to search for the flag might shift to a tendency to go to the flag's 
base as the return to base time limit approaches. Some of this might be best implemented
in the GameInfos tbd?

e.g. in code where a capture is made could do:

	GameEvent( GameAIControllerImpl.CaptureGameEvent, Pawn );
*/

event NotifyLevelChange()
{
	local int i;
	local Weapon W;

	if( Level.PlayerControllerList != None )
		class'U2UseManagerPlayer'.static.SetEnabled( U2Pawn(Level.PlayerControllerList.Pawn), false );

	foreach DynamicActors( class'Weapon', W )
		W.ClearWeaponEffects();
		
	class'ImpactHandler'.static.Init( Self );

	class'MusicScriptEvent'.static.CallRoutine(Self,"dmFadeout");

	class'UIConsole'.static.SendEvent("LevelChange");

	// Remove level-specific UIComponents.
	for( i=0; i<UIComponents.length; i++ )
		class'UIConsole'.static.DestroyComponent( UIComponents[i] );
	UIComponents.Remove(0,UIComponents.length);

	Super.NotifyLevelChange();
}

event NotifyHack()
{
	local int i;

	// Create level-specific UIComponents.
	UIComponents.Remove(0,UIComponents.length);
	UIComponents.length = Level.UIComponents.length;
	for( i=0; i<Level.UIComponents.length; i++ )
		UIComponents[i] = class'UIConsole'.static.LoadComponent( "UI", Level.UIComponents[i].Component );
	for( i=0; i<UIComponents.length; i++ )
		class'UIConsole'.static.AddComponent( UIComponents[i], class'UIConsole'.static.FindLooseComponent( Level.UIComponents[i].Parent ) );

	Super.NotifyHack();
}

event NotifyLevelChangeEnd()
{
	if( Level.PlayerControllerList != None )
		class'U2UseManagerPlayer'.static.SetEnabled( U2Pawn(Level.PlayerControllerList.Pawn), true );

	class'MusicScriptEvent'.static.CallRoutine(Self,Level.DMScript,Level.DMSong);

	Super.NotifyLevelChangeEnd();
}

event NotifyAudioSystemReset()
{
	class'DialogEngine'.static.NotifyAudioSystemReset( Self );
}

function NotifyCutSceneStart()
{
	bDisplayHud = false; //NEW (mwp) hide the HUD and crosshair
	bSaveDisabled=true; //NEW (mwp)
	if( Level.PlayerControllerList != None )
		class'U2UseManagerPlayer'.static.SetEnabled( U2Pawn(Level.PlayerControllerList.Pawn), false );
}

function NotifyCutSceneEnd()
{
	bDisplayHud = Level.Game.default.bDisplayHud; //NEW (mwp) restore the HUD and crosshair to their original state
	bSaveDisabled=false; //NEW (mwp)
	if( Level.PlayerControllerList != None )
		class'U2UseManagerPlayer'.static.SetEnabled( U2Pawn(Level.PlayerControllerList.Pawn), true );
}

static function BSM( Actor ContextActor, coerce string Message )
{
	class'UIConsole'.static.BroadcastStatusMessage( 
		ContextActor, 
		Message,
		default.BSMTime,
		None,
		default.BSMColor,
		, //sound
		, //volume
		, //pitch,
		"CenterDebugHolder",
		true );
}

defaultproperties
{
	DamageToPlayerScalars(0)=0.150000
	DamageToPlayerScalars(1)=0.400000
	DamageToPlayerScalars(2)=0.750000
	DamageByPlayerScalars(0)=2.000000
	DamageByPlayerScalars(1)=1.250000
	DamageByPlayerScalars(2)=1.000000
	AirControl=0.250000
	SpeedRatio=1.000000
	PlayerSpeedRatio=1.250000
	bSinglePlayerMission=true
	RespawnAppearanceDelay=0.300000
	bForcedWeaponSwitch=true
	bUseCombatSounds=true
	bGiveDefaultWeapon=true
	BSMTime=4.000000
	BSMColor=(R=255,A=255)
	RagdollDetailLevel=3
	MaxRagdollDeaths=5
	DefaultPlayerClassName="U2Pawns.U2PlayerSP"
	GameName="U2"
	MutatorClass="U2.U2Mutator"
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}