U2AI.U2NPCControllerAdvanced

//=============================================================================
// U2NPCControllerAdvanced.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 12/17/02 1:06p $
// $Revision: 50 $
//=============================================================================

class U2NPCControllerAdvanced extends U2NPCControllerBasic;

/*-----------------------------------------------------------------------------
OVERVIEW:

This is the AI Controller class for NPCs which can react to and attack enemies 
and use actual inventory weapons, possibly in combination with animation-based 
attacks.

Move here:
	Any Weapon related code.

Weapons should look at damage radius and determine "dangerous" distance from this
instead of hard-coding these (so that changes to the weapon/projectile properties
will automatically be taken into account).

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

/*-----------------------------------------------------------------------------
Advanced NPCs:
	+weapon use
	+can shoot decorations to get items
	+advanced non-bot movement

Weapon Selection:

One timer is used to reevaluate all weapons in the NPCs inventory every 5 secs
or so (tbd - more often if NPC has an enemy) and the NPC will switch to the
best weapon at that time. The function SwitchToBestWeapon is used to perform
the rating and initiate a weapon switch if necessary.

Another timer evaluates the current weapon every 0.2 secs or so. If the rating
for the current weapon becomes unacceptable, this timer can result in a call
to SwitchToBestWeapon.

When picking up a weapon, the Weapon code will generally check to see whether
the newly-acquired weapon is more highly rated than the current one and, if
so, switch to the new weapon. NPCs can override AllowPickupWeaponSwitch, e.g.
if the NPC is currently firing the current weapon. This is done in 
Weapon.ClientWeaponSet.

When picking up ammo, no action is necessary unless the NPC already has the
weapon which uses that ammo in his inventory. This can happen when running
across ammo while already having the weapon or by running over a weapon with
or without the weapon already present. When this happens, the weapon will be
compared with the current one (unless its already selected) to see if the
NPC should switch to it.  This is also done in Weapon.ClientWeaponSet and
the NPC can disable this switch also if desired.
*/

// AI flags
//var bool bFiringPaused;				
//var bool bMustHunt;
//var bool bNoShootDecor;				// set to true to prevent NPC from targetting a decoration 2x within Roaming state (cleared on entering Roaming state)
//var bool bStrafeDir;					
//var bool bWantsToCamp;				

const CheckCurrentWeaponTimerName	= 'CheckCurrentWeaponTimer';
const SelectBestWeaponTimerName		= 'SelectBestWeaponTimer';

const ReloadSkillDumb				= 0.00;	// <= never checks if good time to reload
const ReloadSkillSmart				= 0.50;	// >= always checks if good time to reload
const MaxCheckReloadDelay			= 10.0; // max time between checking reloads for [dumb..smart]

var	float RateCurrentWeaponChecks;
var	float RateBestWeaponChecks, RateBestWeaponChecksSpread;
var	float RateBestWeaponChecksEnemy, RateBestWeaponChecksEnemySpread;
var	float LastWeaponSwitchTime;
var	float NextCheckReloadTime;

var protected int NumWeapons;				// number of weapons this NPC currently has

//-----------------------------------------------------------------------------
//@ _INIT/RESTART
//-----------------------------------------------------------------------------

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

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

event Destroyed()
{
	RemoveAllTimers();
	Super.Destroyed();
}

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

function AddWeaponTimers()
{
	if( RateCurrentWeaponChecks > 0.0 )
		AddTimer( CheckCurrentWeaponTimerName, RateCurrentWeaponChecks, true, RateCurrentWeaponChecks );
	if( RateBestWeaponChecks > 0.0 )
		AddTimer( SelectBestWeaponTimerName, RateBestWeaponChecks, true, RateBestWeaponChecksSpread );
}

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

function ResetGlobalAISettings()
{
	Super.ResetGlobalAISettings();
	#debug   StopFiring( 0.0, SFI_Behavior, GetContext() );
	#release StopFiring( 0.0, SFI_Behavior );

	//tbd:
	//bKamikaze = false;
	//BlockedPath = None;
}

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

function NotifyAddInventory( Inventory AddedItem )
{
	Super.NotifyAddInventory( AddedItem );
	
	if( Weapon(AddedItem) != None )
		NumWeapons++;
}

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

