U2AI.BehaviorControllerBasic

//=============================================================================
// BehaviorControllerBasic.uc
// Created By: Mike Fox
// Created On: 01/22/02
// $Author: Mfox $
// $Date: 12/18/02 4:48p $
// $Revision: 34 $
//=============================================================================

class BehaviorControllerBasic extends BehaviorControllerInterf;

/*-----------------------------------------------------------------------------
This is the AI component which handles "high level" attack-related decisions.

Determines the behavior that the controlled NPC should use for dealing with the
current enemy (acquire, flee, hunt, close, ranged attack etc.) and also manages
the NPC's ranged attack (if any), telling the NPC when to fire (which causes 
the NPC to fire his weapon or initiate an animation based ranged attack which
will spawn a projectile etc.).

All the "lower level" decisions (where/how to move what inputs to track etc.
are controlled by the core AI in the controlled NPC.

This component is mainly driven externally by the NPC under control but can
also be affected internally, e.g. if the NPC's "able to attack" status changes,
if the reloading of the current weapon is completed for example? The BC will
also maintain internal timers which will control how long and NPC will stop
moving for between other attack behaviors etc.

Note that "metastates" refer to the current "high-level" state of the NPC --
e.g. whether the NPC has an enemy or not (see EMetaState for a complete list).
The metastates control high-level decisions such as the behavior list (states) 
to use and whether to attempt to shoot or not.

tbd: move weapon selection code into here also?
*/

const CheckBehaviorTimerName	= 'CheckBehaviorTimer';
const CheckFireShotTimerName	= 'CheckFireShotTimer';
const CheckMetaStateTimerName	= 'CheckMetaStateTimer';

enum EMetaState
{
	MS_AttackInactive,				// no enemy (wander, roam etc.)
	// actively engaging enemy (bExecuteOrders=false)
	MS_AttackActive,				// enemy set and visible, reachable
	MS_AttackActiveCantReach,		// enemy set and visible but not reachable
    MS_AttackActiveEnemyNotVisible,	// enemy set but not visible
	MS_AttackActiveMelee,			// melee attacking enemy (timed meta state)
	MS_AttackActiveMeleeHit,		// melee attacking enemy (timed meta state) after hitting enemy
	MS_AttackActiveUseCover,		// using cover (timed meta state)
	// passively engaging enemy (bExecuteOrders=true)
	MS_AttackPassive,				// enemy set and visible, reachable
	MS_AttackPassiveCantReach,		// enemy set and visible but not reachable
    MS_AttackPassiveEnemyNotVisible,// enemy set but not visible
	MS_AttackPassiveMelee,			// melee attacking enemy (timed meta state)
	MS_AttackPassiveMeleeHit,		// melee attacking enemy (timed meta state)
	MS_AttackPassiveUseCover,		// using cover (timed meta state)
};

//-----------------------------------------------------------------------------
//data:

// helpers
var float TotalBehaviorOdds;		// sum of odds for all supported behaviors
var int LastSelectedBehaviorIndex;
var EMetaState MetaState;			// current "meta" state

// used to discourage going back to the same state again for bAvoidRepeat=true states
var name BlockedStateName;
var EMetaState PreviousMetaState;

var int LastAttackActiveIndex;
var int LastAttackActiveCantReachIndex;
var int LastAttackActiveEnemyNotVisibleIndex;
var int LastAttackActiveUseCoverIndex;
var int LastAttackActiveMeleeIndex;
var int LastAttackActiveMeleeHitIndex;
var int LastAttackPassiveIndex;
var int LastAttackPassiveCantReachIndex;
var int LastAttackPassiveEnemyNotVisibleIndex;
var int LastAttackPassiveUseCoverIndex;
var int LastAttackPassiveMeleeIndex;
var int LastAttackPassiveMeleeHitIndex;

// When false, behavior controller won't change controlled NPC's behavior.
// Used with special transition states like dodging, knockdown etc. which
// will disable/enable the behavior controller for the duration of the
// state.
var bool bEnabled;

var float NextSetAmmoTime;
var float MinSetAmmoDelay;
var float MaxSetAmmoDelay;
var float NextFireShotTimerAvailableTime;
var bool bNPCSetFireShotDelay; // set while current CheckFireShotTimer time was set by NPC

// global to avoid copying multiple times
var array<U2PawnBasic.BehaviorT> GBehaviorList;

const MaxRecursionCount = 5;
var private float LastTimeSeconds;
var private int RecursionCount;

var bool bCleaned;

//-----------------------------------------------------------------------------
// Make sure that a timer isn't set up with too high of a frequency (e.g. 0.0).

function AddTimerSafe( name TimerName, float TimerTime, bool bRepeat, optional float MinTime )
{
	//mdf-tbr: its possible for a timer event to cause the BC to be destroyed and
	// simply returning here is probably the easiest fix (or I'd have to check
	// for bCleaned everywhere.

	if( bCleaned )
		return;	
	//assert( !bCleaned );
	
	if( MinTime <= 0.0 )
		MinTime = 0.05;
	
	if( TimerTime < MinTime )
	{
		//DMTNS( "AddTimerSafe: TimerTime changed from " $ TimerTime $ " to " $ MinTime );
		TimerTime = MinTime;
	}
	
	//#debug DMAI( Self $ ".AddTimerSafe: " $ TimerName $ " TimerTime: " $ TimerTime );
	//#debug DMAI( "  CheckBehaviorTimer:  " $ TimeRemaining( CheckBehaviorTimerName ) );
	//#debug DMAI( "  CheckFireShotTimer:  " $ TimeRemaining( CheckFireShotTimerName ) );
	//#debug DMAI( "  CheckMetaStateTimer: " $ TimeRemaining( CheckMetaStateTimerName ) );
	
	AddTimer( TimerName, TimerTime, bRepeat );
}

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

#debug   function SetCheckFireShotTimer( float TimerTime, bool bCanOverride, string ContextStr )
#release function SetCheckFireShotTimer( float TimerTime, bool bCanOverride )
{
	if( bCanOverride || !bNPCSetFireShotDelay ) // don't override NPC requested delay
	{
		//DMTNS( "SetCheckFireShotTimer: " $ TimerTime $ " " $ ContextStr );
		AddTimerSafe( CheckFireShotTimerName, TimerTime, true );
	}
}

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

function DumpList( array<U2PawnBasic.BehaviorT> BehaviorList, name BehaviorListName )
{
	local int ii;
	
	DMT( BehaviorListName $ ":" );
	for( ii=0; ii<BehaviorList.Length; ii++ )
		DMT( ii $ " StateName: " $ BehaviorList[ ii ].StateName $ " EnableTime: " $ BehaviorList[ ii ].EnableTime $ " bDisabled: " $ BehaviorList[ ii ].bDisabled );
}

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

function DumpGList()
{
	local int ii;

	DMT( "GBehaviorList:" );
	for( ii=0; ii<GBehaviorList.Length; ii++ )
		DMT( "  " $ ii $ " StateName: " $ GBehaviorList[ ii ].StateName $ " EnableTime: " $ GBehaviorList[ ii ].EnableTime $ " bDisabled: " $ GBehaviorList[ ii ].bDisabled );
}

//-----------------------------------------------------------------------------
//@ BEHAVIOR CONTROL
//-----------------------------------------------------------------------------

