U2AIOld.U2NPCControllerAdvancedOld

//=============================================================================
// U2NPCControllerAdvancedOld.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 12/16/02 5:46p $
// $Revision: 21 $
//=============================================================================

class U2NPCControllerAdvancedOld extends U2NPCControllerBaseOld;

/*-----------------------------------------------------------------------------
mdf-tbd:

+NPCs are too eager to attack without having much inventory and/or a good weapon.

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

/*-----------------------------------------------------------------------------
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.
*/

// Paul du Bois' timers rule!...
const CheckCurrentWeaponTimerName	= 'CheckCurrentWeaponTimer';
const SelectBestWeaponTimerName		= 'SelectBestWeaponTimer';

const ReloadSkillDumb				= 0.00;	// <= never checks if good time to reload
const ReloadSkillSmart				= 0.75;	// >= 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;
var		float		RateBestWeaponChecksEnemy;
var		float		LastWeaponSwitchTime;
var		float		NextCheckReloadTime;

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

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, RateBestWeaponChecks );
}

//-----------------------------------------------------------------------------
//@ MISC
//-----------------------------------------------------------------------------

function bool CanRespawn()
{
	return false;
}

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

function SetPeripheralVision()
{
	Super.SetPeripheralVision();

	if( Pawn != None && bSniping && AmbushSpot != None )
		Pawn.SetSightRadius( AmbushSpot.SightRadius );
}

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

function bool UseTacticalJumps()
{
	return false; // disable for advanced NPCs?
}

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

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 float GetSpecifiedFireRate( bool bPrimary )
{
	local float FireRate;
	
	if( 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 );
}

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

function FireShot( byte bUseAltMode )
{
	#debug DMAIA( "FireShot -- Weapon: " $ Pawn.Weapon $ " bUseAltMode: " $ 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;

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

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

#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 );

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

	if( Pawn != None && Pawn.Weapon != None && bWasFiring )
		Pawn.Weapon.Tick( 0.001 ); // make sure weapon knows it is no longer firing

	ResetAttackTimer( SuggestedFireAgainDelay );
}

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

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, U2PawnAdvanced(Pawn).DisabledFireWeapons );
}

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

function bool SupportsWeaponAltFire( Weapon W )	
{ 
	return SupportsWeapon( W, U2PawnAdvanced(Pawn).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 );
}

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

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

//	Focus = A;

	#debug DMAIA( "FireAt" );

/*mdf-STBW improvements		
	// let STBW timer handle all weapon switching (unless Weapon asks for this or we nab a pickup)
	SwitchToBestWeapon( Rating, bUseAltMode );
*/

//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 );
		}
		else
		{
			bReadyToAttack = true;
			return;
		}
	}
}

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

function bool AmmoReadyForAction( U2Weapon U2W )
{
	// enough ammo for at least once use is fine in singleplayer
	return( U2W != None && U2W.HasEnoughAmmo( 1 ) );
}

//-----------------------------------------------------------------------------
// mdf-tbd: anything else that should affect this for singleplayer?
// mdf-tbd: how should this work for singleplayer -- what to do about low 
// health and energy if the NPC can't obtain any more in the current level --
// run away and become less aggressive / ignore and keep attacking as if at 
// full health / armor.

function bool ReadyForAction()
{
	return( Pawn != None &&
			Pawn.Weapon != None &&
			Pawn.Weapon.AIRating >= 0.4 &&
			//Pawn.Health > 70 &&
			//(U2Pawn(Pawn).GetPowerSuitMax() == -1.0 || U2Pawn(Pawn).GetPowerSuitPct() > 0.25 ) &&
			AmmoReadyForAction( U2Weapon(Pawn.Weapon) ) );
}

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

function bool CanFire( bool bTest ) { return true; }

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

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;