function NotifyRemoveInventory( Inventory RemovedItem )
{
	Super.NotifyRemoveInventory( RemovedItem );

	if( Weapon(RemovedItem) != None )
		NumWeapons--;
}

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

function int GetNumWeapons()
{
	return NumWeapons;
}

//-----------------------------------------------------------------------------
//@ COMBAT
//-----------------------------------------------------------------------------

function bool IsPreparedToFire( bool bOwner, optional bool bCheckWeaponRating, optional int MinWeaponRating )
{
	local byte bUseAltMode;
	
	// !!mdf-tbd: how often will this be called and if NPCs only have 1/2 weapons -- can we optimize this stuff?
	return( Super.IsPreparedToFire( bOwner, bCheckWeaponRating, MinWeaponRating ) &&
			Pawn != None &&
			Pawn.Weapon != None && 
			!Pawn.Weapon.bMeleeWeapon && 
			(!bOwner || (Pawn.Weapon.CanFire() && Pawn.Weapon.HasEnoughAmmo(1))) &&
			(!bCheckWeaponRating || Pawn.Weapon.RateSelf( ControllerEnemy, bUseAltMode ) >= MinWeaponRating) );
}

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

/*
Disabled for now since we don't have any melee-only weapons and we only do
animation-based melee attacks which is handled in the Basic AI so the Super
version of this function is sufficient.

function bool IsPreparedToMelee( bool bOwner, optional bool bCheckWeaponRating, optional int MinWeaponRating )
{
	// local byte bUseAltMode; tbd: pbly want this but need to test it carefully
	//mdf-tbd: support animation-based melee attacks for advanced NPCs (if MeleeOdds > 0.0)?
	
	return( Super.IsPreparedToMelee( bOwner, bCheckWeaponRating, MinWeaponRating ) ||
			(Pawn != None && 
			 Pawn.Weapon != None && 
			 //(!bCheckWeaponRating || Pawn.Weapon.RateSelf( ControllerEnemy, bUseAltMode ) > MinWeaponRating) &&
			 Pawn.Weapon.bMeleeWeapon && 
			 (!bOwner || Pawn.Weapon.CanFire())) );
}
*/

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

function bool SplashDamageAttack() 
{
	if( Pawn == None || Pawn.Weapon == None )
		return false;

	if( bFire != 0 )
		return Pawn.Weapon.bSplashDamage;

	if( bAltFire != 0 )
		return Pawn.Weapon.bAltSplashDamage;
		
	return false;
}

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

function bool HasInstantHitAttack()
{
	return ( Pawn.Weapon != None && Pawn.Weapon.bInstantHit );
}

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

function bool TrySplashDamageAttack() 
{
	return ( Pawn.Weapon != None && Pawn.Weapon.bRecommendSplashDamage );
}

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

function ChangedWeapon()
{
	local byte bUseAltMode;

	if( Pawn != None && Pawn.Weapon != None )
	{
		if( IsFiring() )
		{
			Pawn.Weapon.RateSelf( ControllerEnemy, bUseAltMode );
			FireShot( bUseAltMode );
		}
		Pawn.Weapon.SetHand( 0 );
	}
}

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

function bool AllowPickupWeaponSwitch( Weapon Self, float CurrentRating, float PendingRating )
{
	// allow switch if no enemy or no LOS to enemy or enough health and new weapon a lot better
	return( ControllerEnemy == None || !CanSee( ControllerEnemy ) || (Pawn.Health > 40 && (PendingRating - CurrentRating > 0.2)) );
}

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

function FireShot( byte bUseAltMode )
{
	// mdf-tbr: happening when killing an NPC which is firing under script control?
	// Should be able to assume that Pawn and Pawn.Weapon are valid when calling FireShot
	if( Pawn == None )
		return;

	#debug DMAIA( "FireShot -- Weapon: " $ Pawn.Weapon $ " bUseAltMode: " $ bUseAltMode );
	//DMTNS( "FireShot -- Weapon: " $ Pawn.Weapon $ "(" $ Pawn.Weapon.GetStateName() $ ") bUseAltMode: " $ bUseAltMode );

	if( bUseAltMode == 0 )
	{
		bFire = 1;
		bAltFire = 0;
		Pawn.Weapon.Fire();
	}
	else
	{
		bFire = 0;
		bAltFire = 1;
		Pawn.Weapon.AltFire();
	}
}

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