function string GetExtendedStateInformation()
{
	return "BehaviorTimer: " $ class'Util'.static.GetFloatString( TimeRemaining( CheckBehaviorTimerName ) ) @
		   " MetaStateTimer: " $ class'Util'.static.GetFloatString( TimeRemaining( CheckMetaStateTimerName ) ) @
		   " FireShotTimer: " $ class'Util'.static.GetFloatString( TimeRemaining( CheckFireShotTimerName ) ) @
		   " MetaState: " $ EnumStr( enum'EMetaState', MetaState, 3 );
}

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

function string GetCurrentMetaStateName()
{
	return EnumStr( enum'EMetaState', MetaState );
}

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

function string GetCurrentMetaStateNameShort()
{
	switch( MetaState )
	{
		case MS_AttackInactive:
			return "I";
		case MS_AttackActive:
			return "A";
		case MS_AttackActiveCantReach:
			return "ACR";
		case MS_AttackActiveEnemyNotVisible:
			return "AENV";
		case MS_AttackActiveMelee:
			return "AM";
		case MS_AttackActiveMeleeHit:
			return "AMH";
		case MS_AttackActiveUseCover:
			return "AUC";
		case MS_AttackPassive:
			return "P";
		case MS_AttackPassiveCantReach:
			return "PCR";
		case MS_AttackPassiveEnemyNotVisible:
			return "PENV";
		case MS_AttackPassiveMelee:
			return "PM";
		case MS_AttackPassiveMeleeHit:
			return "PMH";
		case MS_AttackPassiveUseCover:
			return "PUC";
		default:
			return "??";
	}
}

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

function bool BehaviorEnabled( int Index )
{
	return ( !GBehaviorList[ Index ].bDisabled && Level.TimeSeconds >= GBehaviorList[ Index ].EnableTime );
}

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

function int GetNumEnabledBehaviors( array<U2PawnBasic.BehaviorT> BehaviorList )
{
	local int ii, EnabledCount;
	
	// count enabled behaviors
	EnabledCount = 0;
	for( ii=0; ii<BehaviorList.Length; ii++ )
		if( !BehaviorList[ ii ].bDisabled && Level.TimeSeconds >= BehaviorList[ ii ].EnableTime )
			EnabledCount++;

	return EnabledCount;
}

//-----------------------------------------------------------------------------
// NPC can call this any time the situation changes -- enemy acquired, enemy
// lost etc. to have the BC reevaluate the situation.

#debug   function Update( EBCType BCTypeIn, string ContextStr )
#release function Update( EBCType BCTypeIn )
{
	local EBCType BCTypeOut;
	
	if( Pawn == None )
	{
		//DMAssert( false, ContextStr @ "Pawn is None in " $ Self $ ".Update?" );
		return;
	}
	else if( Pawn.Health <= 0 )
	{
		//DMAssert( false, ContextStr @ "Pawn is dead in " $ Self $ ".Update?" );
		return;
	}
	
	//!!mdf-tbd: I think this is what we want (rather than just blocking timeouts)
	if( !bEnabled )
	{
		#debug DMAI( "--> Update (!bEnabled)  BCTypeIn: " $ EnumStr( enum'EBCType', BCTypeIn ) $ " Context: " $ ContextStr $ " MetaState: " $ EnumStr( enum'EMetaState', MetaState, 3 ) $ " State: " $ Outer.GetStateName() );
		return;
	}
	
	BCTypeOut = BCTypeIn;

	/* 2002.02.07 !!mdf-tbd: wtf was I doing this -- this breaks metastates like XXXUseCover because the
	  NPC will go back to AttackActive instead of picking the next behavior in the current
	  metastate if current behavior times out!? Was this necessary before adding the bEnabled
	  check above maybe?
	// remap BCType according to MetaState if necessary
	if( BCTypeOut == BC_BehaviorTimeOut || BCTypeOut == BC_MetaStateTimeOut )
	{
		// don't remap BC_BehaviorTimeOut if timeouts are disabled (caller will reenable timeouts and call Update)
	}
	*/
	if( MetaState == MS_AttackActiveUseCover || MetaState == MS_AttackPassiveUseCover )
	{
		if( BCTypeOut == BC_BehaviorTimeOut )
			BCTypeOut = BC_CoverTimeOut;
		else if( BCTypeOut == BC_EnemyRecovered )
			BCTypeOut = BC_CoverRecoveredEnemy;
		// 2002.12.07 otherwise, if NPC attacking enemy and enemy moves out of sight NPC will move to cover
		//else if( BCTypeOut == BC_EnemyNotVisible )
		else if( BCTypeOut == BC_EnemyNotVisible && Outer.GetStateName() != AttackStationaryState )
			BCTypeOut = BC_CoverEnemyNotVisible;
	}
	else if( MetaState == MS_AttackActiveMelee || MetaState == MS_AttackPassiveMelee )
	{
		if( BCTypeOut == BC_AttackUpdate )
			BCTypeOut = BC_MeleeUpdate;
	}

	// remap BC_MeleeXXXHit events to BC_MeleeXXX if no behaviors for "Hit" event
	if( BCTypeOut == BC_MeleeUpdateHit )
	{
		if( ( bExecuteOrders && GetNumEnabledBehaviors( U2PBasic.AttackPassiveMeleeHitBehaviors ) == 0) ||
			(!bExecuteOrders && GetNumEnabledBehaviors( U2PBasic.AttackActiveMeleeHitBehaviors ) == 0) )
			BCTypeOut = BC_MeleeUpdate;
	}
	else if( BCTypeOut == BC_MeleeRangeLostHit )
	{
		if( ( bExecuteOrders && GetNumEnabledBehaviors( U2PBasic.AttackPassiveMeleeHitBehaviors ) == 0) ||
			(!bExecuteOrders && GetNumEnabledBehaviors( U2PBasic.AttackActiveMeleeHitBehaviors ) == 0) )
			BCTypeOut = BC_MeleeRangeLost;
	}
	
	// if NPC can't find cover or doesn't need it, disable trying to use cover again for a while
	if( BCTypeOut == BC_CoverNotFound || BCTypeOut == BC_CoverNotNeeded )
	{
		DisableBehaviorTemporarily( AttackMoveToCoverCombatState, U2PBasic.AttackUseCoverLockoutTime );
	}
	else if( BCTypeOut == BC_AttackCantFire )
	{
		// !!mdf-tbd: have caller pass in time to disable itself for?
		DisableBehaviorTemporarily( Outer.GetStateName(), U2PBasic.AttackCantFireLockoutTime );
		BCTypeOut = BC_AttackUpdate;
	}
	else if( BCTypeOut == BC_EnemyRecovered )
	{
		// we just recovered the enemy so don't move back to cover
		SetLowOddsTimeInAllLists( AttackMoveToCoverCombatState, Level.TimeSeconds + U2PBasic.RecoverLockOutUseCoverTime );
	}
	
	// discourage going right back to the same state within the same metastate for this update
	BlockedStateName = Outer.GetStateName();
	PreviousMetaState = MetaState;
		
	#debug DMAI( "--> Update (bEnabled)  BCTypeIn: " $ EnumStr( enum'EBCType', BCTypeIn ) $ " BCTypeOut: " $ EnumStr( enum'EBCType', BCTypeOut ) $ " Context: " $ ContextStr $ " MetaState: " $ EnumStr( enum'EMetaState', MetaState, 3 ) $ " State: " $ Outer.GetStateName() );
	#debug   EvaluateAttackSituation( BCTypeOut, ContextStr );
	#release EvaluateAttackSituation( BCTypeOut );
	
	BlockedStateName = '';
}

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

