U2AI.UtilSquad

//=============================================================================
// UtilSquad.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 12/16/02 4:19a $
// $Revision: 1 $
//=============================================================================

class UtilSquad extends Object
	abstract;

/*-----------------------------------------------------------------------------
Placeholder class for squad-related code. Eventually this should become a
component which is shared by squadmates.

Currently, a squad consists of any valid NPCs which are on the same team and 
have "squad" orders (currently either OrdersGoto with an associated destination 
OrdersObject or OrdersSquad).

Members of a squad decide whether or not to actually attempt to carry out their
orders while engaged in combat, i.e. whether to set/clear bExecuteOrders which 
determines whether NPCs will actively engage the enemy (ignoring the orders) or
passively engage the enemy (while falling back towards the orders destination).

(The value of bExecuteOrders only applies to NPCs which have a valid enemy. If
an NPC is scripted or autonomous without an enemy, then the NPC is counted as
be following the squad orders, if it has them.)

If an NPC doesn't have an enemy then it will probably be under script
control and following the script, presumably to the orders destination

*/

//-----------------------------------------------------------------------------
// Does the NPC associated with the given controller belong to the same squad 
// as the given ComparisonPawn?
//
// NOTE: will return true if the given Controller belongs to the given
// Pawn as long as other checks pass.
//
// !!mdf-tbd: check for NPCs having the same orders as each other?

static private function bool ValidSquadMember( Controller C, Pawn ComparisonPawn )
{
	if( C.bStasis )
		return false;
	if( U2NPCControllerBasic(C) == None )
		return false;
	if( !U2NPCControllerBasic(C).HasSquadOrders() )
		return false;
	if( !class'Pawn'.static.ValidPawn( C.Pawn ) )
		return false;
	if( !ComparisonPawn.SameTeam( C.Pawn ) )
		return false;
		
	return true;
}

//-----------------------------------------------------------------------------
// Find all valid members of the squad that the given SourcePawn belongs to 
// (including the given SourcePawn unless this is no longer valid, e.g. dead)
// and return the number of squad members and the number of those which have 
// bExecuteOrders = true. Also finds the ExecuteOrdersThreshold by using the
// largest threshold found for any NPC in the squad.

static private function GetSquadInfo( Pawn SourcePawn, out array<U2NPCControllerBasic> SquadMembers, out int ExecuteOrdersCount, out float SquadExecuteOrdersThreshold )
{
	local Controller C;
	local U2NPCControllerBasic U2NPCBasic;
	
	//SourcePawn.DMTNS( "GetSquadInfo for " $ SourcePawn );
	for( C=SourcePawn.Level.ControllerList; C!=None; C=C.NextController )
	{
		//SourcePawn.DMTNS( "  considering " $ C.Pawn );

		if( ValidSquadMember( C, SourcePawn ) )		
		{
			U2NPCBasic = U2NPCControllerBasic(C);
			
			//SourcePawn.DMTNS( "    accepted " $ C.Pawn );
			SquadMembers.Length = SquadMembers.Length + 1;
			SquadMembers[ SquadMembers.Length - 1 ] = U2NPCBasic;
			
			//NOTE: just use the largest one found (should be stored on a per-squad basis eventually)
			SquadExecuteOrdersThreshold = FMax( SquadExecuteOrdersThreshold, U2NPCBasic.ExecuteOrdersThreshold );
			
			if( U2NPCBasic.bExecuteOrders )
			{
				//SourcePawn.DMTNS( "    " $ C.Pawn $ " has bExecuteOrders );
				ExecuteOrdersCount++;
			}
		}
		else
		{
			//SourcePawn.DMTNS( "    rejected " $ C.Pawn );
		}
	}
	
	//SourcePawn.DMTNS( "GetSquadInfo  NumSquadMembers: " $ SquadMembers.Length $ " ExecuteOrdersCount: " $ ExecuteOrdersCount $ " SquadExecuteOrdersThreshold: " $ SquadExecuteOrdersThreshold );
}

//-----------------------------------------------------------------------------
// See if the squad needs to be rebalanced.