function float GetSpecifiedFireRate( bool bPrimary )
{
	local float FireRate;
	
	if( Pawn != None && Pawn.Weapon != None )
	{
		if( bPrimary )
			FireRate = Pawn.Weapon.RefireRate;
		else
			FireRate = Pawn.Weapon.AltRefireRate;
	}
	else
	{
		FireRate = U2Weapon.MinSlowFireRate; // weapon no longer firing -- assume was non-rapid fire weapon?
	}
	
	//DMTNS( "GetSpecifiedFireRate returning " $ FireRate $ " for weapon: " $ Pawn.Weapon $ " bPrimary: " $ bPrimary );
	return FireRate;
}

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

function float GetCurrentFireRate()
{
	return GetSpecifiedFireRate( bFire == 1 );
}

//-----------------------------------------------------------------------------
// Returns true if NPC is firing or is trying to fire. For animation-based NPCs
// this is the case if the ranged attack animation is currently playing.

function bool IsFiring()
{
	return ( (bFire + bAltFire != 0) || IsMeleeAttacking() );
}

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

function ResetFiring()
{
}
*/

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

#debug   function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr )
#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo )
{
	local bool bWasFiring;
	
	#debug DMAIA( "StopFiring advanced (" $ ContextStr $ "):" $ SuggestedFireAgainDelay );
	//DMTNS( "StopFiring advanced (" $ ContextStr $ "):" $ SuggestedFireAgainDelay );

	bWasFiring = (bFire != 0 || bAltFire != 0);

	if( bWasFiring )
	{
		// clear animation-based attack if any
		#debug   Super.StopFiring( SuggestedFireAgainDelay, SFInfo, ContextStr );
		#release Super.StopFiring( SuggestedFireAgainDelay, SFInfo );
	
		if( Pawn != None && Pawn.Weapon != None )
			Pawn.Weapon.Tick( 0.001 ); // make sure weapon knows it is no longer firing
	}
}

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

function bool SupportsWeapon( Weapon W, array<name> WeaponsList ) 
{
	local int ii;
	local bool bRetVal;
	local name WeaponName;

	bRetVal = true;
	ii=0;
	while( ii < WeaponsList.Length )
	{
		WeaponName = WeaponsList[ ii ];

		if( WeaponName != '' && W.IsA( WeaponName ) )
		{
			bRetVal = false;
			break;
		}
		ii++;
	}

	return bRetVal;
}

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

function bool SupportsWeaponFire( Weapon W )	
{
	return SupportsWeapon( W, U2PAdvanced.DisabledFireWeapons );
}

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

function bool SupportsWeaponAltFire( Weapon W )	
{ 
	return SupportsWeapon( W, U2PAdvanced.DisabledAltFireWeapons );
}

//-----------------------------------------------------------------------------
// mdf-tbd: generalize? Currently used when script changes fire/altfire enabled
// status to update the affected weapon if in the NPC's inventory.

function RefreshWeapon( name WeaponName )
{
	local Inventory Inv;

	if( Pawn != None )
	{
		for( Inv=Pawn.Inventory; Inv!=None; Inv=Inv.Inventory )
		{
			if( Inv.IsA( WeaponName ) )
				U2Weapon(Inv).Refresh();
		}
	}
}

//-----------------------------------------------------------------------------
// Assuming we selected the best weapon (corresponding to the given Rating)
// decide whether we actually want to fire the weapon. Less skilled NPCs may
// try to fire the weapon even if it isn't ready (e.g. no ammo) or could 
// actually be dangerous to the NPC.

