U2CTF.GameAIControllerCTF

//=============================================================================
// GameAIControllerCTF.uc
// Created By: Mike Fox
// Created On: 08/07/01
// $Author: Mfox $
// $Date: 9/13/02 11:03a $
// $Revision: 5 $
//=============================================================================

class GameAIControllerCTF extends GameAIControllerImpl;

/*-----------------------------------------------------------------------------
Overview of rules:

Teams score points by capturing other team's flag.
etc.

-----------------------------------------------------------------------------*/

const GameEventFlagCaptured			= 'FlagCaptured';
const GameEventFlagDropped			= 'FlagDropped';
const GameEventFlagReturned			= 'FlagReturned';
const GameEventFlagTaken			= 'FlagTaken';
//const GameEventFlagSee			= 'FlagSee';

var U2CTFFlag OurFlag;
var U2CTFFlag TheirFlag;

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

function Initialize( int NewTeamIndex )
{
	local U2CTFFlag Flag;

	Super.Initialize( NewTeamIndex );

	foreach AllActors( class'U2CTFFlag', Flag )
	{
		if( Flag.Team == GetTeam( TeamIndex ) )
			OurFlag = Flag;
		else
			TheirFlag = Flag;
	}
}

// tbd:
function GameEvent( name EventName, Actor Instigator, optional Actor OtherActor, optional name OtherInfo )
{
	#debug DMTNS( "GameEvent: " $ EventName );
	switch( EventName )
	{
		case GameEventFlagCaptured:
		case GameEventFlagDropped:
		case GameEventFlagReturned:
		case GameEventFlagTaken:
			UpdateGameAI();
			break;

		default:
			Super.GameEvent( EventName, Instigator, OtherActor, OtherInfo );
			break;
	}
}

/*
//-----------------------------------------------------------------------------

function GameEvent( name EventName, Actor Instigator, optional Actor OtherActor, optional name OtherInfo )
{
	switch( EventName )
	{
		case CaptureGameEvent:
			if( Pawn(Instigator) != None )
			{
				if( Pawn(Instigator).PlayerReplicationInfo.Team.TeamIndex == TeamIndex )
					HandleFriendlyCapture();
				else
					HandleEnemyCapture();
			}
			else
				GameEventError( "invalid instigator", EventName, Instigator, OtherActor, OtherInfo );
			break;
	
		case DeathGameEvent:
			if( Pawn(Instigator) != None )
			{
				if( Pawn(Instigator).PlayerReplicationInfo.Team.TeamIndex == TeamIndex )
					HandleFriendlyDeath();
				else
					HandleEnemyDeath();
			}
			break;

		default:
			Super.GameEvent( EventName, Instigator, OtherActor, OtherInfo );
			break;
	}
}

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

function protected HandleEnemyCapture()
{
	local Controller C;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( C.bIsBot )
			U2NPCController(C).SetOrders( U2NPCControllerBase.OrdersAttack, C ); // mdf-tbd: support actor OrdersObject?
	}
}

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

function protected HandleFriendlyCapture()
{
	local Controller C;

	for( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( C.bIsBot )
			U2NPCController(C).SetOrders( U2NPCControllerBase.OrdersAttack, C ); // mdf-tbd: support actor OrdersObject?
	}
	//for( C=list of NPCs controlled by this controller; C!=None; C=C.Next )
	//	C.SetOrders(...);
}

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

function protected HandleEnemyDeath()
{
}

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

function protected HandleFriendlyDeath()
{
}
*/

//-----------------------------------------------------------------------------
// overall:
// if losing:   increasingly offensive with increasing amount behind, decreasing time remaining
// if winning:  increasingly defensive with increasing amount ahead, decreasing time remaining

function protected UpdateGameAI()
{
	local Controller C;
	local U2NPCController U2NPC;

	// tbd: most of this should be event driven eventually?
	if( true || NumTeamPlayers() == 1 )
	{
		// special case -- 1 player on team
		// if losing -- have to be offensive (no one for defense)
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			U2NPC = U2NPCController(C);

			if( U2NPC == None )
				continue;

			if( CanControlNPC( U2NPC ) )
			{
				// mdf-tbr: this should be determined internally by the NPC AI
				//if( !U2NPC.ReadyForAction() )
				//	continue; // NPC needs more time to prepare mdf-tbd: have a per-NPC "NextGameAICheckTime"?

				// what's the current status?
				// mdf-tbd: use a lookup table for all of this?
				if( OurFlag.GetStatus() == FS_Home )
				{
					// our flag in base
					if( TheirFlag.GetStatus() == FS_Home )
					{
						// their flag in base -- go get it
						SetNPCSpecialGoal( U2NPC, TheirFlag.HomeBase );
					}
					else if( TheirFlag.GetStatus() == FS_Held && TheirFlag.Holder == C.Pawn )
					{
						// I'm holding their flag -- try to cap it
						SetNPCSpecialGoal( U2NPC, OurFlag.HomeBase );
					}
					else if( TheirFlag.GetStatus() == FS_Dropped )
					{
						// their flag was dropped -- try to find it
						// mdf-tbd: check LOS so bots don't cheat
						SetNPCSpecialGoal( U2NPC, TheirFlag );
					}
					else
					{
						#debug DMTNS( "Situation not yet handled" );
					}
				}
				else if( OurFlag.GetStatus() == FS_Held )
				{
					// our flag held -- go after it
					// mdf-tbd: check LOS so bots don't cheat
					// mdf-tbd: if their flag nearby get it first
					SetNPCSpecialGoal( U2NPC, OurFlag.Holder );
				}
				else if( OurFlag.GetStatus() == FS_Dropped )
				{
					// our flag dropped -- go after it
					// mdf-tbd: check LOS so bots don't cheat
					// mdf-tbd: if their flag nearby get it first
					SetNPCSpecialGoal( U2NPC, OurFlag );
				}
				else
				{
					#debug DMTNS( "Situation not yet handled" );
				}
			}
			else
			{
				// mdf-tbr:
				#debugbegin
				if( U2NPC.PlayerReplicationInfo == None || U2NPC.PlayerReplicationInfo.Team == GetTeam( TeamIndex ) )
					DMTNS( "Can't control " $ C );
				#debugend
			}
		}
	}
}

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

defaultproperties
{
}