function SetBCEnabled( bool bVal )
{
	bEnabled = bVal;
}

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

function bool GetBCEnabled()
{
	return bEnabled;
}

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

function SetMinTimeOutDelay( float MinTimeOutDelay )
{
	if( TimeRemaining( CheckBehaviorTimerName ) < MinTimeOutDelay )
		AddTimerSafe( CheckBehaviorTimerName, MinTimeOutDelay, false );
	if( TimeRemaining( CheckMetaStateTimerName ) < MinTimeOutDelay )
		AddTimerSafe( CheckMetaStateTimerName, MinTimeOutDelay, false );
}

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

function RestoreTimeOutDelays( float CheckBehaviorDelay, float CheckMetaStateDelay )
{
	AddTimerSafe( CheckBehaviorTimerName, CheckBehaviorDelay, false );
	AddTimerSafe( CheckMetaStateTimerName, CheckMetaStateDelay, false );
}

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

function float GetCheckBehaviorDelay()
{
	return TimeRemaining( CheckBehaviorTimerName );
}

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

function float GetCheckMetaStateDelay()
{
	return TimeRemaining( CheckMetaStateTimerName );
}

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

function GetTimeOutDelays( out float CheckBehaviorDelay, out float CheckMetaStateDelay )
{
	CheckBehaviorDelay = TimeRemaining( CheckBehaviorTimerName );
	CheckMetaStateDelay = TimeRemaining( CheckMetaStateTimerName );
}

//-----------------------------------------------------------------------------
//!!mdf-tbd: go through calls to StopFiring to see if there are cases where the
// intent is to decrease the timer rate rather than increasing it. Add a param
// here which specifies the intent (e.g. check again in no more than 0.2 secs
// vs check again in no less than 0.5 secs etc.)

function SetNextCheckFireShotDelay( float SuggestedFireAgainDelay )
{
	if( Level.TimeSeconds >= NextFireShotTimerAvailableTime && SuggestedFireAgainDelay > 0.0 )
	{
		#debug DMAIA( "BehaviorController.SetCheckFireShotTimer: setting fire shot timer to " $ SuggestedFireAgainDelay );
		#debug   SetCheckFireShotTimer( SuggestedFireAgainDelay, true, GetContext(0) );
		#release SetCheckFireShotTimer( SuggestedFireAgainDelay, true );
		bNPCSetFireShotDelay = true;
	}
}

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

function StartFiring()
{
	if( !IsFiring() ) // otherwise we'd stop rapid firing
	{
		if( Level.TimeSeconds >= NextFireShotTimerAvailableTime )
		{
			//DMTNS( "StartFiring: calling CheckFireShot" );
			CheckFireShot();
		}
	}
	else
	{
		//DMTNS( "StartFiring: already firing" );
	}
}

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

function BlockFiring( float SuggestedFireAgainDelay )
{
	#debug DMAIA( "BehaviorController.BlockFiring: " $ SuggestedFireAgainDelay );
	#debug   SetCheckFireShotTimer( SuggestedFireAgainDelay, true, GetContext(0) );
	#release SetCheckFireShotTimer( SuggestedFireAgainDelay, true );
	NextFireShotTimerAvailableTime = Level.TimeSeconds + SuggestedFireAgainDelay;
}

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

function float GetMinFiringDelay()
{
	if( IsFiring() )
		return 0.0;
		
	return TimeRemaining( CheckFireShotTimerName ); 
}

//-----------------------------------------------------------------------------
// implemetation
//-----------------------------------------------------------------------------

function DisableBehaviorTemporarilyInList( name TargetState, float Duration, out array<U2PawnBasic.BehaviorT> BehaviorList, name BehaviorListName )
{
	local int ii;
	
	for( ii=0; ii<BehaviorList.Length; ii++ )
	{
		if( BehaviorList[ ii ].StateName == TargetState )
		{
			BehaviorList[ ii ].EnableTime = Level.TimeSeconds + Duration;
			#debug DMAI( "DisableBehaviorTemporarilyInList - disabled " $ TargetState $ " in " $ BehaviorListName $ " until " $ BehaviorList[ ii ].EnableTime );
		}
	}
}

/*-----------------------------------------------------------------------------
NOTE: the state is disabled by setting its EnableTime to some time in the 
future -- once that time is up, the state is active again.
*/

function DisableBehaviorTemporarily( name TargetState, float Duration )
{
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackActiveBehaviors, 'AttackActive' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackActiveCantReachBehaviors, 'AttackActiveCantReach' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackActiveEnemyNotVisibleBehaviors, 'AttackActiveEnemyNotVisible' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackActiveUseCoverBehaviors, 'AttackActiveUseCover' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackActiveMeleeBehaviors, 'AttackActiveMelee' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackActiveMeleeHitBehaviors, 'AttackActiveMeleeHit' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackPassiveBehaviors, 'AttackPassive' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackPassiveCantReachBehaviors, 'AttackPassiveCantReach' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackPassiveEnemyNotVisibleBehaviors, 'AttackPassiveEnemyNotVisible' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackPassiveUseCoverBehaviors, 'AttackPassiveUseCover' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackPassiveMeleeBehaviors, 'AttackPassiveMelee' );
	DisableBehaviorTemporarilyInList( TargetState, Duration, U2PBasic.AttackPassiveMeleeHitBehaviors, 'AttackPassiveMeleeHit' );
	
	DisableBehaviorTemporarilyInList( TargetState, Duration, GBehaviorList, 'GBehaviorList' );
}

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

function DisableBehaviorInList( name TargetState, out array<U2PawnBasic.BehaviorT> BehaviorList, bool bDisabledFlag, bool bInvertSelection )
{
	local int ii;
	
	for( ii=0; ii<BehaviorList.Length; ii++ )
	{
		if( !bInvertSelection && BehaviorList[ ii ].StateName == TargetState ||
			 bInvertSelection && BehaviorList[ ii ].StateName != TargetState )
		{
			BehaviorList[ ii ].bDisabled = bDisabledFlag;
		}
	}
}

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

function DisableBehaviorInAllLists( name TargetState, bool bDisabledFlag, bool bDisableAllExcept )
{
	DisableBehaviorInList( TargetState, U2PBasic.AttackActiveBehaviors,					bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackActiveCantReachBehaviors,		bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackActiveEnemyNotVisibleBehaviors,	bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackActiveUseCoverBehaviors,			bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackActiveMeleeBehaviors,			bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackActiveMeleeHitBehaviors,			bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackPassiveBehaviors,				bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackPassiveCantReachBehaviors,		bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackPassiveEnemyNotVisibleBehaviors, bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackPassiveUseCoverBehaviors,		bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackPassiveMeleeBehaviors,			bDisabledFlag, bDisableAllExcept );
	DisableBehaviorInList( TargetState, U2PBasic.AttackPassiveMeleeHitBehaviors,		bDisabledFlag, bDisableAllExcept );
	
	DisableBehaviorInList( TargetState, GBehaviorList, bDisabledFlag, bDisableAllExcept );
}

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

function EnableBehavior( name TargetState )
{
	DisableBehaviorInAllLists( TargetState, false, false );
}

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