function bool ShouldFireWeapon( float Rating, bool bUseAltMode )
{
	// check if weapon has ammo and isn't totally useless
	// mdf-tbd: if already firing the same weapon and the Rating hasn't changed, make sure
	// we keep firing it for a while (mainly for ineffective -- dangerous and cantfire 
	// could cut off more quickly).

	/* mdf-tbd: currently won't stop firing once firing and current odds seem to make it very likely that NPC will start firing
	return( (Rating > U2Weapon.RatingIneffective) || // weapon is at least somewhat effective
			(Rating == U2Weapon.RatingDangerous && SkillScaledDecision( 0.0, 5.0, 0.2, 0.0 )) || // firing weapon is actually dangerous
			(Rating == U2Weapon.RatingNoAmmo && SkillScaledDecision( 0.0, 5.0, 0.1, 0.0 )) || // weapon has no ammo or not ready
			(Rating == U2Weapon.RatingIneffective && SkillScaledDecision( 0.0, 5.0, 0.3, 0.0 )) ); // weapon is ineffective (e.g. too far to target)
	*/
	// course -- if weapon starts firing because rating > ineffective then it decreases, still have problem of
	// not stopping firing (sigh -- this all use to work fine with U2436 -- I spent hours tweaking the FT...)
	//return ( Rating > U2Weapon.RatingIneffective );

	if( Rating > U2Weapon.RatingIneffective )
		return true;
		
	if( Rating >= U2Weapon.RatingNoAmmo )
		return false; // can't physically fire weapon
		
	if( NumWeapons == 1 )
		return true; // if this is the only available weapon, just fire it?

	// tbd: check other weapon ratings and fire if none is more effective?		
	return false;
}

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

function FireAt( Actor A )
{
	local byte bUseAltMode;
	local float Rating;

	#debug DMAIA( "FireAt" );

//NEW (mdf) Fix?
	/* SwitchToBestWeapon is changing the weapon but the current weapon is still getting a chance to fire
	   and its using the bUseAltMode set for the pending weapon. This is invalid in many cases -- e.g.
	   alt/primary fire is disabled for some weapons and that mode might not be the best for the current
	   situation. Bottom line is that if there is a pending weapon, we shouldn't be trying to fire the
	   current one. Its possible that this is also causing weapons to lock up and keep firing for a
	   long time? */
//	if( Pawn.Weapon != None && (Pawn.PendingWeapon == None || Pawn.PendingWeapon == Pawn.Weapon) )
///*OLD
	if( Pawn.Weapon != None )
//*/
	{
		// mdf-tbd: pbly doesn't hurt to refresh this info
		Rating = Pawn.Weapon.RateSelf( A, bUseAltMode );
		if( ShouldFireWeapon( Rating, (bUseAltMode==1) ) )
		{
			SetRotation( Pawn.Rotation );
			FireShot( bUseAltMode );
		}
	}
}

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

function float GetAttackStyle( Actor TargetActor )
{
	local float ReturnedStyle;
	
	if( U2PBasic.RangeIdealAttack > 0.0 )
		ReturnedStyle =  Super.GetAttackStyle( TargetActor );
	else if( Pawn.Weapon != None )
		ReturnedStyle =  Pawn.Weapon.SuggestAttackStyle( TargetActor );
	else
		ReturnedStyle =  StyleRetreat;
		
	//DMTNS( "Advanced.GetAttackStyle returning " $ ReturnedStyle );
	return ReturnedStyle;
}

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

function float GetDefenseStyle( Actor TargetActor )
{
	local float ReturnedStyle;
	
	if( U2PBasic.RangeIdealAttack > 0.0 )
		ReturnedStyle = Super.GetDefenseStyle( TargetActor );
	else if( Pawn.Weapon != None )
		ReturnedStyle = Pawn.Weapon.SuggestDefenseStyle( TargetActor );
	else
		ReturnedStyle =  StyleRetreat;
		
	//DMTNS( "Advanced.GetDefenseStyle returning " $ ReturnedStyle );
	return ReturnedStyle;
}

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

function float GetAttackRating( Pawn Other )
{
	local byte bTempUseAltMode;

	if( Pawn.Weapon != None )
		return Pawn.Weapon.RateSelf( Other, bTempUseAltMode );
	else
		return 0.0;
}

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

function float GetFireRating()
{
	if( Pawn.Weapon != None )
		return Pawn.Weapon.AIRating;
	else
		return 0.0;
}

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

function bool ShouldSwitchToBestWeapon( float Rating, bool bUseAltMode )
{
	// time limit must be up (randomize, affect by skill) or current weapon
	// has to be unusable
	return( (Level.TimeSeconds - LastWeaponSwitchTime >= 10.0) ||
			!ShouldFireWeapon( Rating, bUseAltMode ) );
}

//-----------------------------------------------------------------------------
// Note: can pass in Rating and bUseAltMode (obtained elsewhere, e.g. from a 
// call to RateSelf to possibly force a switch, possibly depending on the skill 
// of the NPC.