static private function UpdateSquad( Pawn UpdatedPawn )
{
	local int NumSquadMembers;
	local int ExecuteOrdersCount;
	local int DesiredExecuteOrdersCount, ExecuteOrdersDiscrepancy;
	local float Distance, BestDistance;
	local float BestDistanceInitializer, BestDistanceEnemyMultiplier;
	local float SquadExecuteOrdersThreshold;
	local bool bEnableExecuteOrders;
	local U2NPCControllerBasic U2NPCBasic, BestC;
	local array<U2NPCControllerBasic> SquadMembers;
	local int ii, jj;
	
	//Log( "UpdateSquad" );
	
	if( UpdatedPawn == None )
		return; // no information?
		
	GetSquadInfo( UpdatedPawn, SquadMembers, ExecuteOrdersCount, SquadExecuteOrdersThreshold );

	NumSquadMembers = SquadMembers.Length;
	if( NumSquadMembers == 0 )
		return; // no squad members left

	DesiredExecuteOrdersCount = Min( NumSquadMembers, int( SquadExecuteOrdersThreshold * NumSquadMembers + 0.5) );
	//Log( "  DesiredExecuteOrdersCount: " $ DesiredExecuteOrdersCount );
	
	ExecuteOrdersDiscrepancy = ExecuteOrdersCount - DesiredExecuteOrdersCount;
	
	// NOTE: ExecuteOrdersDiscrepancy will generally be in -1..1 so not much point 
	// in sorting the SquadMembers array by distance (ideally this list would be
	// maintained in a central location but updating it whenever an NPC dies
	// or acquires an enemy isn't going to add much overhead at this point).
	if( ExecuteOrdersDiscrepancy != 0 )
	{
		if( ExecuteOrdersDiscrepancy > 0 )
		{
			// need more squad members with bExecuteOrders=false -- pick N furthest candidates from OrdersObject
			//Log( "  reducing bExecuteOrders count" );
			bEnableExecuteOrders = false;
			BestDistanceInitializer = -999999;
			BestDistanceEnemyMultiplier = 0.333;
		}
		else
		{
			// need more squad members with bExecuteOrders=true -- pick N closest candidates to OrdersObject
			//Log( "  increasing bExecuteOrders count" );
			bEnableExecuteOrders = true;
			BestDistanceInitializer = 999999;
			BestDistanceEnemyMultiplier = 3.0;
			ExecuteOrdersDiscrepancy = -ExecuteOrdersDiscrepancy;
		}
		
		for( ii=0; ii<ExecuteOrdersDiscrepancy; ii++ )
		{
			BestC = None;
			BestDistance = BestDistanceInitializer;
			for( jj=0; jj<SquadMembers.Length; jj++ )
			{
				U2NPCBasic = SquadMembers[ jj ];
				
				//Log( "      Consider " $ U2NPCBasic.Pawn $ " bExecuteOrders: " $ U2NPCBasic.bExecuteOrders $ " Orders: " $ U2NPCBasic.Orders $ " ScriptControl: " $ U2NPCBasic.UnderScriptControl() );
				if( U2NPCBasic.bExecuteOrders != bEnableExecuteOrders && U2NPCBasic.Orders == U2NPCBasic.OrdersGoto && !U2NPCBasic.UnderScriptControl() )
				{
					Distance = VSize( U2NPCBasic.Pawn.Location - U2NPCBasic.OrdersObject.Location );
					
					// if the NPC currently has an enemy, prefer other NPCs (scale distance)
					if( U2NPCBasic.ControllerEnemy != None )
						Distance *= BestDistanceEnemyMultiplier;
						
					//Log( "      Distance: " $ Distance $ " BestDistance: " $ BestDistance );
					
					if( (bEnableExecuteOrders && Distance < BestDistance) || // looking for closest to OrdersObject
						(!bEnableExecuteOrders && Distance > BestDistance) ) // looking for furthest from OrdersObject
					{
						BestDistance = Distance;
						BestC = U2NPCBasic;
					}
				}
			}
			
			if( BestC != None )
				BestC.SetExecuteOrders( bEnableExecuteOrders );
			else
				break;
		}
	}
}

//-----------------------------------------------------------------------------
// Given NPC now has squad orders. Call UpdateSquad to see if the squad needs 
// to be rebalanced.

static function CheckSquadOrdersOnMemberAdded( U2NPCControllerBasic AddedController )
{
	//Log( "CheckSquadOrdersOnMemberAdded: " $ AddedController.Pawn );
	
	UpdateSquad( AddedController.Pawn );
}

//-----------------------------------------------------------------------------
// Given Pawn was either killed or no longer has squad orders. Call UpdateSquad
// to see if the squad needs to be rebalanced.
//
// NOTE: Pawn passed in separately since when an NPC dies the Pawn is generally 
// UnPossessed and loses its Controller.

static function CheckSquadOrdersOnMemberLost( U2NPCControllerBasic LostController, Pawn LostPawn )
{
	//Log( "CheckSquadOrdersOnMemberLost: " $ LostPawn );
	
	LostController.SetExecuteOrders( false );
	UpdateSquad( LostPawn );
}

//-----------------------------------------------------------------------------
// Given NPC acquired an enemy (when it didn't have one previously). Set that
// Pawn's

static function CheckSquadOrdersOnEnemyAcquired( Pawn AcquiringPawn )
{
	local array<U2NPCControllerBasic> SquadMembers;
	local int NumSquadMembers;
	local int ExecuteOrdersCount;
	local float ExecuteOrdersRatio;
	local float SquadExecuteOrdersThreshold;

	//Log( "CheckSquadOrdersOnEnemyAcquired: " $ AcquiringPawn );
	
	UpdateSquad( AcquiringPawn );

	/*2002.12.15 (mdf) just call UpdateSquad now?		
	GetSquadInfo( AcquiringController.Pawn, SquadMembers, ExecuteOrdersCount, SquadExecuteOrdersThreshold );

	NumSquadMembers = SquadMembers.Length;
	if( NumSquadMembers == 0 )
		return; // entire squad wiped out
		
	//!!mdf-tbd: reassign orders based on proximity to ordersobject/enemy(s)?
	if( NumSquadMembers <= 1 )
	{
		//AcquiringController.DMTNS( "bExecuteOrders = true " $ GetContext() );
		AcquiringController.SetExecuteOrders( true ); // no one left to to the job but given NPC
	}
	else 
	{
		ExecuteOrdersRatio = float(ExecuteOrdersCount) / float(NumSquadMembers);
		if( ExecuteOrdersRatio < SquadExecuteOrdersThreshold )
		{
			//AcquiringController.DMTNS( "bExecuteOrders = true " $ GetContext() );
			AcquiringController.SetExecuteOrders( true );  // not enough teammates following orders
		}
		else if( ExecuteOrdersRatio > SquadExecuteOrdersThreshold )
		{
			AcquiringController.SetExecuteOrders( false ); // not enough teammates attacking enemies
		}
	}
	*/
	
	//Log( "CheckSquadOrdersOnEnemyAcquired: " $ AcquiringController.ControllerEnemy $ " NumSquadMembers: " $ NumSquadMembers $ " ExecuteOrdersCount: " $ ExecuteOrdersCount $ " bExecuteOrders: " $ AcquiringController.bExecuteOrders );
}

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

defaultproperties
{
}