function DisableBehavior( name TargetState )
{
	DisableBehaviorInAllLists( TargetState, true, false );
}

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

function DisableAllBehaviorsExcept( name TargetState )
{
	DisableBehaviorInAllLists( TargetState, true, true );
}

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

function SetLowOddsTimeInList( name TargetState, float NewLowOddsTime, out array<U2PawnBasic.BehaviorT> BehaviorList )
{
	local int ii;
	
	for( ii=0; ii<BehaviorList.Length; ii++ )
	{
		// can't set LowOddsTime for cycled states (Odds always 0.0)
		if( BehaviorList[ ii].Odds > 0.0 && (TargetState == '' || BehaviorList[ ii ].StateName == TargetState) )
			BehaviorList[ ii ].LowOddsTime = NewLowOddsTime;
	}
}

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

function SetLowOddsTimeInAllLists( name TargetState, float NewLowOddsTime )
{
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackActiveBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackActiveCantReachBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackActiveEnemyNotVisibleBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackActiveUseCoverBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackActiveMeleeBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackActiveMeleeHitBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackPassiveBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackPassiveCantReachBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackPassiveEnemyNotVisibleBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackPassiveUseCoverBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackPassiveMeleeBehaviors );
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, U2PBasic.AttackPassiveMeleeHitBehaviors );
	
	SetLowOddsTimeInList( TargetState, NewLowOddsTime, GBehaviorList );
}

//-----------------------------------------------------------------------------
/* mdf-tbd: need to figure out how to clear GBehaviorList if its a copy of the
  given list.
  
function DisableBehaviorInGivenList( name TargetState, out array<U2PawnBasic.BehaviorT> BehaviorList )
{
	DisableBehaviorInList( TargetState, BehaviorList );

	if( ? )
		DisableBehaviorInList( TargetState, GBehaviorList );
}
*/

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

function bool ShouldMeleeAttack()
{
	return ( IsPreparedToMelee( true ) && CheckMeleeAttackRange( ControllerEnemy ) );
}

//-----------------------------------------------------------------------------
// Is a state from which firing at the enemy is likely to be possible (true
// even if enemy not visible to support tossed projectiles & such).

function bool IsFiringMetaState( EMetaState MS )
{
	return ( MS == MS_AttackActive || 
			 MS == MS_AttackActiveCantReach || 
			 MS == MS_AttackActiveEnemyNotVisible || 
			 MS == MS_AttackActiveUseCover ||
			 MS == MS_AttackPassive || 
			 MS == MS_AttackPassiveCantReach || 
			 MS == MS_AttackPassiveEnemyNotVisible || 
			 MS == MS_AttackPassiveUseCover );
}

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

function UpdateMetaState( EMetaState NewMetaState, float MinBehaviors )
{
	local bool bWasFiringMetaState;
	local float SuggestedCheckFireShotRate; // used if going from non-firing meta state to a firing one
	
	#debugbegin	
	if( DebugAI() )
		AIMessage( "UpdateMetaState: " $ EnumStr( enum'EMetaState', MetaState ) $ " --> " $ EnumStr( enum'EMetaState', NewMetaState ), MetaState != NewMetaState );
	#debugend
	
	if( MetaState != NewMetaState )
	{
		// meta state is changing
		NotifyMetaStateChange();

		bWasFiringMetaState = IsFiringMetaState( MetaState );

		//!!mdf-tbd: save stuff from previous meta state? when to clear these?
		switch( MetaState )
		{
		case MS_AttackActive:
			LastAttackActiveIndex = LastSelectedBehaviorIndex;
			break;

		case MS_AttackActiveCantReach:
			LastAttackActiveCantReachIndex = LastSelectedBehaviorIndex;
			break;

		case MS_AttackActiveEnemyNotVisible:
			LastAttackActiveEnemyNotVisibleIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 0.25;
			break;

		case MS_AttackActiveUseCover:
			LastAttackActiveUseCoverIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 0.25;
			break;

		case MS_AttackActiveMelee:
			LastAttackActiveMeleeIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 1.0;
			break;

		case MS_AttackActiveMeleeHit:
			LastAttackActiveMeleeHitIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 1.0;
			break;

		case MS_AttackPassive:
			LastAttackPassiveIndex = LastSelectedBehaviorIndex;
			break;

		case MS_AttackPassiveCantReach:
			LastAttackPassiveCantReachIndex = LastSelectedBehaviorIndex;
			break;

		case MS_AttackPassiveEnemyNotVisible:
			LastAttackPassiveEnemyNotVisibleIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 0.25;
			break;

		case MS_AttackPassiveUseCover:
			LastAttackPassiveUseCoverIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 0.25;
			break;

		case MS_AttackPassiveMelee:
			LastAttackPassiveMeleeIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 1.0;
			break;

		case MS_AttackPassiveMeleeHit:
			LastAttackPassiveMeleeHitIndex = LastSelectedBehaviorIndex;
			SuggestedCheckFireShotRate = 1.0;
			break;

		case MS_AttackInactive:
			SuggestedCheckFireShotRate = 0.0;
			break;

		default:
			DMAssert( false, GetContext() );
			break;
		}

		LastSelectedBehaviorIndex = -1;
		MetaState = NewMetaState;

		// fill in the global list
		//!!mdf-tbd: is there a better way than copying these (really just need a reference)?
		switch( MetaState )
		{
		case MS_AttackActive:
			GBehaviorList = U2PBasic.AttackActiveBehaviors;
			LastSelectedBehaviorIndex = LastAttackActiveIndex;
			break;

		case MS_AttackActiveCantReach:
			GBehaviorList = U2PBasic.AttackActiveCantReachBehaviors;
			LastSelectedBehaviorIndex = LastAttackActiveCantReachIndex;
			break;

		case MS_AttackActiveEnemyNotVisible:
			GBehaviorList = U2PBasic.AttackActiveEnemyNotVisibleBehaviors;
			LastSelectedBehaviorIndex = LastAttackActiveEnemyNotVisibleIndex;
			break;

		case MS_AttackActiveUseCover:
			GBehaviorList = U2PBasic.AttackActiveUseCoverBehaviors;
			LastSelectedBehaviorIndex = LastAttackActiveUseCoverIndex;
			break;

		case MS_AttackActiveMelee:
			GBehaviorList = U2PBasic.AttackActiveMeleeBehaviors;
			LastSelectedBehaviorIndex = LastAttackActiveMeleeIndex;
			break;
			
		case MS_AttackActiveMeleeHit:
			GBehaviorList = U2PBasic.AttackActiveMeleeHitBehaviors;
			LastSelectedBehaviorIndex = LastAttackActiveMeleeHitIndex;
			break;
			
		case MS_AttackPassive:
			GBehaviorList = U2PBasic.AttackPassiveBehaviors;
			LastSelectedBehaviorIndex = LastAttackPassiveIndex;
			break;

		case MS_AttackPassiveCantReach:
			GBehaviorList = U2PBasic.AttackPassiveCantReachBehaviors;
			LastSelectedBehaviorIndex = LastAttackPassiveCantReachIndex;
			break;

		case MS_AttackPassiveEnemyNotVisible:
			GBehaviorList = U2PBasic.AttackPassiveEnemyNotVisibleBehaviors;
			LastSelectedBehaviorIndex = LastAttackPassiveEnemyNotVisibleIndex;
			break;

		case MS_AttackPassiveUseCover:
			GBehaviorList = U2PBasic.AttackPassiveUseCoverBehaviors;
			LastSelectedBehaviorIndex = LastAttackPassiveUseCoverIndex;
			break;

		case MS_AttackPassiveMelee:
			GBehaviorList = U2PBasic.AttackPassiveMeleeBehaviors;
			LastSelectedBehaviorIndex = LastAttackPassiveMeleeIndex;
			break;
			
		case MS_AttackPassiveMeleeHit:
			GBehaviorList = U2PBasic.AttackPassiveMeleeHitBehaviors;
			LastSelectedBehaviorIndex = LastAttackPassiveMeleeHitIndex;
			break;
		}

		if( GBehaviorList.Length < MinBehaviors )
			U2PBasic.ErrorGeneral( ET_Other, "too few states in behavior list for " $ EnumStr( enum'EMetaState', MetaState ) $ "!" );

		// set up meta state timer if necessary (!!mdf-tbd: not generalized much at this point)
		if( MetaState == MS_AttackActiveMelee || MetaState == MS_AttackPassiveMelee )
			AddTimerSafe( CheckMetaStateTimerName, RandRange( U2PBasic.AttackMeleeMinTime, U2PBasic.AttackMeleeMaxTime ), false );
		else if( MetaState == MS_AttackActiveUseCover || MetaState == MS_AttackPassiveUseCover )
			AddTimerSafe( CheckMetaStateTimerName, RandRange( U2PBasic.AttackUseCoverMinTime, U2PBasic.AttackUseCoverMaxTime / (2.0 - Level.Game.GetNormalizedDifficulty()) ), false );
		else if( MetaState != MS_AttackActiveMeleeHit && MetaState != MS_AttackPassiveMeleeHit ) // keep melee timer
			RemoveTimer( CheckMetaStateTimerName );

		// enable fireshot timer if we have a valid, visible enemy and the NPC is capable of ranged attacks
		if( U2PBasic.bHasRangedAttack )
		{
			#debug DMAIA( "UpdateMetaState - verifying CheckFireShotTimer" );

			if( !bWasFiringMetaState && IsFiringMetaState( MetaState ) )
			{
				//#debug DMAIA( "UpdateMetaState - adding CheckFireShotTimer: " $ U2PBasic.FireCheckRate );
				//AddTimerSafe( CheckFireShotTimerName, U2PBasic.FireCheckRate, true ); // loops until removed
				// just call fire shot (so fires shot if possible and sets timer)
				// pbly want to have some optional delay?
				//SetMinFireShotRate( SuggestedCheckFireShotRate, true );
				//CheckFireShot();
				StartFiring();
			}
			else if( bWasFiringMetaState && !IsFiringMetaState( MetaState ) )
			{
				#debug DMAIA( "UpdateMetaState - removing CheckFireShotTimer" );
				RemoveTimer( CheckFireShotTimerName );
			}
		}
	}
	
	#debug DMAI( "UpdateMetaState: " $ GBehaviorList.Length $ " behaviors in list" );
}