exec function bool SwitchToBestWeapon( optional out float Rating, optional out byte bUseAltMode )
{
	local bool bSwitching;
	local U2Weapon Weapon;
	
	if( NumWeapons <= 1 )
		return false;

	if( Pawn != None )
		Weapon = U2Weapon(Pawn.Weapon);
	
	//DMTNS( "SwitchToBestWeapon begin -- Weapon: " $ Weapon );

	//DMTNS( "STBW   Rating: " $ Rating $ " bUseAltMode: " $ bUseAltMode $ " Enemy: " $ ControllerEnemy );
	
	if( Pawn != None && Pawn.Inventory != None && ShouldSwitchToBestWeapon( Rating, (bUseAltMode==1)) )
	{
		Rating = U2Weapon.RatingNone;

		//DMTNS( "RecommendWeapon BEGIN" );
		Pawn.PendingWeapon = Pawn.Inventory.RecommendWeapon( ControllerEnemy, Rating, bUseAltMode );
		//DMTNS( "RecommendWeapon END" );

		//DMTNS( "  RecommendWeapon returned " $ Pawn.PendingWeapon $ " Rating: " $ Rating $ " bUseAltMode: " $ bUseAltMode );
//		#debug DMAIA( "  bFire=" $ bFire $ " bAltFire=" $ bAltFire );

		//NOTE: this was causing a problem in FireAt because the previous weapon was still
		//selected and was being fired with the new weapon's Rating/bUseAltMode, which was 
		//invalid for some weapons (e.g. FT alt-fire was temporarily disabled0.
		if( Pawn.PendingWeapon != None )
		{
			if( Weapon == None )
			{
				Pawn.ChangedWeapon();
				bSwitching = true;
			}
			else if( Weapon != Pawn.PendingWeapon )
			{
				#debug DMAIA( "  Calling Weapon.PutDown()" );
				#debug DMAssert( Weapon.DownTime > 0.2, GetContext() );
				#debug   StopFiring( FMin( 0.5, Weapon.DownTime ), SFI_WeaponSwitch, GetContext() ); // wait for switch
				#release StopFiring( FMin( 0.5, Weapon.DownTime ), SFI_WeaponSwitch ); // wait for switch
				Weapon.PutDown();
				bSwitching = true;
			}
		}

		if( Rating <= U2Weapon.RatingIneffective && IsFiring() )
		{
//			#debug DMAIA( "SwitchToBestWeapon calling StopFiring" );

			#debug   StopFiring( 0.2, SFI_WeaponRating, GetContext() ); // stop firing but check again soon
			#release StopFiring( 0.2, SFI_WeaponRating ); // stop firing but check again soon
		}
		else if( Rating == U2Weapon.RatingFireNow )
		{	
			#debug DMAIA( "SwitchToBestWeapon calling FireShot" );

			// fire immediately (e.g. for weapons which don't require an enemy to be effective)
			FireShot( bUseAltMode );

			// reevaluate weapon soon -- wait long enough for it to actually fire
			//bResult = SwitchToBestWeapon( Rating, bUseAltMode );
		}
	}

	if( bSwitching ) // make sure NPC doesn't go nuts switching back and forth?
		LastWeaponSwitchTime = Level.TimeSeconds;

	//DMTNS( "SwitchToBestWeapon end" );
	return bSwitching;
}

//-----------------------------------------------------------------------------
// mdf-tbd: just check the current weapon (checking all weapons slow) and add
// code elsewhere to make sure SwitchToBestWeapon called when a new weapon is
// obtained (i.e. assume best weapon in inventory currently selected and just
// check for whether the weapon wants us to fire it?).
//
// mdf-tbd: do advanced NPCs need this?
//
// This would also mean changing the way in which weapons (generalize
// to inventory) tells NPC to use it -- this shouldn't rely on the weapon needing
// to be rated. And, I think that currently, if an NPC runs over a Takkra, it will
// immediately insist that it is the highest rated weapon, forcing the NPC to
// switch to it and use it, perhaps at a bad time? Not sure about this but an 
// alternative might be to support inventory adding/removing itself from some
// list maintained by the NPC (or just add flag to inventory) which indicates that
// inventory wants NPC to use it. Then the mechanism for responding to such
// inventory could be decoupled from the code which rates inventory -- the takkra
// would track its own situation and add itself to this list whenever its projectile
// is destroyed for example.