//	if( Pawn != None )
//		DMTNS( "SwitchToBestWeapon begin -- Weapon: NA" );
//	else
//		DMTNS( "SwitchToBestWeapon begin -- Weapon: " $ Pawn.Weapon );
	if( Pawn != None && Pawn.Inventory != None && ShouldSwitchToBestWeapon( Rating, (bUseAltMode==1)) )
	{
		Rating = U2Weapon.RatingNone;

		Pawn.PendingWeapon = Pawn.Inventory.RecommendWeapon( ControllerEnemy, Rating, bUseAltMode );

		//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( Pawn.Weapon == None )
			{
				Pawn.ChangedWeapon();
				bSwitching = true;
			}
			else if( Pawn.Weapon != Pawn.PendingWeapon )
			{
				//DMTNS( "  Calling Pawn.Weapon.PutDown()" );
				#debug   StopFiring( 0.5, SFI_WeaponSwitch, GetContext() );
				#release StopFiring( 0.5, SFI_WeaponSwitch );
				Pawn.Weapon.PutDown();
				bSwitching = true;
			}
		}

		if( Rating <= U2Weapon.RatingIneffective && (bFire != 0 || bAltFire != 0) )
		{
			// #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
			SetSharedTimer( 0.1, false );
			//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?
//
// mdf-tbd: store # weapons in inventory somewhere. If NPC has only 1 weapon,
// there's no need to perform much of this work -- there's nothing else to
// switch to...  Hmm, but what about weapon becoming dangerous, e.g. because
// the enemy closed in on an NPC with a RL -- we'd need to rate the weapon in
// that case.

// 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;

	#debug DMAIA( "CheckCurrentWeapon -- begin" );

	//log( "CheckCurrentWeapon -- Weapon: " $ Pawn.Weapon $ " enemy: " $ ControllerEnemy );
	if( Pawn != None && Pawn.Weapon != None )
	{
		Rating = Pawn.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
			//log( "CheckCurrentWeapon -- calling STBW" );
			SwitchToBestWeapon( Rating, bUseAltMode );
		}

		// check if should reload weapon?
		if( !UnderScriptControl() )
		{
if( WeaponInvGrenadeLauncher(Pawn.Weapon)==None )	//!!ARL/MDF: TEMP DEMO HACK -- REMOVE
{
			if( GetSkill() > ReloadSkillDumb && Level.TimeSeconds >= NextCheckReloadTime )
			{
				// if no LOS to enemy, reload current weapon if not fully loaded
				if( (ControllerEnemy == None || !LineOfSightTo(ControllerEnemy)) && (OldControllerEnemy == None || !LineOfSightTo(OldControllerEnemy)) )
					U2Weapon(Pawn.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" );
	}
}

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

function CheckCurrentAmmo()
{
	local int NumAmmoTypes;
	
	// if weapon supports multiple ammo types (grenade launcher), occasionally mix them up
	if( Pawn != None && Pawn.Weapon != None )
	{
		NumAmmoTypes = Pawn.Weapon.GetNumAmmoTypes();
		if( NumAmmoTypes > 1 )
			Pawn.Weapon.SetAmmoType( Rand( NumAmmoTypes ) );
	}
}

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

final function CheckCurrentWeaponTimer()
{
	CheckCurrentWeapon();
	CheckCurrentAmmo();
}

//-----------------------------------------------------------------------------
// 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()
{
	// mdf-tbd: sloow?
	//return;

	//DMTNS( "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, RateBestWeaponChecks );
	}
	else
	{
		if( RateBestWeaponChecksEnemy > 0.0 )
			AddTimer( SelectBestWeaponTimerName, RateBestWeaponChecksEnemy, true, RateBestWeaponChecksEnemy );
	}

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

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

final function SelectBestWeaponTimer()
{
	SelectBestWeapon();
}

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

function float GetAttackStyle( Actor TargetActor )
{
	if( Pawn.Weapon != None )
		return Pawn.Weapon.SuggestAttackStyle( TargetActor );
	else
		return 0.0;
}

//-----------------------------------------------------------------------------
//@ STATE CODE
//-----------------------------------------------------------------------------

state @ FrozenState
{
	function CheckCurrentWeapon();
	function SelectBestWeapon();
	function bool NonRangedFireCheck() { return false; }
}

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

state @ RoamingState
{
	ignores EnemyNotVisible;

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

	function HearPickup( Pawn Other )
	{
		if( GetSkill() < FRand() - 0.125 )
			return;

		if( (Pawn.Health > 70) && (Pawn.Weapon.AIRating > 0.6) && (RelativeStrength( Other ) < 0) )
			HearNoise( 0.5, Other );
	}

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

	function bool PickFarInventoryDestination()
	{
		// look for long distance inventory 
		FindBestInventoryPath( MoveTarget, 0.0, (GetSkill() >= 0.75) );
		#debug DMAIM( "PickFarInventoryDestination MoveTarget: " $ MoveTarget );
		return( MoveTarget != None );
	}

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

	function ShareWith( Pawn Other )
	{
		local bool bHaveItem, bIsHealth, bOtherHas, bIsWeapon;

		#debug DMAIM( "ShareWith" );

		if( WeaponPickup(MoveTarget) != None )
		{
			if( ( Pawn.Weapon == None ) || ( Pawn.Weapon.AIRating < 0.5 ) || WeaponPickup(MoveTarget).bWeaponStay )
				return;

			bIsWeapon = true;
			bHaveItem = (Pawn.FindInventoryType( Pickup(MoveTarget).InventoryType ) != None );
		}
/*
		// mdf-tbd //MDF: no such thing as Health class should also handle energy etc.
		else if( Health(MoveTarget) != None )
		{
			bIsHealth = true;
			if( Pawn.Health < 80 )
				return;
		}
*/

		if( (Other.Health <= 0) || 
			(VSize( Other.Location - Pawn.Location ) > 1250) || 
			!LineOfSightTo( Other ) )
			return;

		//decide who needs it more
		CampTime = 2.0;
		if( bIsHealth )
		{
			if( Pawn.Health > Other.Health + 10 )
			{
				GotoLabel( GiveWayLabel );
				return;
			}
		}
		else if( bIsWeapon && ( Other.Weapon != None ) && ( Other.Weapon.AIRating < 0.5 ) )
		{
			GotoLabel( GiveWayLabel );
			return;
		}
		else
		{
			bOtherHas = ( Other.FindInventoryType( Pickup( MoveTarget ).InventoryType ) != None );
			if( bHaveItem && !bOtherHas )
			{
				GotoLabel( GiveWayLabel );
				return;
			}
		}
	}

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

	function bool ShouldRecamp()
	{
		return ( (Pawn != None) &&
				 ((Orders != OrdersFollow) || 
				  ((Controller(OrdersObject).Pawn != None) && 
				   IsCloseToDynamicGoal( Controller(OrdersObject).Pawn ))) && 
				 (Pawn.Weapon != None) && 
				 (Pawn.Weapon.AIRating > 0.4) && 
				 (0.75*FRand() > GetSkill() + 0.125) );
	}

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

	function ModifyPickupMoveTarget()
	{
		#debug DMAIM( "MoveTarget is Pickup: " $ MoveTarget );
	
		if( Orders == OrdersFollow )
		{
			ShareWith( Controller( OrdersObject ).Pawn );
		}
		/*
		mdf-tbd: 

		Could be made more general -- is there any teammate [in the area] that 
		needs this pickup more than the NPC?
		
		The old code only worked if the NPC had point and had a SupportingPlayer
		but, really, there is no reason to check for sharing with any teammate.
		
		This would also potentially eliminate the above call to sharewith.
		else if( bHasPoint )
		{
			// ShareWith( SupportingPlayer.Pawn );
		}
		*/
	}

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

	function MaybeHandleSpecialDestination()
	{
		if( Pickup(MoveTarget) != None )
		{
			ModifyPickupMoveTarget();
		}
	}

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

	event BeginState()
	{
		Super.BeginState();
		bNoShootDecor = false;
	}
} // RoamingState

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

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 );
		if( Orders == OrdersHold || Orders == OrdersFollow )
			GotoState( RoamingState );

		return bResult;
	}
} // WanderingState

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

defaultproperties
{
	RateCurrentWeaponChecks=2.000000
	RateBestWeaponChecks=5.000000
	RateBestWeaponChecksEnemy=2.000000
	DefaultMeleeAttackState='AttackStationary'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}