//-----------------------------------------------------------------------------
// Note: caller can use MinOdds == 0.0 (after cycling through all entries) to 
// determine that at least one entry is cycled.

function float GetBehaviorOdds( int Index, out float MinOdds )
{
	local float ReturnedOdds;
	
	// if we are entering a new metastate (metastate changed), return the EntryOdds if applicable
	if( MetaState != PreviousMetaState && GBehaviorList[ Index ].EntryOdds != 0.0 )
	{
		ReturnedOdds = GBehaviorList[ Index ].EntryOdds;
		if( ReturnedOdds > 0.0 && ReturnedOdds < MinOdds )
			MinOdds = ReturnedOdds;
		// -ve values simply mean disabled when entering state
		ReturnedOdds = FMax( ReturnedOdds, 0.0 );
		//DMTNS( "Using EntryOdds for " $ GBehaviorList[ Index ].StateName $ ":" $ ReturnedOdds );
	}
	else if( Level.TimeSeconds < GBehaviorList[ Index ].LowOddsTime )
	{
		// this behavior is pretty much disabled currently unless its the only one available
		ReturnedOdds = 0.00001;
		if( ReturnedOdds < MinOdds )
			MinOdds = ReturnedOdds;
		//DMTNS( "Using Odds for " $ GBehaviorList[ Index ].StateName $ ":" $ ReturnedOdds );
	}
	else
	{
		ReturnedOdds = GBehaviorList[ Index ].Odds;
		if( ReturnedOdds < MinOdds )
			MinOdds = ReturnedOdds;
		//DMTNS( "Using Odds for " $ GBehaviorList[ Index ].StateName $ ":" $ ReturnedOdds );
	}
	
	// Strongly discourage re-using previous state/MS but it *can* be used (e.g. 
	// if its the only one available). Remember that if the odds are 0.0 then
	// this is a cycled state, so leave those odds alone (next state in the
	// list will be selected). Only applies if metastate didn't change.
	if( ReturnedOdds > 0.0 && 
		MetaState == PreviousMetaState && 
		GBehaviorList[ Index ].bAvoidRepeat &&
		GBehaviorList[ Index ].StateName == BlockedStateName )
	{
		ReturnedOdds = 0.000001;
	}
	
	return ReturnedOdds;
}

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