function CheckCurrentWeapon()
{
	local float Rating;
	local byte bUseAltMode;
	local Pawn PotentialEnemy;
	local bool bTossed;
	local U2Weapon Weapon;
	
	if( Pawn != None )
		Weapon = U2Weapon(Pawn.Weapon);

	#debug DMAIA( "CheckCurrentWeapon -- begin: " $ Weapon );

	//log( "CheckCurrentWeapon -- Weapon: " $ Pawn.Weapon $ " Enemy: " $ ControllerEnemy );
	if( Pawn != None && Weapon != None )
	{
		Rating = Weapon.RateSelf( ControllerEnemy, bUseAltMode );

		//log( "CheckCurrentWeapon -- Rating: " $ Rating $ " bUseAltMode: " $ bUseAltMode );

		if( Rating == U2Weapon.RatingFireNow ) // Takkra etc. support
		{
			//log( "CheckCurrentWeapon -- fire now" );
			if( (bUseAltMode == 0 && bFire == 0) || (bUseAltMode == 1 && bAltFire == 0) )
			{
				// fire immediately (e.g. for weapons which don't require an enemy to be effective)
				FireShot( bUseAltMode );
	
				// re-evaluate weapon soon -- wait long enough for it to actually fire
				// mdf-tbd: could really use reset timer functions for this
				// mucking with best weapon timer in currentweapon timer confusing and causing former to never get called?
				// mdf-tbd: call to remove timers should be redundent if I fix AddTimer/S
				//	RemoveTimer( SelectBestWeaponTimerName);
				//	AddTimer( SelectBestWeaponTimerName, 0.5, false );
			}
		}
		else if( Rating <= U2Weapon.RatingIneffective )
		{
			#debug   StopFiring( 0.5, SFI_WeaponRating, GetContext() );
			#release StopFiring( 0.5, SFI_WeaponRating );
			// mucking with best weapon timer in currentweapon timer confusing and causing former to never get called?
			//mdf-tbd: call to remove timers should be redundent if I fix AddTimer/S
			//RemoveTimer( SelectBestWeaponTimerName);
			//AddTimer( SelectBestWeaponTimerName, 0.5, false );
			// just call STBW
			//DMTNS( "CheckCurrentWeapon -- calling STBW" );
			SwitchToBestWeapon( Rating, bUseAltMode );
		}

		// check if should reload weapon?
		if( !UnderScriptControl() )
		{
			if( GetSkill() > ReloadSkillDumb && Level.TimeSeconds >= NextCheckReloadTime )
			{
				// if no LOS to enemy && not shooting at last seen pos, reload current weapon if not fully loaded
				//if( (ControllerEnemy == None || !LineOfSightTo(ControllerEnemy)) && (OldControllerEnemy == None || !LineOfSightTo(OldControllerEnemy)) )

				PotentialEnemy = ControllerEnemy;
				if( PotentialEnemy == None )
					PotentialEnemy = OldControllerEnemy;
					
				if( PotentialEnemy == None )
				{
					Weapon.Reload();
				}
				else if( ControllerEnemy != None )
				{
					bTossed = ( Weapon.ProjectileClass != None && Weapon.ProjectileClass.default.Physics == PHYS_Falling );
					if( StopFiringAtEnemy( ControllerEnemy, bTossed ) )
						Weapon.Reload();
				}
		
				// smart NPCs will check for reload with every call to weapon timer handler
				if( GetSkill() < ReloadSkillSmart )
					NextCheckReloadTime = Level.TimeSeconds + RandRange( 0.5, MaxCheckReloadDelay*(1.0 - GetSkill()) );
			}
		}
	}
	
	//DMTNS( "CheckCurrentWeapon -- end  Weapon: " $ Pawn.Weapon $ " PendingWeapon: " $ Pawn.PendingWeapon );
}

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

final function CheckCurrentWeaponTimer()
{
	CheckCurrentWeapon();
}

//-----------------------------------------------------------------------------
// Called every 5 secs or so (configurable) to determine whether the NPC has a
// better weapon in his inventory for the current situation. If the NPC has an
// enemy, called every 0.5 seconds. Calls SwitchToBestInventory which should
// also be called whenever the NPC gains an inventory item