function GetSelectedBehavior( 
	out name SelectedBehaviorState, 
	out name SelectedBehaviorLabel, 
	out float SelectedBehaviorDuration )
{
	local float Odds, TotalOdds, SelectedOdds;
	local int ii, SelectedBehaviorIndex;
	local bool bFoundEnabled;
	local float MinOdds;

	// pick attack state based on Pawn's list

	//DMTNS( EnumStr( enum'EMetaState', PreviousMetaState ) $ " --> " $ EnumStr( enum'EMetaState', MetaState ) );

	//!!mdf-tbd: if odds won't ever be changed in-game could do this only when list changes
	//  and store a GTotalOdds and bGFoundCycled accordingly...
	TotalOdds = 0.0;
	bFoundEnabled = false;
	MinOdds = 999999.9;
	
	//DumpGList();
	
	for( ii=0; ii<GBehaviorList.Length; ii++ )
	{
		if( BehaviorEnabled( ii ) )
		{
			bFoundEnabled = true;
			Odds = GetBehaviorOdds( ii, MinOdds );
			if( Odds > 0.0 )
				TotalOdds += Odds;
				
			#debug DMAI( "  " $ GBehaviorList[ ii ].StateName $ " is enabled " $ " Odds: " $ Odds );
		}
		else
		{
			#debug DMAI( "  " $ GBehaviorList[ ii ].StateName $ " is disabled " );
		}
	}

	if( !bFoundEnabled )
	{
		U2PBasic.ErrorGeneral( ET_Other, "all states in behavior list for " $ EnumStr( enum'EMetaState', MetaState ) $ " are disabled?!" );
		DumpGList();
		return;
	}

	#debug DMAI( "  TotalOdds: " $ TotalOdds $ " MinOdds: " $ MinOdds );
	if( TotalOdds > 0.0 )
	{
		if( MinOdds <= 0.0 )
		{
			// tbd: eventually support mix of random and cycled states?
			if( MinOdds == 0.0 )
				DMTNS( "WARNING: mix of random and cycled states not currently supported  MetaState: " $ EnumStr( enum'EMetaState', MetaState ) );
			else
				DMTNS( "WARNING: negative odds found  MetaState: " $ EnumStr( enum'EMetaState', MetaState ) );
		}
		else
		{
			SelectedOdds = FRand()*TotalOdds;
		
			TotalOdds = 0.0;
			for( ii=0; ii<GBehaviorList.Length; ii++ )
			{
				if( BehaviorEnabled( ii ) )
				{		
					#debug DMAI( "  considering " $ GBehaviorList[ ii ].StateName );
					
					TotalOdds += GetBehaviorOdds( ii, MinOdds );
					if( TotalOdds >= SelectedOdds )
						break;
				}
			}
		}

		SelectedBehaviorIndex = ii;
	}
	else
	{
		//DMTNS( "Picking a cycled behavior  LastSelectedBehaviorIndex: " $ LastSelectedBehaviorIndex );
		// all states are cycled -- pick next available (enabled) one
		do
		{
			LastSelectedBehaviorIndex++;
			if( LastSelectedBehaviorIndex >= GBehaviorList.Length )
				LastSelectedBehaviorIndex = 0;
		} until( BehaviorEnabled( LastSelectedBehaviorIndex ) )

		SelectedBehaviorIndex = LastSelectedBehaviorIndex;
	}

	SelectedBehaviorState = GBehaviorList[ SelectedBehaviorIndex ].StateName;
	SelectedBehaviorLabel = GBehaviorList[ SelectedBehaviorIndex ].StateLabel;
	
	//!!mdf does this make sense (if NPC has to reload this will override the time specified here)
	// maybe in the case of ranged attacks the firing pattern should completely
	// determine how long the NPC stays in ranged?
	// (no -- firing pattern could apply across ranged, tactical, findcover, retreat...)
	SelectedBehaviorDuration = FMax( 0.2, RandRange( GBehaviorList[ SelectedBehaviorIndex ].TimeMin, 
													 GBehaviorList[ SelectedBehaviorIndex ].TimeMax ) );

	// clear any TempOdds which were set
	SetLowOddsTimeInAllLists( '', 0.0 );

	#debug DMAI( "  Selected " $ SelectedBehaviorState $ " for " $ EnumStr( enum'EMetaState', MetaState ) );
}

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

function CheckEnemySituation()
{
	// tbd:
}

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

function UpdateAttackActive( 
	EBCType BCType,
	out name SelectedBehaviorState, 
	out name SelectedBehaviorLabel, 
	out float SelectedBehaviorDuration )
{
	if( MetaState == MS_AttackActiveEnemyNotVisible || MetaState == MS_AttackPassiveEnemyNotVisible )
	{
		// re-acquired enemy (increased odds of a hit compared to initial acquisition)
		LastAcquireTime = Level.TimeSeconds - 0.1;
	}

	//!!mdf - first check if should use some behavior because of current situation?
	//  e.g. if out of ammo we probably want cover/flee
	// maybe we should ping the controller to give it a chance to specify the behavior?

	CheckEnemySituation();

	if( bExecuteOrders )
		UpdateMetaState( MS_AttackPassive, 1 );
	else		
		UpdateMetaState( MS_AttackActive, 1 );
		
	if( IsMobile() )
	{
		#debug DMAI( "UpdateAttackActive -- enemy is mobile" );
		GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
	}
	else
	{
		#debug DMAI( "UpdateAttackActive -- enemy is immobile" );
		SelectedBehaviorState = DefaultImmobileAttackState;
	}
}

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

function UpdateAttackCantReach()
{
	if( bExecuteOrders )
		UpdateMetaState( MS_AttackPassiveCantReach, 1 );
	else
		UpdateMetaState( MS_AttackActiveCantReach, 1 );
}

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

function UpdateAttackEnemyNotVisible()
{
	if( bExecuteOrders )
		UpdateMetaState( MS_AttackPassiveEnemyNotVisible, 1 );
	else
		UpdateMetaState( MS_AttackActiveEnemyNotVisible, 1 );
}

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

function UpdateAttackUseCover()
{
	if( bExecuteOrders )
		UpdateMetaState( MS_AttackPassiveUseCover, 0 );
	else
		UpdateMetaState( MS_AttackActiveUseCover, 0 );
}

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

function UpdateAttackMelee()
{
	if( bExecuteOrders )
		UpdateMetaState( MS_AttackPassiveMelee, 0 );
	else
		UpdateMetaState( MS_AttackActiveMelee, 0 );
}

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

function UpdateAttackMeleeHit()
{
	if( bExecuteOrders )
		UpdateMetaState( MS_AttackPassiveMeleeHit, 0 );
	else
		UpdateMetaState( MS_AttackActiveMeleeHit, 0 );
}

//-----------------------------------------------------------------------------
// Master attack evaluation function

#debug   protected function EvaluateAttackSituation( EBCType BCType, string ContextStr  )
#release protected function EvaluateAttackSituation( EBCType BCType  )
{
	local name SelectedBehaviorState, SelectedBehaviorLabel;
	local float SelectedBehaviorDuration;
	local bool bKeepState;

	SelectedBehaviorState = NoState;
	SelectedBehaviorLabel = NoLabel;
	SelectedBehaviorDuration = 0.0;

	#debug DMAI( "EvaluateAttackSituation  BCType: " $ EnumStr( enum'EBCType', BCType ) );
#debugbegin
	//!!mfd-tbr: once all "leaks" caught
	if( Pawn != None && !ValidEnemy( ControllerEnemy ) && BCType != BC_EnemyInvalid && BCType != BC_TookDamage && BCType != BC_UpdateInactive )
	{
		DMAssert( false, GetContext() ); //!!mdf should be true in theory
		DM( "  NPC state:         " $ Outer.GetStateName() );
		DM( "  MetaState:         " $ EnumStr( enum'EMetaState', MetaState ) );
		DM( "  BCType:            " $ EnumStr( enum'EBCType', BCType ) );
		DM( "  Context:           " $ ContextStr );
		DM( "  Enemy:             " $ ControllerEnemy );
		if( ControllerEnemy != None )
		{
		DM( "  Enemy Health:      " $ ControllerEnemy.Health );
		DM( "  Enemy bHidden:     " $ ControllerEnemy.Health );
		DM( "  Enemy bDeleteMe:   " $ ControllerEnemy.Health );
		DM( "  Attitude to Enemy: " $ EnumStr( enum'EAttitude', GetAttitudeTo( ControllerEnemy ) ) );
		}
	}
#debugend

	bKeepState = false;
	
	switch( BCType )
	{
	case BC_BehaviorTimeOut:
	case BC_MetaStateTimeOut:
		UpdateAttackActive( BCType, SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		break;
		
	case BC_EnemyAcquired:
		LastAcquireTime = Level.TimeSeconds; // just acquired enemy
		SelectedBehaviorState = DefaultAcquisitionState;
		break;

	case BC_AttackUpdate:
	case BC_CoverNotFound:
	case BC_CoverNotNeeded:
	case BC_EnemyChanged:
	case BC_EnemyRecovered:
	case BC_MeleeRangeLost:
		UpdateAttackActive( BCType, SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		break;
		
	case BC_EnemyCantReach:
		UpdateAttackCantReach();
		if( IsMobile() )
			GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		else
			SelectedBehaviorState = DefaultImmobileAttackState;
		break;

	case BC_EnemyNotVisible:
	case BC_StakeOutEnd:
		UpdateAttackEnemyNotVisible();
		if( IsMobile() )
			GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		else if( HasScript() )
			SelectedBehaviorState = ScriptedState;
		else
			SelectedBehaviorState = DefaultImmobileState;
		break;

	case BC_CoverLeavingCover:
	case BC_CoverEnemyNotVisible: // should basically result in stakeout or hunt since stationary / movetocover won't apply
	case BC_CoverReachedCover:
	case BC_CoverRecoveredEnemy:
	case BC_CoverTimeOut:
		UpdateAttackUseCover();
		if( IsMobile() )
			GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		else
			SelectedBehaviorState = DefaultImmobileState;
			
		if( BCType == BC_CoverRecoveredEnemy )
		{
			// re-acquired enemy (increased odds of a hit compared to initial acquisition)			
			LastAcquireTime = Level.TimeSeconds - 0.2;
			//fire immediately if possible
			StartFiring();
		}

		break;

	/*
	!!mdf-tbd: go to DefaultLeapState	without modifying current meta state?
	case BC_LeapRange:
		if( IsMobile() )
			GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		else
			SelectedBehaviorState = DefaultImmobileState;
		break;
		
	!!mdf-tbd: go to DefaultKnockDownState without modifying current meta state?
	case BC_KnockDown:
		if( IsMobile() )
			GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		else
			SelectedBehaviorState = DefaultImmobileState;
		break;
	*/
		
	case BC_MeleeRange:
	case BC_MeleeUpdate:
		UpdateAttackMelee();
		if( IsPreparedToMelee( true ) )
			GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		else
			bKeepState = true;
		break;
			
	case BC_MeleeUpdateHit:
	case BC_MeleeRangeLostHit:
		UpdateAttackMeleeHit();
		GetSelectedBehavior( SelectedBehaviorState, SelectedBehaviorLabel, SelectedBehaviorDuration );
		break;
		
	case BC_EnemyInvalid:
	case BC_TargetInvalid: //!!mdf-tbd: target might not be enemy (usually won't be...)
	case BC_UpdateInactive:
		// what if there was an old enemy: a) handle here b) assert( false ) ?
		RemoveTimer( CheckBehaviorTimerName );
		UpdateMetaState( MS_AttackInactive, 0 );
		#debug WhatToDoNext( GetContext() );
		#release WhatToDoNext();
		bKeepState = true;
		break;

	/*
	mdf-obe?
	case BC_EnemyChanged:
		//!!mdf keep the status quo with the new enemy, if much weaker/stronger 
		// maybe re-evaluate whether to run away or not
		break;
	*/

	case BC_TookDamage:
		//!!mdf decide to flee, maybe increase tactical move frequency?
		/*
		if( ControllerEnemy != None )
		{
			if( GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear && is allowed to flee )
			{
				SelectedBehaviorState = AttackRetreatState;
				SelectedBehaviorDuration = RandRange( specified flee duration );
			}
			break;
		}
		*/
		bKeepState = true;
		break;

	default:
		DMAssert( false, GetContext() ); // whoops
		break;
	}

	if( bKeepState )
	{
		#debug DMAI( "  EvaluateAttackSituation keeping current state" );
	}
	else if( SelectedBehaviorState == NoState )
	{
		#debug DMAI( "  WARNING: EvaluateAttackSituation - no destination state" );
	}
	else
	{
		//!!mdf-tbd: can occasionally end up recursing between available states
		if( Level.TimeSeconds == LastTimeSeconds )
		{
			RecursionCount++;
			if( RecursionCount > MaxRecursionCount )
			{
				#debug DMAI( "  EvaluateAttackSituation MaxRecursionCount exceeded going to " $ DefaultDeadLockedState );
				Outer.GotoState( DefaultDeadLockedState );
				return;
			}
		}
		else
		{
			LastTimeSeconds = Level.TimeSeconds;
			RecursionCount = 0;
		}
	
		#debug DMAI( "  EvaluateAttackSituation -- selecting " $ SelectedBehaviorState $ "," $ SelectedBehaviorLabel $ " setting timer (" $ SelectedBehaviorDuration $ " secs)" );

		if( SelectedBehaviorDuration > 0.0 )
			AddTimerSafe( CheckBehaviorTimerName, SelectedBehaviorDuration, false );
		else
			RemoveTimer( CheckBehaviorTimerName );

		if( Outer.IsInState( SelectedBehaviorState ) )
		{
			InitializeState();
			if( SelectedBehaviorLabel != NoLabel )
				Outer.GotoLabel( SelectedBehaviorLabel );
		}
		else
		{
			Outer.GotoState( SelectedBehaviorState, SelectedBehaviorLabel );
		}
	}
}

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

function CheckBehavior()
{
	#debug   Update( BC_BehaviorTimeOut, GetContext() );
	#release Update( BC_BehaviorTimeOut );
}

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

function CheckBehaviorTimer()
{
	//DMTNS( Self $ ".CheckBehaviorTimer() called" );
	CheckBehavior();
}

/*-----------------------------------------------------------------------------
We disable cover use here temporarily so that an NPC that was just using cover 
when this behavior timed out (i.e. after AttackUseCoverMinTime ..
AttackUseCoverMaxTime secs) doesn't go right back to using cover just because 
the odds of using the MoveToCover state (in the AttackActive/Passive metastate) 
are so high for many NPCs.

We don't currently do something like this for melee attacks since these are
basically controlled by MeleeOdds whenever the enemy is in range (there are no
behavior lists which will tell the NPC to "try" to do a melee attack).
*/

function CheckMetaState()
{
	if( MetaState == MS_AttackActiveUseCover || MetaState == MS_AttackPassiveUseCover )
		DisableBehaviorTemporarily( AttackMoveToCoverCombatState, U2PBasic.AttackUseCoverTimeOutTime * (2.0 - Level.Game.GetNormalizedDifficulty()) );
	#debug   Update( BC_MetaStateTimeOut, GetContext() );
	#release Update( BC_MetaStateTimeOut );
}

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

function CheckMetaStateTimer()
{
	//DMTNS( Self $ ".CheckMetaStateTimer() called" );
	CheckMetaState();
}

//-----------------------------------------------------------------------------
//@ ATTACK FIRING CONTROL
//-----------------------------------------------------------------------------

function CheckFireShot()
{
	local int NumAmmoTypes;
	local float FireRate;
		
	#debug DMAIA( "CheckFireShot" );
	#debug DMAIA( "  CanFire():                " $ CanFire( true ) );
	#debug DMAIA( "  IsFiring():               " $ IsFiring() );
	#debug DMAIA( "  IsPreparedToFire( true ): " $ IsPreparedToFire( true ) );

	//DMTNS( "CheckFireShot" );
	//DMTNS( "  CanFire():                " $ CanFire() );
	//DMTNS( "  IsFiring():               " $ IsFiring() );
	//DMTNS( "  IsPreparedToFire( true ): " $ IsPreparedToFire( true ) );
	
	bNPCSetFireShotDelay = false;
	if( IsFiring() )
	{
		// must be currently rapid firing (non-rapid firing is stopped after a single shot below)
		//#debug DMAIA( "BehaviorController.CheckFireShot stop rapid firing for " $ U2PBasic.FireFastPauseTime );
		//DMTNS( "  BehaviorController.CheckFireShot stop rapid firing for " $ U2PBasic.FireFastPauseTime );
		// mdf-tbd: just keep firing until we're out of ammo?
		// ResetFiring();
		#debug   StopFiring( 0.0, SFI_Behavior, GetContext() );
		#release StopFiring( 0.0, SFI_Behavior );
		#debug   SetCheckFireShotTimer( U2PBasic.FireFastPauseTime, false, GetContext(0) );
		#release SetCheckFireShotTimer( U2PBasic.FireFastPauseTime, false );
	}
	else if( ControllerEnemy == None )
	{
		// no enemy (and behavior controller was bypassed?)
		//DMTNS( "removing timer?" );
		RemoveTimer( CheckFireShotTimerName );
	}
	else if( !CanFire( false ) )
	{
		// AI is preventing us from firing (e.g. NPC is dodging) -- try again shortly
		//DMTNS( "!CanFire( true )" );
		#debug   SetCheckFireShotTimer( U2PBasic.FireCheckFailedRate, false, GetContext(0) );
		#release SetCheckFireShotTimer( U2PBasic.FireCheckFailedRate, false );
	}
	else if( !IsPreparedToFire( true ) )
	{
		//!!mdf-tbd: might be best to have weapon tell NPC when it starts reloading & set the timer 
		// for the anticipated reload time -- same thing when switching weapon?
		//DMTNS( "!IsPreparedToFire()" );
		#debug   SetCheckFireShotTimer( 0.5, false, GetContext(0) );
		#release SetCheckFireShotTimer( 0.5, false );
	}
	else
	{
		// ready and prepared to fire
		
		// if weapon supports multiple ammo types (grenade launcher), occasionally mix them up
		if( Level.TimeSeconds > NextSetAmmoTime && Pawn != None && Pawn.Weapon != None )
		{
			NumAmmoTypes = Pawn.Weapon.GetNumAmmoTypes();
			if( NumAmmoTypes > 1 )
			{
				Pawn.Weapon.SetAmmoType( Rand( NumAmmoTypes ) );
				NextSetAmmoTime = Level.TimeSeconds + RandRange( MinSetAmmoDelay, MaxSetAmmoDelay );
			}
		}
		
		//!!mdf
		//stuff to factor in here?
		// if( IsPreparedToFire( true ) && FRand() < 0.5 && VSize( ControllerEnemy.Location - GetLastEnemySeenLocation() ) < 150 && ClearShot() && CanStakeOut() )
		#debug DMAIA( "BehaviorController.CheckFireShot calling FireAt()" );
		//DMTNS( "BehaviorController.CheckFireShot calling FireAt()" );
		FireAt( ControllerEnemy );
		#debug DMAIA( "BehaviorController.CheckFireShot called FireAt() bFire: " $ bFire $ " bAltFire: " $ bAltFire $ " FireRate: " $ GetCurrentFireRate() );
		//DMTNS( "BehaviorController.CheckFireShot called FireAt() bFire: " $ bFire $ " bAltFire: " $ bAltFire $ " FireRate: " $ GetCurrentFireRate() );

		if( bFire > 0 || bAltFire > 0 )
		{
			FireRate = GetCurrentFireRate();
			
			// actually fired weapon
			if( FireRate > U2Weapon.MaxRapidFireRate )
			{
				#debug DMAIA( "BehaviorController.CheckFireShot ResetFiring() (slow) for " $ U2PBasic.FireSlowPauseTime );
				//DMTNS( "  BehaviorController.CheckFireShot ResetFiring() (slow) for " $ U2PBasic.FireSlowPauseTime );
				#debug   StopFiring( 0.0, SFI_Behavior, GetContext() ); //!! if NPCs ever start to use animation-based attacks which are "rapid" (ie. they don't use the code below) this will stop the animation before anything happens (no notify).
				#release StopFiring( 0.0, SFI_Behavior ); //!! if NPCs ever start to use animation-based attacks which are "rapid" (ie. they don't use the code below) this will stop the animation before anything happens (no notify).
				if( U2PBasic.FireSlowPauseTime > 0.0 )
				{
					#debug   SetCheckFireShotTimer( U2PBasic.FireSlowPauseTime, false, GetContext(0) );
					#release SetCheckFireShotTimer( U2PBasic.FireSlowPauseTime, false );
				}
				else
				{
					#debug   SetCheckFireShotTimer( FireRate, false, GetContext(0) );	// use weapon's refire rate?
					#release SetCheckFireShotTimer( FireRate, false );	// use weapon's refire rate?
				}
			}
			else
			{
				#debug DMAIA( "BehaviorController.CheckFireShot continuing to rapid fire for " $ U2PBasic.FireFastDuration );
				//DMTNS( "  BehaviorController.CheckFireShot continuing to rapid fire for " $ U2PBasic.FireFastDuration );
				#debug   SetCheckFireShotTimer( U2PBasic.FireFastDuration, false, GetContext(0) );
				#release SetCheckFireShotTimer( U2PBasic.FireFastDuration, false );
			}
		}
		else
		{
			// generally assume that whatever prevented us from firing (usually in 
			// AdjustAim) will have reset the fire shot timer as needed but in some
			// cases this might not be true (e.g. weapon not ready to fire)?
			if( TimeRemaining( CheckFireShotTimerName ) <= 0.0 )
			{
				//DMTNS( "no time left on timer -- resetting" );
				#debug   SetCheckFireShotTimer( U2PBasic.FireCheckFailedRate, false, GetContext(0) );
				#release SetCheckFireShotTimer( U2PBasic.FireCheckFailedRate, false );
			}
		}
	}
	
	//DMTNS( "CheckFireShot DONE -- next call in: " $ TimeRemaining( CheckFireShotTimerName ) );
}

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

function CheckFireShotTimer()
{
	//DMTNS( Self $ ".CheckFireShotTimer() called" );
	CheckFireShot();
}

//-----------------------------------------------------------------------------
//@ INIT/CLEANUP
//-----------------------------------------------------------------------------

function CleanupBC()
{
	bCleaned = true;
	
	/*
	DMT( Self $ " removing all timers" );
	DM( "BehaviorTimer: " $ class'Util'.static.GetFloatString( TimeRemaining( CheckBehaviorTimerName ) ) @
		"MetaStateTimer: " $ class'Util'.static.GetFloatString( TimeRemaining( CheckMetaStateTimerName ) ) @
		" FireShotTimer: " $ class'Util'.static.GetFloatString( TimeRemaining( CheckFireShotTimerName ) ) @
		" MetaState: " $ EnumStr( enum'EMetaState', MetaState, 3 ) );
	*/
		
	RemoveAllTimers();
}

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

defaultproperties
{
	LastSelectedBehaviorIndex=-1
	LastAttackActiveIndex=-1
	LastAttackActiveCantReachIndex=-1
	LastAttackActiveEnemyNotVisibleIndex=-1
	LastAttackActiveUseCoverIndex=-1
	LastAttackActiveMeleeIndex=-1
	LastAttackActiveMeleeHitIndex=-1
	LastAttackPassiveIndex=-1
	LastAttackPassiveCantReachIndex=-1
	LastAttackPassiveEnemyNotVisibleIndex=-1
	LastAttackPassiveUseCoverIndex=-1
	LastAttackPassiveMeleeIndex=-1
	LastAttackPassiveMeleeHitIndex=-1
	bEnabled=true
	MinSetAmmoDelay=1.000000
	MaxSetAmmoDelay=5.000000
}