function SelectBestWeapon()
{
	#debug DMAIA( "SelectBestWeapon -- begin: " $ Pawn.Weapon );

	SwitchToBestWeapon();

	// reset timer -- don't re-evaluate *too* often -- pickups will cause immediate check vs current weapon though (through Weapon code)
	if( ControllerEnemy == None || !CanSee( ControllerEnemy ) )
	{
		if( RateBestWeaponChecks > 0.0 )
			AddTimer( SelectBestWeaponTimerName, RateBestWeaponChecks, true, RateBestWeaponChecksSpread );
	}
	else
	{
		if( RateBestWeaponChecksEnemy > 0.0 )
			AddTimer( SelectBestWeaponTimerName, RateBestWeaponChecksEnemy, true, RateBestWeaponChecksEnemySpread );
	}

	//DMTNS( "  Next Tick in " $ TimeRemaining( SelectBestWeaponTimerName ) );
	//DMTNS( "SelectBestWeaponTimer -- end: " $ Pawn.Weapon );
}

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

function SelectBestWeaponTimer()
{
	SelectBestWeapon();
}

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

function bool SetAmmoTypeStr( string AmmoString )
{
	if( Pawn.Weapon == None )
		return false;

	return Pawn.Weapon.SetAmmoTypeStr( AmmoString );
}

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

function EnemyAcquired()
{
	if( ControllerEnemy == None && RateBestWeaponChecksEnemy > 0.0 )
		AddTimer( SelectBestWeaponTimerName, RateBestWeaponChecksEnemy, true, RateBestWeaponChecksEnemySpread );
	
	Super.EnemyAcquired();
}

//-----------------------------------------------------------------------------
//@ INTERACTIONS
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Only called for Pawn's which are already known to be an enemy. Returns fear
// or attack.

function EReaction GetReactionToEnemy( Pawn EnemyPawn )
{
	if( bKamikaze )
		return REACTION_Attack;
	else
		return Super.GetReactionToEnemy( EnemyPawn );
}

//-----------------------------------------------------------------------------
//@ ORDERS
//-----------------------------------------------------------------------------

function UpdateOrders( name NewOrders, Actor NewOrdersObject, float NewOrdersThreshold, Object NewOrderGiver )
{
	Super.UpdateOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver );

	// mdf-tbd:
	if( bSniping && NewOrders != OrdersDefend )
		bSniping = false;
}

//-----------------------------------------------------------------------------
//@ STATES -- MAIN
//-----------------------------------------------------------------------------

state @ AttackMeleeState
{
	ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise, NotifyBump, EnemyInLeapRange, EnemyInMeleeRange;

	//-------------------------------------------------------------------------
	// NOTE: makes sure StopFiring not called if weapon rating is bad

	function CheckCurrentWeapon();		
	function SelectBestWeapon();
}

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

state @ FrozenState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, EnemyInLeapRange, EnemyInMeleeRange;

	function CheckCurrentWeapon();
	function SelectBestWeapon();
}

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

state @ ScriptedState
{
	function CheckCurrentWeapon();		
	function SelectBestWeapon();
}

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

state @ ScriptedDialogState
{
	function CheckCurrentWeapon();		
	function SelectBestWeapon();
}

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

state @ WanderingState
{
	ignores EnemyNotVisible;

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

	function bool SetOrders( optional name NewOrders, optional Actor NewOrdersObject, optional float NewOrdersThreshold, optional Object NewOrderGiver, optional bool bAcknowledge )
	{
		local bool bResult;

		#debug DMAI( "SetOrders " $ GetContext() );
		bResult = Global.SetOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver, bAcknowledge );

		//!!mdf
		//if( Orders == OrdersHold || Orders == OrdersFollow )
		//	GS( RoamingState ); //GS-tbd

		return bResult;
	}
} // WanderingState

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

state @ WanderingPanicState
{
	ignores BeginFalling, SeeEnemy, SeeFriend, SeeAlertFriend, SeeOther, NotifyBump, HearNoise, EnemyNotVisible; 
	ignores NotifyLanded, EnemyInLeapRange, EnemyInMeleeRange, NotifyHitWall;
}

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

defaultproperties
{
	RateCurrentWeaponChecks=2.000000
	RateBestWeaponChecks=10.000000
	RateBestWeaponChecksSpread=2.000000
	RateBestWeaponChecksEnemy=2.000000
	RateBestWeaponChecksEnemySpread=1.000000
	CosMinFacingTargetAngle=0.984000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}