U2AI.U2NPCControllerBasic

//=============================================================================
// U2NPCControllerBasic.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 1/07/03 10:31a $
// $Revision: 156 $
//=============================================================================

class U2NPCControllerBasic extends U2NPCControllerBase;

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

This is the AI Controller class for most NPCs which can react to and attack 
enemies but don't use actual inventory weapons (animation-based ranged and
melee attacks).
*/

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

const FakeNotifyLeapBeginTimerName	= 'FakeNotifyLeapBeginTimer';
const FreezeNPCHackTimerName		= 'FreezeNPCHackTimer';

const LeapBeginNotify				= 'LeapBeginNotify';
const StayNotify					= 'Stay';

const MinImpaleCos					= -0.93;	// impalee/impaler facing each other to within 20 degrees

//!!mdf-tbi: go off actual animation durations / update when animations changed
const CrouchStanceChangeDuration	= 0.50;
const ProneStanceChangeDuration		= 0.75;

// AI properties
var float	Aggressiveness;				// 0.0 to 1.0 (typically)
var Pawn	OldControllerEnemy;
var	vector	HidingSpot;
var float	VerifyCoverRate;

// AI flags
var bool bChangeDir;					// tactical move boolean
var bool bDeviousHunting;				// if true, try to sneak up behind enemy when hunting
var bool bFrustrated;				
var bool bInitiatingAttack;
var bool bKamikaze;					
var bool bSmartAboutTurrets;			// if true, knows to avoid attacking turrets (StationaryPawns for now)
var bool bSniping;						// mdf-tbd: approach changed in 777?
var bool bStationary;					// if set NPC can only rotate/aim
var bool bTriedLastDetectedLocation;	// used with hunting state
//tbd: just call LOS if not too slow? var protected bool bLOSToTarget;			// true when NPC has LOS to enemy (false means don't fire)

// orders
var name	Orders;						// orders a bot is carrying out 
var Object  OrderGiver;					// source of orders (e.g. player, GameAIController)
var	Actor	OrdersObject;				// order object (if applicable)
var float	OrdersThreshold;			// threshold used with some orders
var bool	bExecuteOrders;				// NPC will favor orders over attacking enemy (controlled, e.g., on a squad-basis)
var float	ExecuteOrdersThreshold;		// threshold used by NPC to decide whether to set/clear bExecuteOrders

var Actor	StationarySpot;				// holdspot used with stationary NPCs

// debug
var(Controller) globalconfig private bool bShowOrdersObjects;

// attacks
var class<BehaviorControllerInterf>	BehaviorControllerClass;
var BehaviorControllerInterf			BehaviorController;

var name DefaultAcquisitionState;		// state used when NPC acquires an enemy when relaxed
var name DefaultDeadLockedState;		// state used to wait a few ticks when behavior is deadlocked
var name DefaultImmobileState;			// state used to keep NPCs from moving
var name DefaultImmobileAttackState;	// state used to carry out ranged attack for immobile (stationary) NPCs

// internal
//!!mdf -- eliminate with external firing controller?
var bool bFireFalling;
var bool bStrafeDir;						
//mdf-tbd: var float LastFireTime;				
var float MaxFallbackNoDetectTime;
var float MaxHuntTime;	
var float LastInvFind;					// move to bot
var float RefireDelay;
var float LastSpecialDestinationCheck;
var NavigationPoint BlockedPath;		// tbd
var vector RealLastDetectedLocation;	// tbd
var EDestinationResult DestinationResult;	// result of last call to SetChargeDestination
var float LastBumpDamageTime;
var float StartTurnTime;
var float OldCheckBehaviorDelay, OldCheckMetaStateDelay;

var float AlertTime;

var float NextLeapTime;
var rotator PendingLeapRotation;
var float PendingLeapSpeed;
var bool bLeapNotifyTimeSet;
var bool bLeaping;
var vector LeapLastHitWallNormal;		// normal of last hit with wall (to prevent multiple hit wall notifications for the same hit)
var float LeapLastHitWallTime;			// last time a wall was hit
var float LeapMinHitWallDelay;			// minimum amount of time before acknowledging hit wall notifications

var Pawn ImpaleVictim;					// pawn we're impaling
var float MeleeEndTime;
var bool bMeleeDamagedTarget;			// set during successful melee attack

var vector StateStartLocation;			// used to save location at start of some states
var bool bAcceptedState;

// move to advanced+?
var Ambushpoint AmbushSpot;				// current AmbushSpot if applicable

var float StartDodgeTime;
var bool bDodgeFinished;				// true when dodge animation has finished playing

//-----------------------------------------------------------------------------
//@ DEBUG
//-----------------------------------------------------------------------------

function string GetExtendedStateInformation() 
{ 
	return BehaviorController.GetExtendedStateInformation();
}

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

function string GetMetaStateName()
{
	if( BehaviorController != None )
		return BehaviorController.GetCurrentMetaStateName();
	else
		return "NA";
}

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

function string GetMetaStateNameShort()
{
	if( BehaviorController != None )
		return BehaviorController.GetCurrentMetaStateNameShort();
	else
		return "NA";
}

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

//!!mdf-tbr:
#debugbegin
function VerifyStateChange( name OldState, name NewState, name Label, bool bGoto, string ContextStr, int ContextLineNum )
{
	local string ErrorStr;

	ErrorStr = "";

	// ignore transitions within the same state for now?
	if( NewState != OldState )
	{
		if( !IsMobile() )
		{
			switch( NewState )
			{
			case AttackCloseState:
			case AttackCloseChargeState:
			case AttackFallbackState:
			case AttackHideState: 
			case AttackHuntState:
			case AttackLeapState:
			case AttackMoveToCoverBaseState:
			case AttackMoveToCoverCombatState:
			case AttackMoveToCoverFleeState:
			case AttackRecoverEnemyState:
			//nope: let immobile NPCs use this for attacking:
			// case AttackStationaryState:
			case AttackRetreatState:
			case AttackStakeOutState:
			case AttackStakeOutCoverState:
			//!!mdf-tbd: can't think of a good way to handle these
			/*
			case AttackTacticalMoveState:
			case AttackTacticalMoveMeleeState:
			case AttackTacticalRetreatState:
			case AttackTacticalRetreatMeleeState:
			*/
			case FindAirState:
			case RoamingState:
			case WanderingState:
				ErrorStr = "Immobile NPC transitioning to state which requires movement (" $ NewState $ ")!";
			}
		}
	}

	if( ErrorStr != "" )
		DMAssert( false, "VerifyStateChange -- " $ ErrorStr $ "  CONTEXT=" $ ContextStr $ " Line=" $ ContextLineNum );
}
#debugend

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

function ClearReferencesTo( Pawn P )
{
	local Pawn PreviousControllerEnemy;
	
	PreviousControllerEnemy = ControllerEnemy;
	
	Super.ClearReferencesTo( P );

	if( OldControllerEnemy == P )
		OldControllerEnemy = None;

	// only called UpdateEnemy if previous enemy was the given Pawn
	if( PreviousControllerEnemy == P )
	{
		#debug   StopFiring( 0.0, SFI_Behavior, GetContext() );
		#release StopFiring( 0.0, SFI_Behavior );
		UpdateEnemy();
	}
}

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

function Restart()
{
	#debug   SetControllerEnemy( None, GetContext() );
	#release SetControllerEnemy( None );

	#debug DMAI( "Restart" );
	GotoState( DefaultState ); //GS-OK
}

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

function PossessStartup()
{
	Super.PossessStartup();
	
	if( U2PBase.bStationary )
		SetStationary( true );
}

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

function Possess( Pawn P )
{
	Super.Possess( P );

	P.PreSetMovement();
	
	BehaviorController = new BehaviorControllerClass;
	#debug DMAssert( BehaviorController != None, GetContext() );

	if( U2PBasic.bMonitorStanceRanges )
	{
		// for getting EnemyRangeTransition events (NPC stands up if enemy too close etc.)
		Ranges.Length = 2;
		Ranges[ 0 ] = U2PBasic.MinCrouchDistance;
		Ranges[ 1 ] = U2PBasic.MinProneDistance;
	}
}

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

event Destroyed()
{
	//DMTNS( "Destroyed  BehaviorController: " $ BehaviorController );

	RemoveAllTimers();

	if( BehaviorController != None )
	{
		BehaviorController.CleanupBC();
		BehaviorController.Delete();
		BehaviorController = None;
	}
	
	ClearCoverSpot();
	
	Super.Destroyed();
}

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

function ResetGlobalAISettings();

//-----------------------------------------------------------------------------
// NOTE: I'd like to eliminate this if possible and fold this behavior into the
// behavior controller. For now this should only be called when the NPC no longer
// has a valid enemy (or old enemy) and we want to know "what to do next" (all
// situations when the NPC does have an enemy should be captured / handled by
// the BC. All that WTDN should really do is put the NPC back into the scripted
// state if it has a script (and isn't in the scripted state currently) or let
// the NPC go back to its default state (tbd: go roaming to handle a priority
// objective?).

#debug   function WhatToDoNext( string ContextStr )
#release function WhatToDoNext()
{
	local name DestinationState, DestinationLabel;
	local bool bMaintainCurrentState;

	#debug DMAI( "U2NPCControllerBasic.WhatToDoNext (" $ ContextStr $ ") ScriptController=" $ ScriptController $ " Enemy=" $ ControllerEnemy $ " OldControllerEnemy=" $ OldControllerEnemy );

	ResetGlobalAISettings();

	//!!mdf-tbd: this is still happening:
	//DMAssert( ControllerEnemy == None && OldControllerEnemy == None, ContextStr $ "-->" $ GetContext() ); // all calls to WTDN should go through BC which will handle valid enemies through behavior lists
	// e.g. DM:  165.255 U2NPCControllerAdvanced1 AttackStationary WARNING (ASSERT!): assertion is invalid: WhatToDoNext (line 296) (Pawn=m08a1.U2Izarian4)
	
	//hack: we shouldn't be here if there is an enemy...
	if( ControllerEnemy != None )
	{
		//!!mdf-tbd: fix
		//DMAssert( false, ContextStr $ "-->" $ GetContext() ); // all calls to WTDN should go through BC which will handle valid enemies through behavior lists
		#debug   BehaviorController.Update( BC_AttackUpdate, ContextStr $ "-->" $ GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
		return;		
	}

	#debug DMAssert( OldControllerEnemy == None, "OldControllerEnemy: " $ OldControllerEnemy $ " " $ ContextStr $ "-->" $ GetContext() ); // all calls to WTDN should go through BC which will handle valid enemies through behavior lists
	#release DMAssert( OldControllerEnemy == None, "OldControllerEnemy: " $ OldControllerEnemy $ " " $ GetContext() ); // all calls to WTDN should go through BC which will handle valid enemies through behavior lists

	if( HasScript() )
	{
		if( GetStateName() == ScriptedState )
		{
			bMaintainCurrentState = true;
		}
		else
		{
			DestinationState = ScriptedState;

			#debug DMAI( "WTDN (Basic) selecting " $ ScriptedState $ " (default label)" );
			if( IsInState( ScriptedDialogState ) )
				DestinationLabel = BeginLabel;
			else
				DestinationLabel = AutoEndLabel;
		}
	}
	else if( bStationary )
	{
		DestinationState = DefaultImmobileState;
	}
	else if( Orders == OrdersNone || !ReadyForOrders() || !DetermineOrdersTransition( DestinationState, DestinationLabel ) )
	{
		DestinationState = DefaultState;
	}

	if( bMaintainCurrentState )
	{
		#debug DMAI( "WTDN maintaining current state: " $ GetStateName() );
	}
	else
	{
		#debug DMAI( "WTDN (Basic) selecting " $ DestinationState $ "," $ DestinationLabel );
		GotoState( DestinationState, DestinationLabel ); //GS-OK
	}
}

//-----------------------------------------------------------------------------
//@ EVENTS
//-----------------------------------------------------------------------------

function bool FriendlyBumpSpecial()
{
	local bool bResult;

	if( ControllerEnemy != None )
	{
		if( LineOfSightTo( ControllerEnemy ) )
		{
			if( !IsInState( AttackTacticalMoveState ) )
			{
				if( AllowFriendlyBumpStateChanges() )
					GotoState( AttackTacticalMoveState, DontCloseLabel ); //GS-tbd
			}
		}
		else if( !IsInState( AttackStakeOutState ) && FRand() < 0.5 )
		{
			if( AllowFriendlyBumpStateChanges() )
				GotoState( AttackStakeOutState ); //GS-tbd
			ClearLastSeenTimes();
		}

		bResult = true;
	}

	return bResult;
}

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

function bool WanderAfterFriendlyBumpExtra()
{
	return (
		AllowFriendlyBumpStateChanges() &&
		Pawn.Health > 0 && 
		ControllerEnemy == None && 
		Orders == OrdersFollow && 
		MoveTarget == Controller(OrdersObject).Pawn && 
		MoveTarget.Acceleration == vect(0,0,0) );
}

//-----------------------------------------------------------------------------
// At this point, enemy should already be set to the Pawn that bumped us.

function HandleBumpedByEnemy()
{
	GotoState( AttackStationaryState ); //GS-tbd
}

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

#debug   function SetControllerEnemy( Pawn Enemy, coerce string ContextString )
#release function SetControllerEnemy( Pawn Enemy )
{
	#debug   Super.SetControllerEnemy( Enemy, ContextString );
	#release Super.SetControllerEnemy( Enemy );
	if( OldControllerEnemy == ControllerEnemy )
		OldControllerEnemy = None;
}

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

function eventSeeOther( Actor Seen )
{
	local EAttitude AttitudeToOther;
	// placeholder hack -- if no enemy react to seeing a carcass
	//    eventually friendly/neutral --> go alert (seek cover, search area?
	//               enemy --> "check out carcass"?

	if( ControllerEnemy == None )
	{
		if( Pawn(Seen) != None && Pawn(Seen).Health <= 0 )
		{
			AttitudeToOther = GetAttitudeTo( Pawn(Seen) );
			if( AttitudeToOther == ATTITUDE_Enemy )
			{
				// tbi: make alert and approach carcass?
			}
			else
			{
				// tbi: make alert and search/hide?
			}
		}
	}
}

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

#debug   function UpdateBehavior( bool bEnableBC, string ContextStr )
#release function UpdateBehavior( bool bEnableBC )
{
	if( bEnableBC )
		BehaviorController.SetBCEnabled( true );
		
	if( ValidEnemy( ControllerEnemy ) )
	{
		#debug   BehaviorController.Update( BC_AttackUpdate, ContextStr );
		#release BehaviorController.Update( BC_AttackUpdate );
	}
	else
	{
		#debug   BehaviorController.Update( BC_UpdateInactive, ContextStr );
		#release BehaviorController.Update( BC_UpdateInactive );
	}
}

//-----------------------------------------------------------------------------
// States which disable the behavior controller (via SetBCEnabled() in order to
// prevent the state from changing). Should call this if there is any chance
// the state can end with the behavior controller still disabled (e.g. because
// UpdateBehavior() was never called). Checks the behavior controller and if 
// its not enabled, calls UpdateBehavior( true ).

function CheckBehaviorEnabled()
{
	// Assume that the code which changed the state knows what it is doing so
	// don't call UpdateBehavior here?
	if( ValidPawn( Pawn ) && BehaviorController != None && !BehaviorController.GetBCEnabled() )
	{
		//DMTNS( "CheckBehaviorEnabled re-enabling behavior controller (leaving state with behavior controller still disabled?)" );
		BehaviorController.SetBCEnabled( true );
	}
}

//-----------------------------------------------------------------------------
//@ EVENTS -- DAMAGE
//-----------------------------------------------------------------------------

function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
{
	if( Pawn != None && Pawn.Health > 0 )
	{
		Super.DamageAttitudeTo( Other, Damage, DamageType );
		#debug   BehaviorController.Update( BC_TookDamage, GetContext() );
		#release BehaviorController.Update( BC_TookDamage );
	}
}

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

function SpecialDeathHandling( Pawn KilledPawn )
{
	class'UtilSquad'.static.CheckSquadOrdersOnMemberLost( Self, KilledPawn );
}

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

function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local Pawn OldPawn;
	
	OldPawn = Pawn;
	
	Super.eventTakeDamage( Damage, Instigator, HitLocation, Momentum, DamageType );

	if( Pawn == None || Pawn.Health <= 0 || Pawn.bDeleteMe )
		SpecialDeathHandling( OldPawn );
}

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

function HandleKnockDown()
{
	GotoState( KnockDownState ); //mdf-tbd: go through BC
}

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

function EndPanic()
{
	Super.EndPanic();
	
	if( Pawn != None )
	{
		// pretty bad accuracy for next sec or so?
		// !!mdf-tbd: alternatively, stay in the panic state at a "recover" label for a bit?
		LastAcquireTime = Level.TimeSeconds + 0.5;
		Pawn.LastPainAnimTime = Level.TimeSeconds + 0.5;
	}
}

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

/*-----------------------------------------------------------------------------
Try moving at right angles to enemy on the side that the NPC is currently 
headed towards (i.e. if an NPC, moving at least somewhat to its left acquires 
an enemy, continue moving to the left (but now at right angles to the enemy) to
maximize chances of exposing the firing offset.
*/

function bool GetPossibleFiringLocation( out vector FiringLocation )
{
	local vector RightAngleDirection;
	
	RightAngleDirection = Normal( (ControllerEnemy.Location - Pawn.Location) cross vect(0,0,1) );

	//AddArrow( Pawn.Location, Pawn.Location + 128.0*Normal(Pawn.Velocity), ColorWhite() );

	if( Pawn.Velocity dot RightAngleDirection > 0 )
		FiringLocation  = Pawn.Location + Pawn.CollisionRadius *  RightAngleDirection;
	else
		FiringLocation  = Pawn.Location + Pawn.CollisionRadius * -RightAngleDirection;

	//AddArrow( Pawn.Location, FiringLocation, ColorOrange() );
	
	return true;
}
		
/*tbd
//-----------------------------------------------------------------------------
// Return true if enemy can be attacked (e.g. shot) from the current location.
// This could be tricky -- some weapons have different fire offsets depending
// on whether they are alt fired or fired and whether they are instant hit or
// projectile based (including particle based projectiles).

function bool CanAttackEnemy()
{
	if( !CanSee( ControllerEnemy ) )
		return false;
			
	if( 
}
*/

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

function ClearCoverSpot()
{
	if( CurrentCoverSpot != None )
	{
		CurrentCoverSpot.Destroy();
		CurrentCoverSpot = None;
	}
}

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

function AssignCoverSpot( CoverSpot NewCoverSpot )
{
	ClearCoverSpot();
	CurrentCoverSpot = NewCoverSpot;
	//CurrentCoverSpot.bHidden = false;
	//CurrentCoverSpot.SetDrawScale( 5.0 );
}

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

function NotifyMetaStateChange()
{
	//why? even if changed metastate, shouldn't we keep the old coverspot as long as its valid?
	// ClearCoverSpot();
}

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

function SetExecuteOrders( bool bVal )
{
	local bool bExecuteOrdersOld;
	
	bExecuteOrdersOld = bExecuteOrders;
	//DMTNS( "(" $ Pawn $ ") SetExecuteOrders: " $ bExecuteOrders $ " --> " $ bVal );
	
	bExecuteOrders = bVal;
	
	if( bExecuteOrdersOld != bExecuteOrders && BehaviorController != None )
	{
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
	}
		
	if( U2PBasic != None && U2PBasic.bCanStrafeDuringOrders )
	{
		if( bVal )
			U2PBasic.bCanStrafe = true;
		else
			U2PBasic.bCanStrafe = U2PBasic.default.bCanStrafe;
	}
}

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

function RestoreCanStrafe()
{
	if( !bExecuteOrders )
	{
		// not carrying out orders -- restore as usual
		Super.RestoreCanStrafe();
	}
	else 
	{
		// carrying out orders
		if( U2PBasic == None || !U2PBasic.bCanStrafeDuringOrders )
		{
			// not a "special" NPC -- restore as usual
			Super.RestoreCanStrafe();
		}
		else
		{
			// special NPC -- make sure bCanStrafe is true
			Pawn.bCanStrafe = true;
		}
	}
}
	
//-----------------------------------------------------------------------------
// Called when current enemy becomes invalid or NPC is abandoning it. Checks if 
// there is another enemy to attack and updates the BC accordingly.

function UpdateEnemy( optional bool bTryRadiusCheck )
{
	//2002.12.08 mdf-tbd: clear old enemy if this was a stationary pawn (XMP item)
	//so that NPC will only attack it if necessary (blocked by it).
	if( !ValidEnemy( OldControllerEnemy ) || StationaryPawn( OldControllerEnemy ) != None )
		OldControllerEnemy = None;

	// !!mdf-tbd: this is potentially bad if the old enemy is still valid but went
	// out of sight etc. and wasn't cleared. Either code which handles loss
	// of LOS, will clear ControllerEnemy or go hunting etc. or alternatively, we could 
	// make this function smarter and swap ControllerEnemy and OldControllerEnemy if both are 
	// valid but ControllerEnemy is no longer visible. My feeling at this point is that
	// this is a decision which is best handled in the attacking controller.
	#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
	#release SetControllerEnemy( OldControllerEnemy );

	if( ControllerEnemy == None && bTryRadiusCheck )
	{
		#debug   SetControllerEnemy( FindLocalEnemy( MaxRadiusEnemiesDistance ), GetContext() );
		#release SetControllerEnemy( FindLocalEnemy( MaxRadiusEnemiesDistance ) );
	}
	
	if( ControllerEnemy != None )
	{
		if( BehaviorController != None )
		{
			#debug   BehaviorController.Update( BC_EnemyChanged, GetContext() ); //!!mdf-tbd: do additional checks -- is the enemy visible, reachable etc.? (or do in UpdateEnemy?)
			#release BehaviorController.Update( BC_EnemyChanged ); //!!mdf-tbd: do additional checks -- is the enemy visible, reachable etc.? (or do in UpdateEnemy?)
		}
	}
	else
	{
		// 2002.12.14 (mdf) I don't think we should set the bExecuteOrders here 
		// if there is no enemy (set orders when enemy acquired based on squad
		// situation)?
		//if( HasSquadOrders() )
		//	SetExecuteOrders( true ); // no enemy so enable orders? //!!mdf-tbd: not sure
		if( BehaviorController != None )
		{
			#debug   BehaviorController.Update( BC_EnemyInvalid, GetContext() );
			#release BehaviorController.Update( BC_EnemyInvalid );
		}
	}
	
	//DMTNS( "UpdateEnemy  ControllerEnemy: " $ ControllerEnemy );
}

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

function HandleEnemyInvalid()
{
	// Pretty much the default desired behavior for any attack state?
	//DMTNS( "HandleEnemyInvalid" );
	if( IsFiring() )
		UnlockAnimationController();
	UpdateEnemy();
}

//-----------------------------------------------------------------------------
// mdf-tbd: shouldn't add significant overhead to do this since this will now
// only be called if Enemy is set but has become invalid.

event EnemyInvalid() 
{ 
	HandleEnemyInvalid(); 
}

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

function bool OKToHit( Actor HitActor, vector HitLocation, vector HitNormal )
{
	#debug DMAI( "OKToHit: " $ HitActor );

	return( HitActor == OldControllerEnemy || Super.OKToHit( HitActor, HitLocation, HitNormal ) );
}

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

function float GetAttackStyle( Actor TargetActor )
{
	local float ReturnedStyle;
	local float DistanceToEnemy;

	DistanceToEnemy = VSize( Pawn.Location - TargetActor.Location );

	if( DistanceToEnemy > 2*U2PBasic.RangeIdealAttack )
		ReturnedStyle = StyleCharge;
	else if( DistanceToEnemy > U2PBasic.RangeIdealAttack )
		ReturnedStyle =  StyleClose;
	else if( DistanceToEnemy < 0.5*U2PBasic.RangeIdealAttack )
		ReturnedStyle =  StyleRetreat;
	else if( DistanceToEnemy < U2PBasic.RangeIdealAttack )
		ReturnedStyle =  StyleBackoff;
	else
		ReturnedStyle =  StyleNeutral;
		
	//DMTNS( "Basic.GetAttackStyle returning " $ ReturnedStyle );
	return ReturnedStyle;
}

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

function float GetDefenseStyle( Actor TargetActor )
{
	//DMTNS( "Basic.GetDefenseStyle returning " $ StyleNeutral );
	return StyleNeutral; // mdf-tbd: add properties for this for tweaking various basic NPCs?
}

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

function byte PriorityObjective() { return 0; } //mdf-tbd: move to advanced/bot?
function bool FindSpecialAttraction() { return false; } //mdf-tbd: move to advanced/bot?

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

function bool SplashJump()
{
	return false;
}

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

function bool SplashDamageAttack()
{
	return ( IsFiring() && U2PBasic.bSplashDamageAttack );
}	

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

function bool HasInstantHitAttack()
{
	return U2PBasic.bInstantHitAttack;
}

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

function bool TrySplashDamageAttack() 
{
	return false; // mdf-tbd whether we want/need basic NPCs to try for splash damage
}

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

function bool IsMeleeAttacking()
{
	return( Pawn != None &&
			Pawn.MeleeOdds > 0.0 && 
			(bInitiatingAttack ||
			 (Level.TimeSeconds < MeleeEndTime) || 
			 (U2PBasic.MeleeNotifyTime > 0.0 && TimeRemaining( 'MeleeDamageTimer' ) > 0.0)) );
}

/*-----------------------------------------------------------------------------
Returns true if NPC is firing or is trying to fire.

This is used for example when taking damage to determine whether its ok to play 
a hit animation (without causing a ranged attack to be aborted).
*/

function bool IsFiring()
{
	//!!mdf tbd: is there a better way to do this, e.g. by looking at LastFireTime?
	//return Level.TimeSeconds - LastFireTime < 2.0;
	return ( bFire!=0 || bAltFire!=0 || IsMeleeAttacking() );
}

//-----------------------------------------------------------------------------
// Used to stop NPC from firing without aborting the current attack (won't
// clear animation-based attacks).

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

function StopFiringBase()
{
	bFire = 0;
	bAltFire = 0;
	
	//mdf-tbd: LastFireTime = -1.0;
	if( U2P.AnimationController != None )
		U2P.AnimationController.SpecialAnimationClear();

	RangedAttackAbort();
}

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

function StopFiringUpdate( float SuggestedFireAgainDelay )
{
	// reset the fire check timer	
	if( BehaviorController != None )
	{
		//DMTNS( "StopFiringUpdate: " $ SuggestedFireAgainDelay );
		BehaviorController.SetNextCheckFireShotDelay( SuggestedFireAgainDelay );
	}
}

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

#debug   function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr )
#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo )
{
	#debug DMAIA( "  StopFiring Basic (" $ SuggestedFireAgainDelay $ "): " $ EnumStr( enum'EStopFiringInfo', SFInfo ) $ " (" $ ContextStr $ ")" );
	//DMTNS( "  StopFiring Basic (" $ SuggestedFireAgainDelay $ "): " $ EnumStr( enum'EStopFiringInfo', SFInfo ) $ " (" $ ContextStr $ ")" );
	StopFiringBase();
	StopFiringUpdate( SuggestedFireAgainDelay );
}

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

function BCStartFiring()
{
	// try to fire immediately
	if( BehaviorController != None )
		BehaviorController.StartFiring();
}

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

function BCBlockFiring( float SuggestedFireAgainDelay, bool bStopFiring )
{
	if( bStopFiring )
	{
		#debug   StopFiring( SuggestedFireAgainDelay, SFI_Behavior, GetContext() );
		#release StopFiring( SuggestedFireAgainDelay, SFI_Behavior );
	}
	if( BehaviorController != None )
		BehaviorController.BlockFiring( SuggestedFireAgainDelay );
}

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

function float GetSpecifiedFireRate( bool bPrimary )
{
	return U2PBasic.RefireRate; // return animation-based rate
}

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

function float GetCurrentFireRate()
{
	return U2PBasic.RefireRate; // return animation-based rate
}

//-----------------------------------------------------------------------------
// NOTE: although this is only ever applicable in the TacticalMove state, we
// need a global version because the state can sometimes change "as the call is 
// made" and this would otherwise result in a "failed to find function" error.

function bool StrafeFromDamage( float Damage, class<DamageType> DamageType, bool bFindDest );

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

function bool ShouldGiveUpHunting()
{
	return ( GetSkill() < 0.5 );
}

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

function bool GetShouldUseDeviousTactics( float BaseSkill, float BaseOdds )
{
	return ( GetSkill() >= BaseSkill && FRand() < BaseOdds );
}

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

function bool TestCanJump()
{
	return ( MoveTarget != None );
}

//-----------------------------------------------------------------------------
// NPC's enemy was killed but NPC currently has another enemy to deal with.

function HandleEnemyKilledUnSafe( Controller Killer, Pawn KilledEnemy )
{
	if( Killer == Self )
		U2P.AssetsHelperClass.static.HandleKilledEnemy( U2P );
}

//-----------------------------------------------------------------------------
// Called when an NPC's enemy is killed and the NPC currently has no enemy. Can
// be used to do simple things like taunting the enemy (e.g. bots might do this)
// or for more complex behavior (e.g. if bunch of araknids kill an enemy, the
// araknid who struck the fatal blow might get "first dibs" on the carcass, and
// other araknids will swarm the carcass once the killer is in place)..

function HandleEnemyKilledSafe( Controller Killer, Pawn KilledEnemy )
{
	if( Killer == Self )
		U2P.AssetsHelperClass.static.HandleKilledEnemySafe( U2P );
}

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

function HandleFriendDead( Pawn KilledFriend )
{
	if( !KilledFriend.ShouldGib( class'DamageTypePhysical' ) &&
		class'UtilGame'.static.ActorCanSeeActor( U2P, KilledFriend, -1.0 ) )
	{
		AddTimer( 'PlayFriendDeadSound', class'Util'.static.PerturbFloatPercent( U2P.FriendDeadSoundDelay, 30.0 ) );
	}
}

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

function PlayFriendDeadSound()
{
	U2P.AssetsHelperClass.static.HandleFriendDead( U2P );
}

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

function NotifyKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType )
{
	//NOTE: don't call super -- this would clear enemy which is used below

	if( KilledPawn == Pawn && Killer != None )
	{
		#debug DMAI( "NotifyKilled -- I died Killer.Pawn: " $ Killer.Pawn $ "(" $ ValidEnemy( Killer.Pawn ) $ ")" );

		// I'm dead so I won't actually acquire the Instigator but nearby NPCs on my team might acquire him
		if( ValidEnemy( Killer.Pawn ) )
			MaybeAlertOthers( Killer.Pawn );
	}

	if( Pawn == None || Pawn.Health <= 0 )
		return;

	if( OldControllerEnemy == KilledPawn )
		OldControllerEnemy = None;

	if( ControllerEnemy == KilledPawn )
	{
		#debug   StopFiring( 0.5, SFI_TargetInvalid, GetContext() );
		#release StopFiring( 0.5, SFI_TargetInvalid );

		UpdateEnemy( true );

		if( ControllerEnemy == None )
			HandleEnemyKilledSafe( Killer, KilledPawn );
		else
			HandleEnemyKilledUnSafe( Killer, KilledPawn );
	}
	else if( Pawn.SameTeam( KilledPawn ) )
		HandleFriendDead( KilledPawn );
}	

//-----------------------------------------------------------------------------
// Check if I can see my current Destination point, and so can enemy.

function bool CanStakeOut()
{
	local vector LastEnemySeenLocation;
	
	LastEnemySeenLocation = GetLastEnemyDetectedLocation();
	
	return ( VSize( ControllerEnemy.Location - LastEnemySeenLocation ) <= 800 &&
			 Pawn.FastTrace( LastEnemySeenLocation, Pawn.Location + Pawn.EyeHeight * vect(0,0,1) ) && 
			 Pawn.FastTrace( LastEnemySeenLocation, ControllerEnemy.Location + ControllerEnemy.BaseEyeHeight * vect(0,0,1) ) );
}

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

function SetPeripheralVision()
{
	Super.SetPeripheralVision();

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

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

function SpawnShotTimer()
{
	#debug DMAIA( "SpawnShotTimer" );
	//class'U2GameInfo'.static.BSM( Self, "WTF?" );
	if( Pawn.Health > 0 && IsFiring() )
		U2PBasic.SpawnShot();
}

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

function bool CanUseStillAnimations() { return false; }

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

function FireShot( byte bUseAltMode )
{
	local float AnimationDuration;
	
	#debug DMAIA( "FireShot (basic)" );

	//mib-tbd hack to restore weapon state
	if( U2PBasic != None )
	{
		if( !bUseAltMode )
			bFire = 1;
		else
			bAltFire = 1;
		
		if( U2PBasic.AnimationController != None )
			AnimationDuration = U2PBasic.AnimationController.SpecialAnimationRangedAttack( CanUseStillAnimations() );
		//DMTNS( "FireShot calling SetNextCheckFireShotDelay: " $ AnimationDuration );
		if( BehaviorController != None )
		{
			BehaviorController.SetNextCheckFireShotDelay( AnimationDuration );
			BehaviorController.SetMinTimeOutDelay( AnimationDuration );
		}
		
		if( U2PBasic.RangedNotifyTime > 0.0 )
		{
			// these should be replaced with actual notifies
			DMAssert( false, GetContext() );
			AddTimer( 'SpawnShotTimer', U2PBasic.RangedNotifyTime, false );
		}
	}
}

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

function FireAt( Actor A )
{
	FireShot( 0 );
}

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

function MeleeDamageTimer()
{
	if( Pawn.Health > 0 && IsMeleeAttacking() )
		U2PBasic.NotifyMelee01();
}

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

function MeleeAttack( byte bUseAltMode )
{
	local float MeleeAnimationDuration;
	
	//	#debug DMAIA( "MeleeAttack" );

	bInitiatingAttack = true;
	MeleeAnimationDuration = U2P.AnimationController.SpecialAnimationMeleeAttack();
	
	bInitiatingAttack = false;
	if( U2PBasic.MeleeNotifyTime > 0.0 )
	{
		// these should be replaced with actual notifies
		DMAssert( false, "dependencies on MeleeNotifyTime need to be removed " $ GetContext() );
		AddTimer( 'MeleeDamageTimer', U2PBasic.MeleeNotifyTime, false );
	}
	
	if( MeleeAnimationDuration > 0.0 )
	{
		//!!CDH (mdf): in some cases the returned animation duration is off and 
		// playing the animation again b4 it finishes causes it to "lock up" so
		// adding 0.05 seconds in here. This fixes the seagoat for example.
		MeleeAnimationDuration += 0.05;
		BehaviorController.SetMinTimeOutDelay( MeleeAnimationDuration );
		U2PBasic.NotifyMeleeBegin();
		MeleeEndTime = Level.TimeSeconds + MeleeAnimationDuration;
	}
}

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

function float SetSpecialAnim( name AnimAction, bool bOverrideBehavior )
{
	local float AnimationDuration;
	
	AnimationDuration = U2P.AnimationController.SpecialAnimation( AnimAction );
	if( AnimationDuration == 0.0 )
		DMTNS( "WARNING - no acquisition animation for " $ Pawn $ " AnimSequence: " $ Pawn.AnimSequence );
	
	if( bOverrideBehavior )
		BehaviorController.SetMinTimeOutDelay( AnimationDuration );
	
	//DMTNS( "playing special animation (" $ AnimAction $ "), sleeping for " $ AnimationDuration $ " seconds " );
	return AnimationDuration;
}

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

function MeleeAttackAbort()
{
	if( U2P != None && U2P.AnimationController != None )
		U2P.AnimationController.SpecialAnimationMeleeAttackAbort();
}

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

function RangedAttackAbort()
{
	if( U2P != None && U2P.AnimationController != None )
		U2P.AnimationController.SpecialAnimationRangedAttackAbort();
}

//-----------------------------------------------------------------------------
// Impaling attack behavior

function bool IsImpaling() { return false; }

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

function bool CanImpale( Pawn Victim )
{
	return( CheckMeleeAttackRange( Victim ) &&
			vector(Pawn.Rotation) dot vector(Victim.Rotation) < MinImpaleCos );
}

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

function ImpaleAttack()
{
	GotoState( ImpalingState );
}

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

function ImpaleAttackAnimationAbort()
{
	//#debug DMAIA( "ImpaleAttackAnimationAbort" );
	if( U2PBase != None )
		U2P.AnimationController.SpecialAnimationImpaleAttackAbort()	;
}

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

// Animation notifications
function ImpalePawn();
function UnImpalePawn();

/* mdf-tbd: nothing uses this currently
//-----------------------------------------------------------------------------
// combo move

function SpecialFire()
{
	bFiringPaused = true;
	StopMovement( true, false );
	GS( AttackStationaryState ); //GS-tbd
}
*/

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

function bool IsPreparedToFire( bool bOwner, optional bool bCheckWeaponRating, optional int MinWeaponRating )
{
	return ( U2PBasic != None && U2PBasic.bHasRangedAttack );
}

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

function bool IsPreparedToMelee( bool bOwner, optional bool bCheckWeaponRating, optional int MinWeaponRating )
{
	return ( Pawn != None && Pawn.MeleeOdds > 0.0 );
}

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

function bool CanFire( bool bTest ) { return ( CheckTargetInAttackRange( bTest ) && IsFacingTarget( GetTarget(), CosMinFacingTargetAngle ) ); }

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

function bool HasSquadOrders()
{
	return ( Orders == OrdersSquad || (Orders == OrdersGoto && OrdersObject != None) );
}

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

function EnemyAcquired()
{
	#debug   BehaviorController.Update( BC_EnemyAcquired, GetContext() );
	#release BehaviorController.Update( BC_EnemyAcquired );
}
	
//-----------------------------------------------------------------------------
// Note, my enemy might not actually be set (e.g. if I was killed with 1 shot).

function MaybeAlertOthers( Pawn PotentialEnemy )
{
	local Controller C;

	//DMTNS( "MaybeAlertOthers" );

	if( U2PBase.AlertOthersRadius > 0.0 )
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C != Self && 
				U2NPCController(C) != None && 
				ValidPawn( C.Pawn ) && 
				U2PBase.SameTeam( C.Pawn ) )
			{
				U2NPCController(C).MaybeInheritEnemy( U2PBase, PotentialEnemy );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Return true if NPC should jump during tactical moves.

function bool UseTacticalJumps()
{
	return( FRand() < U2PBasic.TacticalJumpOdds );
}

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

/*!!mdf 
function NotTakingHit()
{
	if( Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z && 
		(Momentum.Z/Pawn.PhysicsVolume.Gravity.Z < -0.5) )
		bFireFalling = true;
	else
		Super.NotTakingHit();
}
*/

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

function NotifyTakeHit( Pawn Instigator, vector HitLocation, int Damage, class<DamageType> DamageType, vector Momentum )
{
	bFireFalling = false;
	Super.NotifyTakeHit( Instigator, HitLocation, Damage, DamageType, Momentum );
}

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

function ExecuteDodge( bool bLeft, vector DodgeDestination )
{
	Super.ExecuteDodge( bLeft, DodgeDestination );
	GotoState( DodgingState );
}

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

function UtilGame.ELeapResult GetLeapHighParameters( float TargetDistance, vector Extents, out vector LeapDestination, out float Theta, out float LeapSpeed )
{
	local vector PredictedLocation;
	local int FitActorAtResult;
	
	//DMTNS( "try to LEAP high" );
	LeapSpeed = U2PBasic.LeapHighSpeed;
	
	PredictedLocation = ControllerEnemy.Location;
	if( FDecision( U2PBasic.LeapHighPredictOdds ) )
	{
		// predict necessary target location
		class'UtilGame'.static.GetBestPredictedProjectileLocation( 
			Pawn, 
			ControllerEnemy, 
			class'Pawn', 
			LeapSpeed, 
			U2PBasic.LeapDelayPreJump + U2PBasic.LeapNotifyTime, 
			Pawn.Location, 
			TargetDistance, 
			true, 
			PredictedLocation );
	}
	
	//AddCylinder( PredictedLocation, Pawn.CollisionRadius, Pawn.CollisionHeight, ColorCyan() );
			
	LeapDestination = PredictedLocation;
			
	// align NPC "feet" with bottom of target location
	LeapDestination.Z += (Pawn.CollisionHeight - ControllerEnemy.CollisionHeight);
	
	FitActorAtResult = Pawn.FitActorAt( LeapDestination, Pawn.CollisionRadius + class'UtilGame'.default.VerifyTrajectoryHorizontalExtentPadding, Pawn.CollisionHeight + class'UtilGame'.default.VerifyTrajectoryVerticalExtentPadding );
	//DMTNS( "FitActorAtResult  #2: " $ FitActorAtResult );			
	if( FitActorAtResult == 0 )
	{
		// try aiming directly at enemy
		LeapDestination = ControllerEnemy.Location - (Pawn.CollisionRadius - ControllerEnemy.CollisionRadius) * Normal( Pawn.Location - ControllerEnemy.Location );
		// align NPC "feet" with bottom of target location
		LeapDestination.Z += (Pawn.CollisionHeight - ControllerEnemy.CollisionHeight);
	}
	
	//AddCylinder( LeapDestination, Pawn.CollisionRadius, Pawn.CollisionHeight, ColorOrange() );
	//AddArrow( Pawn.Location, LeapDestination, ColorOrange() );

	return class'UtilGame'.static.VerifyLeapParameters( 
				Pawn,
				class'Pawn',
				LeapSpeed,
				LeapDestination,
				Pawn.Location,
				ControllerEnemy,
				TRAJ_High, 
				Theta,
				Extents );
}		

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

function UtilGame.ELeapResult GetLeapLowParameters( float TargetDistance, vector Extents, out vector LeapDestination, out float Theta, out float LeapSpeed )
{
	local vector PredictedLocation;
	local int FitActorAtResult;

	//DMTNS( "try to LEAP low" );
	LeapSpeed = U2PBasic.LeapLowSpeed;

	PredictedLocation = ControllerEnemy.Location;
	if( FDecision( U2PBasic.LeapLowPredictOdds ) )
	{
		// predict necessary target location
		class'UtilGame'.static.GetBestPredictedProjectileLocation( 
			Pawn, 
			ControllerEnemy, 
			class'Pawn', 
			LeapSpeed, 
			U2PBasic.LeapDelayPreJump + U2PBasic.LeapNotifyTime, 
			Pawn.Location, 
			TargetDistance, 
			false, 
			PredictedLocation );
	}
	
	// aim to leap through enemy somewhat
	LeapDestination = PredictedLocation + vect(0,0,1) * ControllerEnemy.CollisionHeight;
	
	// align NPC "feet" with bottom of target location
	LeapDestination.Z += (Pawn.CollisionHeight - ControllerEnemy.CollisionHeight);

	//AddCylinder( LeapDestination, Pawn.CollisionRadius, Pawn.CollisionHeight, ColorGreen() );
	FitActorAtResult = Pawn.FitActorAt( LeapDestination, Pawn.CollisionRadius + class'UtilGame'.default.VerifyTrajectoryHorizontalExtentPadding, Pawn.CollisionHeight + class'UtilGame'.default.VerifyTrajectoryVerticalExtentPadding );
	//AddCylinder( LeapDestination, Pawn.CollisionRadius, Pawn.CollisionHeight, ColorBlue() );
	
	//DMTNS( "FitActorAtResult #1: " $ FitActorAtResult );			
	if( FitActorAtResult == 0 )
	{
		// doesn't fit at overshoot location -- back up to predicted location
		LeapDestination = PredictedLocation - (Pawn.CollisionRadius - ControllerEnemy.CollisionRadius) * Normal( Pawn.Location - PredictedLocation );
		
		// align NPC "feet" with bottom of target location
		LeapDestination.Z += (Pawn.CollisionHeight - ControllerEnemy.CollisionHeight);
		FitActorAtResult = Pawn.FitActorAt( LeapDestination, Pawn.CollisionRadius + class'UtilGame'.default.VerifyTrajectoryHorizontalExtentPadding, Pawn.CollisionHeight + class'UtilGame'.default.VerifyTrajectoryVerticalExtentPadding );
		
		//DMTNS( "FitActorAtResult  #2: " $ FitActorAtResult );			
		if( FitActorAtResult == 0 )
		{
			// doesn't fit at overshoot location -- aim directly at enemy
			LeapDestination = ControllerEnemy.Location - (Pawn.CollisionRadius - ControllerEnemy.CollisionRadius) * Normal( Pawn.Location - ControllerEnemy.Location );
			// align NPC "feet" with bottom of target location
			LeapDestination.Z += (Pawn.CollisionHeight - ControllerEnemy.CollisionHeight);
		}
	}
	
	//AddCylinder( PredictedLocation, 4, 4, ColorMagenta() );	
	//AddCylinder( LeapDestination, 16, 16, ColorGreen() );
	//AddArrow( Pawn.Location, LeapDestination, ColorGreen() );
	
	return class'UtilGame'.static.VerifyLeapParameters( 
				Pawn,
				class'Pawn',
				LeapSpeed,
				LeapDestination,
				Pawn.Location,
				ControllerEnemy,
				TRAJ_Low, 
				Theta,
				Extents );
}

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

function bool GetLeapMaxParameters( out vector LeapDestination, vector Extents, out float Theta, out float LeapSpeed )
{
	//DMTNS( "LEAP at 45 degrees?" );
			
	LeapDestination = ControllerEnemy.Location;
	if( Normal( LeapDestination - Pawn.Location ) dot vector(Pawn.Rotation) < 0.707 )
		return false;
		
	LeapSpeed = U2PBasic.LeapLowSpeed;
	Theta = -45 * DegreesToRadians;
			
	//AddCylinder( PredictedLocation, 16, 16, ColorRed() );
	//AddArrow( Pawn.Location, PredictedLocation, ColorRed() );

	return class'UtilGame'.static.VerifyTrajectory( Pawn, class'Pawn', LeapSpeed, Pawn.Location, LeapDestination, ControllerEnemy, Theta, /*InterceptTime*/, Extents );
}
	
//-----------------------------------------------------------------------------
// !!mdf-tbd: maybe try different leap speeds depending on the circumstances?

function bool GetLeapParameters( out rotator LeapRotation, out float LeapSpeed )
{
	local vector LeapDestination;
	local float Theta;
	local float TargetDistance;
	local vector Extents;
	local UtilGame.ELeapResult LeapResult;
	local bool bTriedHigh, bSuccess;
	
	if( Pawn == None || ControllerEnemy == None )
		return false;
		
	//AddActor( Pawn, ColorRed() );
	//AddActor( ControllerEnemy, ColorGreen() );
	
	Extents.X = Pawn.CollisionRadius;
	Extents.Y = Pawn.CollisionRadius;
	Extents.Z = Pawn.CollisionHeight;

	TargetDistance = VSize( ControllerEnemy.Location - Pawn.Location );
	//DMTNS( "TargetDistance: " $ TargetDistance );
	if( TargetDistance > U2PBasic.OnlyLeapLowRange && FDecision( U2PBasic.LeapHighOdds ) )
	{
		// try a high leap
		bTriedHigh = true;
		LeapResult = GetLeapHighParameters( TargetDistance, Extents, LeapDestination, Theta, LeapSpeed );
		bSuccess = (LeapResult == LR_Success );
		
		//if( bSuccess )
		//	DMTNS( "  LEAP HIGH!" );
	}

	if( !bSuccess )
	{
		// try a low leap, then maybe a high leap, then maybe a max leap
		LeapResult = GetLeapLowParameters( TargetDistance, Extents, LeapDestination, Theta, LeapSpeed );
		bSuccess = ( LeapResult == LR_Success );

		//if( bSuccess )
		//	DMTNS( "LEAP LOW!" );
		
		if( !bSuccess && LeapResult != LR_OutOfRange && !bTriedHigh && TargetDistance > U2PBasic.OnlyLeapLowRange && U2PBasic.LeapHighOdds > 0.0 )
		{
			LeapResult = GetLeapHighParameters( TargetDistance, Extents, LeapDestination, Theta, LeapSpeed );
			bSuccess = ( LeapResult == LR_Success );
			//if( bSuccess )
			//	DMTNS( "LEAP HIGH (low failed)!" );
		}
				
		if( LeapResult == LR_OutOfRange && FDecision( U2PBasic.LeapMaxOdds ) )
		{
			bSuccess = GetLeapMaxParameters( LeapDestination, Extents, Theta, LeapSpeed );
			//if( bSuccess )
			//	DMTNS( "  LEAP MAX!" );
		}
	}

	//if( !bSuccess )
	//	DMTNS( "  LEAP FAILED!" );
	
	if( bSuccess )
	{
		// set leap parameters
		LeapRotation = rotator(LeapDestination - Pawn.Location); // rotation to aim directly at target
	
		// modify the leap pitch
		if( Theta < 0 )
			LeapRotation.Pitch = RadiansToDegrees * -Theta * DegreesToRotationUnits;
		else
			LeapRotation.Pitch = 65535 - RadiansToDegrees * Theta * DegreesToRotationUnits;
	}
	
	return bSuccess;
}

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

function bool CanAttemptLeapAttack()
{
	return( Level.TimeSeconds >= NextLeapTime &&
			Pawn.Physics == PHYS_Walking && 
			(ControllerEnemy.Physics == PHYS_Walking || ControllerEnemy.Physics == PHYS_Falling) && 
			(!U2PBasic.bLeapRequiresLOS || GetTimeSinceEnemyLastDetected() < 0.2) &&
			ValidEnemy( ControllerEnemy ) );
}

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

event EnemyInLeapRange( float Distance )
{
	if( FDecision( Pawn.LeapOdds ) && CanAttemptLeapAttack() )
		GotoState( AttackLeapState );
}

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

event EnemyInMeleeRange()
{
	if( FDecision( Pawn.MeleeOdds ) || !IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
	{
		#debug   BehaviorController.Update( BC_MeleeRange, GetContext() );
		#release BehaviorController.Update( BC_MeleeRange );
	}
}

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

function bool ShouldDeferTo( Controller Other )
{
	return ( Orders == OrdersFollow && Other == OrdersObject );
}

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

function bool DeferTo( Controller Other )
{
	if( ShouldDeferTo( Other ) )
	{
		if( ControllerEnemy != None && LineOfSightTo( ControllerEnemy ) )
		{
			GotoState( AttackTacticalMoveState, DontCloseLabel ); //GS-tbd
		}
		else
		{
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
			OldControllerEnemy = None;

			//!!mdf--this might need to be in base?
			if( Pawn.Health > 0 && Pawn.Acceleration == vect(0,0,0) )
			{
				WanderDirectionExternal = Other.Pawn.CollisionRadius*2.0*Normal( Pawn.Location - Other.Pawn.Location );
				GotoState( WanderingState, BeginLabel ); //GS-tbd
			}
		}
		return true;
	}

	return Super.DeferTo( Other );
}

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

function EReaction GetReactionToEnemy( Pawn EnemyPawn )
{
	local EReaction ReturnedReaction;
	local float CurrentRelativeStrength;
	
	// mdf-tbd: in U2 turrets might be destroyable so NPCs might need to attack
	// these (while moving around, taking cover, doding projectiles?)
	if( StationaryPawn(EnemyPawn) != None )
	{
		// fear turrets but not force fields (if smart about turrets)	
		if( bSmartAboutTurrets && StationaryPawn(EnemyPawn).bHasAttack )
			ReturnedReaction = REACTION_Fear;
		else
			ReturnedReaction = REACTION_Attack;
	}
	else
	{
		CurrentRelativeStrength = RelativeStrength( EnemyPawn );
		
		if( CurrentRelativeStrength > 0.0 )
		{
			// stronger than enemy -- more likely to attack with increasing skill and Aggressiveness
			if( (CurrentRelativeStrength + Aggressiveness) > (1.0 - GetSkill()) )
				ReturnedReaction = REACTION_Attack;
			else
				ReturnedReaction = REACTION_Fear;
		}
		else
		{
			// weaker than enemy -- more likely to run away with increasing skill and decreasing Aggressiveness
			if( (CurrentRelativeStrength + Aggressiveness) > (1.0 - GetSkill()) )
				ReturnedReaction = REACTION_Fear;
			else
				ReturnedReaction = REACTION_Attack;
		}
	}
	
	return ReturnedReaction;
}

//-----------------------------------------------------------------------------
// mdf-tbi: implement bAlwaysSetAnnoyingNewEnemy -- NPCs which use this (with
// bAlwaysSetEnemy=false) will generally focus on one enemy at a time but if
// a 2nd enemy bumps or damages them then they'll attack it. Not implemented
// yet (just need to add hooks for communicating way in which enemy was 
// detected (see/hear vs bump/damage) via AnnoyedAt or as a parameter to 
// SeeEnemy (leaning towards AnnoyedAt currently -- maintain fixed-sized list
// of recently acquired NPCs & whether annoyed at them).

function bool MaybeAcquireEnemy( Pawn NewEnemy )
{
	#debug DMAIA( "MaybeAcquireEnemy - Enemy: " $ ControllerEnemy $ " OldControllerEnemy: " $ OldControllerEnemy );
	//DMTNS( "MaybeAcquireEnemy - ControllerEnemy: " $ ControllerEnemy $ " OldControllerEnemy: " $ OldControllerEnemy $ " NewEnemy: " $ NewEnemy );

	//2002.12.18 (mdf) this only affects NPCs with the primary script in obolus
	if( bXMPHandlingEnabled )
	{
		// don't allow the fact that we are autonomous to deal with XMP items
		// let us acquire a non-stationary pawn enemy or another XMP item if
		// we already have one as an enemy
		if( StationaryPawn(NewEnemy) == None || StationaryPawn(ControllerEnemy) != None )
			return false;
	}
	
	if( ControllerEnemy == None || U2PBasic.bAlwaysAttackNewEnemy /*|| (U2PBasic.bAlwaysAttackAnnoyingNewEnemy && AnnoyedAt(NewEnemy)) */ )
	{
		#debug DMAIA( "  acquiring new enemy" );
		//DMTNS( "  acquiring new enemy" );
	   
		if( ControllerEnemy == None	&& HasSquadOrders() )
			class'UtilSquad'.static.CheckSquadOrdersOnEnemyAcquired( Pawn );
		
		#debug   SetControllerEnemy( NewEnemy, GetContext() );
		#release SetControllerEnemy( NewEnemy );
	}
	else if( CompareThreat( NewEnemy, ControllerEnemy ) > 0.0 )
	{
		// new enemy bigger threat than current enemy
		#debug DMAIA( "  switching from current enemy to new enemy, maybe replace old enemy with current enemy" );
		//DMTNS( "  switching from current enemy to new enemy, maybe replace old enemy with current enemy" );

		// replace old enemy with current enemy if bigger threat
		if( OldControllerEnemy == None || CompareThreat( ControllerEnemy, OldControllerEnemy ) > 0.0 )
			OldControllerEnemy = ControllerEnemy;

		#debug   SetControllerEnemy( NewEnemy, GetContext() );
		#release SetControllerEnemy( NewEnemy );
	}
	else
	{
		// current enemy bigger threat than new enemy
		#debug DMAIA( "  keeping current enemy, maybe replace old enemy with new enemy" );
		//DMTNS( "  keeping current enemy, maybe replace old enemy with new enemy" );

		// replace old enemy with new enemy if bigger threat
		if( OldControllerEnemy == None || CompareThreat( NewEnemy, OldControllerEnemy ) > 0.0 )
			OldControllerEnemy = NewEnemy;
	}

	return( ControllerEnemy == NewEnemy );
}

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

function CoverSpot FindCoverActor( float MaxDistance, float	CosMinAngle, float CosMaxAngle, bool bIncludePathable )
{
	//!!mdf-tbd: this should fix the crash but I'd like to find out how this is happening
	DMTNS( "Warning: FindCoverActor called in " $ GetStateName() $ " state" );
	return None;
}

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

function HandleBump( Pawn Other, bool bEnemy );

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

function name		GetOrders()						{ return Orders; }
function Actor		GetOrdersObject()				{ return OrdersObject; }
function float		GetOrdersThreshold()			{ return OrdersThreshold; }
function Object		GetOrderGiver()					{ return OrderGiver; }

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

function Actor GetHoldActor()
{
	local Actor ReturnedActor;
	
	if( bStationary )
	{
		if( StationarySpot != None )
			ReturnedActor = StationarySpot;
		else
			ReturnedActor = GetHoldSpot( Pawn );
	}
	else
	{
		ReturnedActor = OrdersObject;
	}
	
	return ReturnedActor;
}		

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

function ClearHoldSpots()
{
	Super.ClearHoldSpots();
	ClearHoldSpot( OrdersObject );
	ClearHoldSpot( StationarySpot );
}

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

function bool UpdateStance( byte TargetStance, optional float EnemyDistance )
{
	local bool bResult;
	local byte OldStance;
	
	OldStance = Pawn.GetStance();
	bResult = Super.UpdateStance( TargetStance, EnemyDistance );
	if( bResult && (TargetStance == ST_Prone || OldStance == ST_Prone) )
	{
		//DMTNS( "going to/from prone -- stop firing for " $ ProneStanceChangeDuration );
		BCBlockFiring( ProneStanceChangeDuration, true ); // don't fire during prone stance change
	}
			
	return bResult;
}

//-----------------------------------------------------------------------------
// Prevents NPC from moving but NPC can still shoot and rotate towards target.
// Unlike hold orders -- these keep an NPC in a general area but the NPC can
// still wander/roam (if applicable) and will revert to moving around when an
// enemy appears. If NPC is no longer dealing with an enemy and goes back to
// the hold state, NPC will try to get back to his original location and
// and rotation and will set his stance to the stance active when the NPC was
// made stationary.
//
// mdf-tbd: support NPC being able to optionally chase no longer visible enemy 
// somewhat?

function SetStationary( bool bVal, optional bool bStayStationaryVal )
{
	bStationary = bVal;
	bStayStationary = bStayStationaryVal;
	
	ClearHoldSpot( StationarySpot );
		
	if( bStationary )
	{
		StationarySpot = GetHoldSpot( Pawn );
		if( StationarySpot != None )
		{
			// not ordered but uses OrdersObject anyway
			
			StationaryStance = LPawn.GetStance();
			//DMTN( "Saved stance is :" $ StationaryStance );
		}

		StopMovement( true, true );
	}

	#debug   WhatToDoNext( GetContext() );
	#release WhatToDoNext();
}

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

function bool IsStationary()	{ return  bStationary; }
function bool IsMobile()		{ return !bStationary; }

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

function bool ProcessOrdersFollow( out Actor NewOrdersObject, Object NewOrderGiver )
{
	local bool bResult;
	
	if( NewOrdersObject == None && Controller(NewOrderGiver) != None )
		NewOrdersObject = Controller(NewOrderGiver).Pawn;
		
	if( NewOrdersObject != None )
	{
		Aggressiveness += 1;
		bResult = true;
	}
		
	return bResult;
}

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

function bool ProcessOrdersGoto( out Actor NewOrdersObject )
{
	local bool bResult;

	if( NewOrdersObject != None )
	{
		Aggressiveness += 1;
		bResult = true;
	}
	
	return bResult;
}

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

function bool ProcessOrdersHold( out Actor NewOrdersObject, Object NewOrderGiver )
{
	local bool bResult;

	if( NewOrdersObject == None && Controller(NewOrderGiver) != None )
		NewOrdersObject = Controller(NewOrderGiver).Pawn;

	if( Pawn(NewOrdersObject) != None )
		NewOrdersObject = GetHoldSpot( Pawn(NewOrdersObject) ); // need to use a holdspot
		
	if( NewOrdersObject != None )
	{
		Aggressiveness += 1;
		bResult = true;
	}

	return bResult;
}

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

function bool ProcessOrdersNone()
{
	return true;
}

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

function bool ProcessOrdersSquad()
{
	return true;
}

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

function bool DetermineOrdersTransition( out name DestinationState, out name DestinationLabel )
{
	DestinationState = NoState;
	DestinationLabel = NoLabel;

	if( Orders == OrdersHold )
		DestinationState = HoldState;

	return ( DestinationState != NoState );
}

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

function bool ProcessOrders( name NewOrders, out Actor NewOrdersObject, out float NewOrdersThreshold, out Object NewOrderGiver )
{
	local bool bResult;

	switch( NewOrders )
	{
		case OrdersNone:
			bResult = ProcessOrdersNone();
			break;

    	case OrdersFollow:
			bResult = ProcessOrdersFollow( NewOrdersObject, NewOrderGiver );
			break;

    	case OrdersGoto:
			bResult = ProcessOrdersGoto( NewOrdersObject );
			break;

		case OrdersHold:
			bResult = ProcessOrdersHold( NewOrdersObject, NewOrderGiver );
			break;

		case OrdersSquad:
			NewOrderGiver = Self;
			bResult = ProcessOrdersSquad();
			break;

		default:
			bResult = false;
			DMAssert( false, GetContext() ); // mdf-tbr
			break;
	}
	
	return bResult;
}

//-----------------------------------------------------------------------------
// Sets the current OrdersObject and, if debug mode is enabled, hides the 
// previous OrdersObject and shows the new one, e.g. so an NPC's destination can
// be seen in-game.

function SetOrdersObject( Actor NewOrdersObject )
{
	if( bShowOrdersObjects && OrdersObject != None && OrdersObject.default.bHidden )
		HideActor( OrdersObject );

	OrdersObject = NewOrdersObject;

	if( bShowOrdersObjects && OrdersObject != None && OrdersObject.default.bHidden )
		ShowActor( OrdersObject, 5.0, STY_Translucent );
}

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

function ClearOrders()
{
	Aggressiveness = U2PBasic.BaseAggressiveness;

	// destroy old holdspot
	if( HoldSpot(OrdersObject) != None )
	{
		OrdersObject.Destroy();
		SetOrdersObject( None );
	}
}

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

function UpdateOrders( name NewOrders, Actor NewOrdersObject, float NewOrdersThreshold, Object NewOrderGiver )
{
	ClearOrders();
	
	Orders = NewOrders;
	SetOrdersObject( NewOrdersObject );
	OrdersThreshold = FMax( MinGoalDistance, NewOrdersThreshold );
	OrderGiver = NewOrderGiver;
}
	
/*-----------------------------------------------------------------------------
Handles incoming orders.

In most cases it should be unnecessary to override the handling of special 
orders but, if this happens, the "right" way to do this is to override the 
HandleXXXOrders function used to actually deal with specific orders (set the
destination state etc.).

To illustrate: the 'here' orders are used to immediately order an NPC to the
OrderGiver's location (used to test pathing and reachability). These can be
handled here (in one place). If SetOrders was used for this, it might be
necessary to modify code in several places.

Returns true if the given orders were successfully processed (valid).
*/

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

	#debug DMAI( "SetOrders (begin) -- NewOrders: " $ NewOrders $ " NewOrderGiver: " $ NewOrderGiver $ " NewOrdersObject: " $ NewOrdersObject );
	//DMTNS( "SetOrders (begin) -- NewOrders: " $ NewOrders $ " NewOrderGiver: " $ NewOrderGiver $ " NewOrdersObject: " $ NewOrdersObject );

	//-------------------------------------------------------------------------
	// process new orders -- keep old orders until new ones are validated
	//-------------------------------------------------------------------------
	
	bResult = ProcessOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver );
	
	//DMTNS( "Basic.SetOrders -- called ProcessOrders for " $ NewOrders $ " bResult: " $ bResult );
	if( bResult )
	{
		// cleanup, reset, re-initialization
		UpdateOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver );

		// respond to orders asap (old code used to wait for WTDN, Roaming etc.. to notice orders change)
		if( ReadyForOrders() )
		{
			if( DetermineOrdersTransition( DestinationState, DestinationLabel ) )
				GotoState( DestinationState, DestinationLabel ); //GS-tbd
		}
	}

	if( HasSquadOrders() )
	{
		class'UtilSquad'.static.CheckSquadOrdersOnMemberAdded( Self );
	}
	else if( Orders == OrdersNone || OrdersObject == None )
	{
		class'UtilSquad'.static.CheckSquadOrdersOnMemberLost( Self, Pawn );
	}
	
	#debug DMAI( "SetOrders (end) -- Orders: " $ Orders $ " OrderGiver: " $ OrderGiver $ " OrdersObject: " $ OrdersObject );
	//DMTNS( "Basic.SetOrders returning " $ bResult );
	return bResult;
}

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

function Actor GetSpecialGoal()
{
	local Actor ReturnedGoal;

	if( Orders == OrdersFollow )
	{
		if( Controller(OrdersObject) != None )
			ReturnedGoal = Controller(OrdersObject).Pawn;
		else
			ReturnedGoal = OrdersObject;

		if( ReturnedGoal == None || ReturnedGoal.bDeleteMe )
		{
			#debug DMAI( "SetOrders " $ GetContext() );
			SetOrders( OrdersNone );
			ReturnedGoal = None;
		}			
	}
	else
	{
		ReturnedGoal = Super.GetSpecialGoal();
	}

	return ReturnedGoal;
}

//-----------------------------------------------------------------------------
//@ STATES -- BASE
//-----------------------------------------------------------------------------

state @ MoveToGoalWithEnemyState extends @ MoveToGoalBaseState
{
	function EnemyAcquired();
} // MoveToGoalWithEnemyState

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

/*-----------------------------------------------------------------------------
NPC just acquired an enemy -- take some time to react, turning towards enemy, 
possibly playing a special animation and even staring at the enemy for a brief 
period so that NPCs don't instantly react to enemies.
*/

state @ AcquisitionState
{
	ignores BeginFalling, EnemyInLeapRange, NotifyLanded; 

	function PlayRandomSound();

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

	function ShotFiredNotification( Pawn Shooter, vector FireDir, class<Projectile> ProjectileClass, float ProjSpeed );
	
	//-------------------------------------------------------------------------

	singular function eventHearNoiseThreat( float Loudness, Actor NoiseMaker )
	{
		#debug DMAI( "eventHearNoiseThreat -- calling MaybeSetEnemy  NoiseMaker: " $ NoiseMaker );
		if( MaybeSetEnemy( NoiseMaker.Instigator ) )
			HandleEnemyNoise( NoiseMaker );
	}
	
	//-------------------------------------------------------------------------

	function eventSeeEnemy( Pawn Seen )
	{
		if( MaybeSetEnemy( Seen ) )
			Pawn.MakeNoise( 1.0 );
	} 

	//-------------------------------------------------------------------------
	
	function bool CanFire( bool bTest ) { return false; }
	
	//-------------------------------------------------------------------------

	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Global.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
		#debug   UpdateBehavior( false, GetContext() );
		#release UpdateBehavior( false );
	}
	
	/*!!mdf-tbd:
	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		//DMTNS( "BeginState" );
		// turn more slowly during acquisition?
		Pawn.RotationRate.Yaw = Min( 32000, Pawn.default.RotationRate.Yaw );
	}
	*/
		
	//-------------------------------------------------------------------------
	
	event EndState()
	{
		//DMTNS( "EndState" );
		UnlockAnimationController( true );
		BCStartFiring();
		if( Pawn != None )
			Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
	}
	
	//-------------------------------------------------------------------------

@ BeginLabel:
	WaitForLanding();
	StopMovement( true, false );
	Focus = ControllerEnemy;
	FocalPoint = Focus.Location;
	if( NeedToTurn( FocalPoint, NeedToTurnAngleCos ) )
		FinishRotation( DefaultRotationThreshold );
	FocalPoint = Focus.Location;

@ PostBeginLabel:
	//DMTNS( "Finished rotating, sleeping for " $ U2PBasic.MinAcquisitionDelay - (Level.TimeSeconds - LastAcquireTime) $ " secs" );
	Sleep( U2PBasic.MinAcquisitionDelay - (Level.TimeSeconds - LastAcquireTime) );
	
	// Play acquisition animation for less intelligent NPCs? Mercs, 
	// marines etc. have alert animations which should have kicked in by now.
	if( StationaryPawn(ControllerEnemy) == None )
		U2PBasic.HandleAcquireEnemySound();
		
	if( FDecision( U2PBasic.AcquisitionAnimationOdds ) )
	{
		StopMovement( true, true );
		//DMTNS( "ACQUIRE!" );
		Sleep( SetSpecialAnim( 'U2_Acquire', true ) );
		Sleep( U2PBasic.PostAcquisitionAnimationDelay );
	}
	#debug   UpdateBehavior( false, GetContext() );
	#release UpdateBehavior( false );
} // AcquisitionState

/*-----------------------------------------------------------------------------
Close in on an enemy.
*/

state @ AttackCloseState extends @ MoveToGoalWithEnemyState
{
	// can't ignore NotifyBump -- borks moving around friendly NPCs
	// 2002.11.11 added SeeEnemy -- we have an enemy, we can assume its in sight, no?
    ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise;

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

	event MayFall()
	{
		#debug DMAI( "MayFall" );

		if( MoveTarget == ControllerEnemy )
		{
			// if enemy is still reachable go ahead with the jump, otherwise abort it
			Pawn.bCanJump = ActorReachable( ControllerEnemy );
			if( !Pawn.bCanJump )
			{
				//DMTNS( "MayFall: BC_EnemyCantReach" );
				//GS( AttackTacticalMoveState, DontCloseLabel );
				#debug   BehaviorController.Update( BC_EnemyCantReach, GetContext() );
				#release BehaviorController.Update( BC_EnemyCantReach );
			}
		}
	}

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

	function bool CanFire( bool bTest ) { return ( U2PBasic.bHasMovingRangedAttack && FDecision( U2PBasic.AttackClosingCanFireOdds ) && Global.CanFire( bTest ) ); }

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

	function FearThisSpot( Actor aSpot )
	{
		#debug DMAI( "FearThisSpot" );
		Destination = Pawn.Location + 120 * Normal( Normal( Destination - Pawn.Location ) + Normal( Pawn.Location - aSpot.Location ) ); 
		GotoLabel( MoveActiveStrafeLabel );
	}

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

	function bool TryStrafe( vector SideDir )
	{ 
		local vector Extent, HitLocation, HitNormal;
		local Actor HitActor;

		#debug DMAI( "TryToStrafe" );

		Extent = Pawn.CollisionRadius * vect(1,1,0);
		Extent.Z = Pawn.CollisionHeight;
		HitActor = Pawn.Trace( HitLocation, HitNormal, Pawn.Location + 100 * SideDir, Pawn.Location, false, Extent );
		if( HitActor != None )
		{
			SideDir *= -1;
			HitActor = Pawn.Trace( HitLocation, HitNormal, Pawn.Location + 100 * SideDir, Pawn.Location, false, Extent );
		}
		if( HitActor != None )
			return false;
		
		if( Pawn.Physics == PHYS_Walking )
		{
			HitActor = Pawn.Trace( HitLocation, HitNormal, Pawn.Location + 100 * SideDir - Pawn.MaxStepHeight * vect(0,0,1), Pawn.Location + 100 * SideDir, false, Extent);
			if( HitActor == None )
				return false;
		}

		// do the strafe
		Destination = Pawn.Location + 250 * SideDir;
		GotoLabel( MoveActiveStrafeLabel );
		return true;
	}
			
	//-------------------------------------------------------------------------

	function TryToDodge( vector DuckDir, bool bDuckLeft )
	{
		#debug DMAI( "TryToDodge" );
		if( !U2PBase.bCanStrafe || FDecision( U2PBasic.DodgeInsteadofStrafeOdds ) )
			Global.TryToDodge( DuckDir, bDuckLeft );
		else if( U2PBase.bCanStrafe && MoveTarget == ControllerEnemy ) 
			TryStrafe( DuckDir );
	}

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

	function bool StrafeFromDamage( float Damage, class<DamageType> DamageType, bool bFindDest )
	{
		local vector SideDir;

		#debug DMAI( "StrafeFromDamage" );

		if( !Pawn.bCanStrafe )
			return false;

		if( FRand() * Damage < 0.15 * U2PBasic.CombatStyle * Pawn.Health ) 
			return false;

		if( !bFindDest )
			return true;

		if( ControllerEnemy == None )
			return false;

		SideDir = Normal( (ControllerEnemy.Location - Pawn.Location) cross vect(0,0,1) );
		if( ( Pawn.Velocity dot sidedir ) > 0 )
			sidedir *= -1;

		return TryStrafe( SideDir );
	}

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

	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		local float Pick;
		local vector SideDir;
		local bool bWasOnGround;

		#debug DMAI( "eventTookDamage" );

		// !!mdf-tbd: refactor with global
		if( Pawn.Health > 0 )
		{
			#debug DMAI( "eventTookDamage" );

			bWasOnGround = ( Pawn.Physics == PHYS_Walking );
	
			Global.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );

			if( !StrafeFromDamage( Damage, DamageType, true ) )
			{
				if( bWasOnGround && MoveTarget == ControllerEnemy && Pawn.Physics == PHYS_Falling ) 
				{
					// weave
					Pick = 1.0;
					if( bStrafeDir )
						Pick = -1.0;
					SideDir = Normal( (ControllerEnemy.Location - Pawn.Location) cross vect(0,0,1) );
					SideDir.Z = 0;
					Pawn.Velocity += Pick * Pawn.GroundSpeed * 0.7 * SideDir;   
					if( FRand() < 0.2 )
						bStrafeDir = !bStrafeDir;
				}
			}
		}
	}

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

	function eventEnemyNotVisible()
	{
		#debug DMAI( "EnemyNotVisible -- going to attack hunt" );
		//GS( AttackHuntState ); 
		#debug   BehaviorController.Update( BC_EnemyNotVisible, GetContext() );
		#release BehaviorController.Update( BC_EnemyNotVisible );
	}

	/*-------------------------------------------------------------------------
	NOTE: Actor/PointReachable return false if target is more than MAXPATHDIST
	units away (assumes that pathing will be used).
	
	I added bKamikazeClose to override this but we'll probably eventually want
	to be able to pass the max distance to use to Actor/PointReachable so that
	we can have "smart" charging from far away without needing to use paths

	Also note that when smart closing (use paths if > 1200 units away) is used
	then this has 2 side effects:

	1) If there are no paths then the NPC can't move (will turn into a turret 
	   if he has a ranged attack until the enemy becomes reachable).

	2) If there are paths, the NPC may appear to "weave" as he closes in 
	   as he moves towards pathnodes while looking at his enemy.
	*/

	function bool CloseRequiresPathing()
	{
		//DMTNS( "CloseRequiresPathing ActorReachable (" $ U2PBasic.AttackClosingReachableDistSquared $ "): " $ ActorReachable( ControllerEnemy, U2PBasic.AttackClosingReachableDistSquared ) );
		return ( !U2PBasic.bKamikazeClosing && !ActorReachable( ControllerEnemy, U2PBasic.AttackClosingReachableDistSquared ) );
	}

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

	function bool GetPredictedCloseLocation( out vector PredictedLocation )
	{
		//DMTNS( "calling GetBestPredictedLocation" );
		class'UtilGame'.static.GetBestPredictedLocation( Pawn, ControllerEnemy, Pawn.GroundSpeed, 0.0, PredictedLocation );
		
		//DMTNS( "called GetBestPredictedLocation" );
			
		// use a location that is a small distance along the vector to the 
		// predicted location so call to MoveToPoint won't take long (this would
		// reduce the frequency with which the destination is updated).
		
		//AddCylinder( PredictedLocation, 4, 4, ColorCyan() );
		
		PredictedLocation = Pawn.Location + Pawn.CollisionRadius * 8.0 * Normal( PredictedLocation - Pawn.Location );
		
		//AddCylinder( PredictedLocation, 4, 4, ColorOrange() );
		//Level.bPlayersOnly = !Level.bPlayersOnly;
		
		return true;
	}

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

	function EDestinationResult SetChargeDestination()
	{
		local Actor CurrentEnemy;
		local float DeltaZ;
		local vector PredictedLocation;
		
		CurrentEnemy = ControllerEnemy;

		// check for enemy directly above us (without this check its possible for an
		// NPC/player to "surf" on top of the other one since the lower one will 
		// always try to move in the same direction instantly
		if( VSize2D(CurrentEnemy.Location - Pawn.Location) <= (CurrentEnemy.CollisionRadius + Pawn.CollisionRadius) )
		{
			DeltaZ = CurrentEnemy.Location.Z - Pawn.Location.Z;
			if( DeltaZ > 0 && DeltaZ < 256.0 )
				return DR_Wait;
		}			
		
		if( !U2PBasic.bPredictChargeLocation )
			return DR_Raw;

		if( VSize(CurrentEnemy.Location - Pawn.Location) <= 3*Pawn.MeleeRange )
			return DR_Raw;

		if( !GetPredictedCloseLocation( PredictedLocation ) )
			return DR_Raw;

		if( !U2PBasic.bKamikazeClosing && !PointReachable( PredictedLocation ) )
			return DR_Raw;

		Destination = PredictedLocation;
		
		return DR_Predicted;
	}

	//-------------------------------------------------------------------------
	//2002.12.17 (mdf) hack to fix izarians not closing.

	function bool FindAlternativeClosePath( Actor Focus )
	{
		local float TargetDistance, NPDistance;
		local TDistanceInfo NPList[ MaxDistanceActors ];
		local int ii;
		
		//DMTNS( "FindAlternativeClosePath  Focus: " $ Focus );
	
		// only applies to levels with XMP items:
		if( Level.HasSpecialColliders() )
		{
			TargetDistance = VSize( Focus.Location - Pawn.Location );
			
			// only applies to NPCs with modified attack ranges
			if( !CheckMaxAttackRanges( TargetDistance, Focus ) ||
				(TargetDistance > 512.0 && (Pawn.IsA( 'U2SkaarjLight' ) || Pawn.IsA( 'U2SkaarjMedium' ) || Pawn.IsA( 'U2SkaarjHeavy' ))) )
			{
				//DMTNS( "looking for alternative paths" );
				// look for a pathnode which is at most 1200 units away
				// and closer to the enemy than the NPC's current location
				GetNearbyPathNodesRelativeTo( Pawn, Focus, NPList, 50.0, 2400.0, false );
				
				for( ii=0; ii<ArrayCount(NPList); ii++ )
				{
					if( NPList[ ii ].TargetActor == None )
						break;
				
					NPDistance = VSize( Focus.Location - NPList[ ii ].TargetActor.Location );
					
					if( NPDistance < TargetDistance )
					{	
						//DMTNS( "checking: " $ NPList[ ii ].TargetActor );
						//AddCylinder( NPList[ ii ].TargetActor.Location, 16, 16, ColorYellow() );
						if( FindBestPathToward( NPList[ ii ].TargetActor, true ) )
						{
							MoveTarget = NPList[ ii ].TargetActor;
							Destination = MoveTarget.Location;
							//AddActor( MoveTarget, ColorPink() );
							//DMTNS( "found alternate path: " $ MoveTarget );
							return true;
						}
					}
				}
			}
		}
		
		return false;
	}

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

	function bool FaceTarget( float F )
	{
		if( !Pawn.bCanStrafe )
			return false;
			
		if( U2PBasic.CloseFaceTarget == 1 )
			return true;

		if( U2PBasic.CloseFaceTarget == -1 )
			return false;
			
		if( (VSize( MoveTarget.Location - Pawn.Location ) < 2.5 * Pawn.CollisionRadius) )
			return true;
			
		return Global.FaceTarget( F );
	}
	
	//-------------------------------------------------------------------------

	function ETacticalMoveType GetTacticalMoveType()
	{
		//!!mdf-tbd:
		//if( GetSkill() >= 0.5 && IsPreparedToFire( true ) && FRand() < 0.75 )
		//if( IsPreparedToFire( true ) && FRand() < 0.75 )
		//!!mdf-tbd: why do we care whether the NPC can fire or not? If there really are cases, add a 
		// new bool to control this?
		if( FDecision( U2PBasic.TacticalMoveCloseOdds ) )
		//if( (!U2PBasic.bHasRangedAttack || IsPreparedToFire( true )) && FDecision( U2PBasic.TacticalMoveCloseOdds ) )
			return Pawn.TacticalMoveType;
		else
			return TMT_None;
	}

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

	function TryToCloseDodge( bool bLeft )
	{
		local vector DodgeDir;

		//DMTNS( "TryToCloseDodge" );
		DodgeDir = Normal( (ControllerEnemy.Location - Pawn.Location) cross vect(0,0,1) );

		if( bLeft )
			TryToDodge( -DodgeDir, true );
		else
			TryToDodge( DodgeDir, false );
	}

	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		Super.BeginState();
		
		if( U2PBasic.AttackClosingCanFireOdds <= 0.0 )
		{
			#debug   StopFiring( 9999999.9, SFI_Behavior, GetContext() ); // kill off firing timer for the duration of the state
			#release StopFiring( 9999999.9, SFI_Behavior ); // kill off firing timer for the duration of the state
		}
		if( StationaryPawn(ControllerEnemy) != None )
			Enable( Event_SeeEnemy );
		else
			Disable( Event_SeeEnemy );
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		if( Pawn != None )
			Pawn.bCanJump = (Pawn.JumpZ > 0);
			
		if( U2PBasic != None && U2PBasic.AttackClosingCanFireOdds <= 0.0 )
		{
			#debug   StopFiring( 0.2, SFI_Behavior, GetContext() ); // restore firing timer
			#release StopFiring( 0.2, SFI_Behavior ); // restore firing timer
		}
	}

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

@ BeginLabel:
	#debug DMAIL( BeginLabel );

@ MovePickDestLabel:
@ CloseLabel:
	if( !ValidEnemy( ControllerEnemy ) )
	{
		#debug   BehaviorController.Update( BC_EnemyInvalid, GetContext() );
		#release BehaviorController.Update( BC_EnemyInvalid );
	}
	
	#debug DMAI( "CloseLabel Enemy = " $ ControllerEnemy );

	if( ControllerEnemy.PhysicsVolume.bWaterVolume )
	{
		if( !Pawn.bCanSwim )
		{
			//DMTNS( "enemy in a water volume and I can't swim: BC_EnemyCantReach" );
			//GS( AttackTacticalMoveState, DontCloseLabel );
			#debug   BehaviorController.Update( BC_EnemyCantReach, GetContext() );
			#release BehaviorController.Update( BC_EnemyCantReach );
		}
	}
	else if( !Pawn.bCanFly && !Pawn.bCanWalk )
	{
		//DMTNS( "enemy not in a water volume and I can't fly or walk: BC_EnemyCantReach" );
		//GS( AttackTacticalMoveState, DontCloseLabel );
		#debug   BehaviorController.Update( BC_EnemyCantReach, GetContext() );
		#release BehaviorController.Update( BC_EnemyCantReach );
	}

	Focus = ControllerEnemy;
	Destination = Focus.Location;
	WaitForLanding();

	if( CloseRequiresPathing() )
	{
		//DMTNS( "closing using path to enemy at: " $ VSize( Focus.Location - Pawn.Location ) );
		
@ CantReachLabel:
		#debug DMAIL( CantReachLabel );
		//!!mdf-tbd: shouldn't do this -- might still be facing enemy? 
		//if( !FindBestPathToward( Focus, true ) )
		if( !FindBestPathToward( Focus, true ) && !FindAlternativeClosePath( Focus ) )
		{
			#debug DMAIM( "can't close (no path or not mobile): BC_EnemyCantReach" );
			Sleep( 0.0 ); // prevents state recursion in some cases
			#debug   BehaviorController.Update( BC_EnemyCantReach, GetContext() );
			#release BehaviorController.Update( BC_EnemyCantReach );
		}
		else
		{
			#debug DMAIM( "moving toward " $ MoveTarget );

			if( FaceTarget( 1.5 ) )
			{
				//DMTNS( "  while facing enemy" );
				MoveToActor( MoveTarget, GetTacticalMoveType(), , , Focus, GetMoveSpeed() );
			}
			else
			{
				//DMTNS( "  while facing navigation point" );
				MoveToActor( MoveTarget, GetTacticalMoveType(), , , , GetMoveSpeed() );
			}
		}
	}
	else
	{
		//DMTNS( "closing using destination=enemy or predicted location" );
		
		DestinationResult = SetChargeDestination();
		if( DestinationResult == DR_Wait )
		{
			Goto( PauseLabel );
		}
		else 
		{
			// only use predicted location (MoveToPoint) if it isn't near the enemy
			if( DestinationResult == DR_Predicted )
			{
				//DMTNS( "  using target's predicted location  face location: " $ U2PBasic.bFacePredictedLocation );
				//AddArrow( Pawn.Location, Destination, ColorOrange() );
				//!!mdf-tbd: can't currently use tactical moves while moving to a point destination
				if( U2PBasic.bFacePredictedLocation )
					MoveToPoint( Destination, , , GetMoveSpeed() );
				else
					MoveToPoint( Destination, , Focus, GetMoveSpeed() );
			}
			else
			{
				//DMTNS( "  using target's current location" );
				//NOTE: will use TMT_Basic instead of TMT_Serpentine if Pawn.bResortToBasicTacticalMoves=true
				MoveToActor( Focus, GetTacticalMoveType(), , , , GetMoveSpeed() );
			}
				
			if( FDecision( U2PBasic.RandomCloseDodgeOdds ) )
				TryToCloseDodge( bTacticalDir );
		}
	}

	// stay in this state until BC decides otherwise (or something changes) 
	Goto( CloseLabel );

@ TurnLabel:
	#debug DMAIM( TurnLabel );
	StopMovement( true, true );
	Focus = ControllerEnemy;
	FinishRotation( DefaultRotationThreshold );
	Goto( CloseLabel );
	Stop;

// collapse with DelayLabel in charging?
@ PauseLabel:
	#debug DMAIM( PauseLabel );
	//StopMovement( true, false );
	Focus = ControllerEnemy;
	FinishRotation( DefaultRotationThreshold );
	Sleep( 0.5 );
	Goto( CloseLabel );

// mdf: handle strafe move here rather than jumping to attacktactical state for this as was done before
@ MoveActiveStrafeLabel:
	//DMTNS( "StrafeMove!" );
	MoveToPoint( Destination, , ControllerEnemy );
	Goto( CloseLabel );
} // AttackCloseState

/*-----------------------------------------------------------------------------
Used by creatures like the mukhogg and rammer to charge directly at their enemy
and damage them if they are bumped by the "head" of the creature. If the target
is missed, creature will overshoot somewhat (due to momentum) before turning
around to charge at their enemy again. Also, while charging, the creature's
ability to correct its direction is somewhat limited.

NOTE: 
*/

state @ AttackCloseChargeState extends @ AttackCloseState
{
    ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise;

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

	function ETacticalMoveType GetTacticalMoveType()
	{
		return TMT_None;
	}
	
	//-------------------------------------------------------------------------

	function HandleBump( Pawn Other, bool bEnemy )
	{
		local float EnemyToHeadDistance, Threshold;
		local float SpeedRatio;
		local float Damage;
		local vector MomentumVector;

		// no damage unless Other is within range of head?
		EnemyToHeadDistance = VSize( Other.Location - (Pawn.Location + Pawn.CollisionRadius*vector(Pawn.Rotation)) );
		Threshold = (Other.CollisionRadius + U2PBasic.ChargeHeadSize);
		//DMTNS( "HandleBump: " $ Other $ " bEnemy: " $ bEnemy $ " Distance: " $ EnemyToHeadDistance $ " Threshold: " $ Threshold );
		
		if( EnemyToHeadDistance < Threshold )
		{
			// launch other, momentum transfer based on speed?
			SpeedRatio = VSize( Pawn.Velocity ) / Pawn.GroundSpeed;

			if( !bEnemy )
				SpeedRatio *= 0.25;

			MomentumVector = Normal( Other.Location - Pawn.Location );
			MomentumVector.Z = 1;
			MomentumVector *= U2PBasic.ChargeMaxMomentumTransfer * SpeedRatio * 100.0/Other.Mass;

			Damage = FMax( U2PBasic.ChargeMinDamage, U2PBasic.ChargeMaxDamage * SpeedRatio);
			//DMTNS( "Damage: " $ Damage );

			Other.TakeDamage( Damage, Pawn, Other.Location, MomentumVector, class'DamageTypePhysical' );
			//AddArrow( Other.Location, Other.Location + MomentumVector, ColorRed() );
	
			// tbd: special animation and/or state?
			if( bEnemy && ValidEnemy( ControllerEnemy ) )
			{
				Disable( Event_NotifyBump );
				#debug   UpdateBehavior( true, GetContext() );
				#release UpdateBehavior( true );
				//GotoLabel( DelayLabel ); // enemy still alive, pause a bit
			}
		}
	}

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

	function eventBumpEnemy( Pawn Other )
	{
		// launch enemy, momentum transfer based on speed
		Super.eventBumpEnemy( Other );

		HandleBump( Other, true );
	}

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

	// !!mdf-tbd:
	function eventBumpFriend( Pawn Other )
	{
		//DMTNS( "BUMP friend: " $ Other );

		Super.eventBumpFriend( Other );

		// tbd: don't bump same class?
		if( !ClassIsChildOf( Pawn.Class, Other.Class ) )
			HandleBump( Other, false );
	}

	//-------------------------------------------------------------------------
		
	function bool GetPredictedCloseLocation( out vector PredictedLocation )
	{
		local vector PredictedDirection, RotationDirection;
		local vector PredictedNormal, RotationNormal;
		local vector PredictedOffset, RotationOffset;
		local vector TargetLocation;
		local float TargetDistance, CosTargetAngle;
		local float ChangeSize;
		local bool bResult;
		
		TargetDistance = class'Util'.static.GetDistanceBetweenActors( Pawn, ControllerEnemy );
		if( TargetDistance < 2*Pawn.CollisionRadius )
		{
			PredictedLocation = ControllerEnemy.Location;
		}
		else
		{ 
			if( !Super.GetPredictedCloseLocation( PredictedLocation ) )
				return false;
		}

		// constrain result based on speed (limit change)

		// must be a better way? but for now just select a destination somewhere
		// on the vector between endpoint of unit vector alingned with Pawn's 
		// rotation and endpoint of unit vector corresponding to predicted
		// location then extrapolate that out.

		//!!mdf-tbd: better way is to use RotateAngleAxis?
		
		// mdf-tbd: eliminate Z component?
		PredictedDirection = PredictedLocation - Pawn.Location;
		PredictedDirection.Z = 0;
		RotationDirection = vector( Pawn.Rotation );
		RotationDirection.Z = 0;
		
		// mdf-tbd: handle pathological cases (are there any?)
		PredictedNormal = Normal( PredictedDirection );
		RotationNormal  = Normal( RotationDirection );
		CosTargetAngle = PredictedNormal dot RotationNormal;

		//AddArrow( Pawn.Location, PredictedLocation, ColorCyan() );
		//if( (CosTargetAngle < 0.707) && TargetDistance > 512.0 ) -- stops all the time
		if( (CosTargetAngle < 0.0) && (TargetDistance > 512.0 || VSize( Pawn.Velocity) < 0.1*Pawn.GroundSpeed) )
		{
			#debug DMAIM( "angle too great -- turning!" );
			GotoLabel( TurnLabel );
		}
		else if( TargetDistance < Pawn.CollisionRadius && CosTargetAngle > 0.866 )
		{
			bResult = true;
		}
		else
		{
			//PredictedOffset = Pawn.Location + PredictedNormal;
			//RotationOffset = Pawn.Location + RotationNormal;
	
			// tbr: extend out so more visible for debugging -- shouldn't be needed though
			PredictedOffset = Pawn.Location + 512.0*PredictedNormal;
			RotationOffset = Pawn.Location + 512.0*RotationNormal;
	
			//AddArrow( Pawn.Location, Pawn.Location + 2048.0*PredictedNormal, ColorRed() );
			//AddArrow( Pawn.Location, Pawn.Location + 2048.0*RotationNormal,  ColorGreen() );
	
			//DMTNS( "Location: "		   $ Pawn.Location );
			//DMTNS( "PredictedOffset: " $ PredictedOffset );
			//DMTNS( "RotationOffset:  " $ RotationOffset );
			//DMTNS( "PredictedNormal: " $ PredictedNormal );
			//DMTNS( "RotationNormal:  " $ RotationNormal );
	
			//#debug AddLine( PredictedOffset, RotationOffset, ColorBlue() );
	
			// note: again, I'm sure there is a better way to do this but at this point
			// we have a "line" with endpoints 2048.0 units away from the Pawn which
			// represents the desired change in direction. If this is more than some
			// amount (should really be an angle) then scale it back based on the
			// Pawn's Velocity / GroundSpeed ratio allowing a 256 "unit" change even
			// if at max Velocity.
			ChangeSize = VSize(PredictedOffset - RotationOffset);
			if( ChangeSize > U2PBasic.ChargeMaxChangeSize )
			{
				// scale distance from ChangeSize down to MaxChangeSize depending on velocity
				ChangeSize = U2PBasic.ChargeMaxChangeSize + (1.0 - (VSize( Pawn.Velocity ) / Pawn.GroundSpeed)) * (ChangeSize-U2PBasic.ChargeMaxChangeSize);
				TargetLocation = RotationOffset + U2PBasic.ChargeMaxChangeSize*Normal( PredictedOffset - RotationOffset);
			}
			else
			{
				TargetLocation = PredictedOffset;
			}
	
			//DMTNS( "TargetLocation: " $ TargetLocation );
	
			// keep distances short so MoveToPoint doesn't get tied up for too long
			PredictedLocation = Pawn.Location + 128.0*Normal( TargetLocation - Pawn.Location);
	
			//AddArrow( Pawn.Location, PredictedLocation, ColorMagenta() );
	
			//PredictedLocation.Z = 0; should be Pawn Location.Z by now?
	
			//DMTNS( "PredictedLocation: " $ PredictedLocation );
			bResult	= true;
		}

		return bResult;
	}

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

@ DelayLabel:
	StopMovement( true, true );
	Focus = ControllerEnemy;
	FinishRotation( DefaultRotationThreshold );
	Sleep( 1.0 );
	Enable( Event_NotifyBump );
	Goto( CloseLabel );
} // AttackCloseChargeState

//-----------------------------------------------------------------------------
// Head towards a special goal or orders destination while dealing with an
// enemy.
//
// NOTE (mdf) UT bot code has ignore EnemyNotVisible here even though there
// was an EnemyNotVisible handler (so it was never getting called). This was
// either an oversight or maybe it was done intentionally because of either
// performance issues or maybe the NPC was cycling between 2 enemies in an
// undesirable way?

state @ AttackFallbackState extends @ MoveToGoalWithEnemyState
{
	//-------------------------------------------------------------------------

	event MayFall()
	{
		Pawn.bCanJump = TestCanJump();
	}

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

	function eventEnemyNotVisible()
	{
		local Pawn TempPawn;

		// current enemy no longer visible
		if( OldControllerEnemy != None && LineOfSightTo( OldControllerEnemy ) )
		{
			// old enemy visible - swap with current enemy
			TempPawn = OldControllerEnemy;
			OldControllerEnemy = ControllerEnemy;
			#debug   SetControllerEnemy( TempPawn, GetContext() );
			#release SetControllerEnemy( TempPawn );
		}
		else 
		{
			// no visible enemy
			if( !ControllerEnemy.IsMobile() )
			{
				// enemy can't move -- clear enemy and maybe pick up OldControllerEnemy (although not visible
				// current enemy (no longer visible) and can't move so worry about OldControllerEnemy (if set) instead
				#debug   SetControllerEnemy( None, GetContext() );
				#release SetControllerEnemy( None );
				UpdateEnemy();
			}
		}
	}

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

	function eventSeeEnemy( Pawn Seen )
	{
		if( Seen != ControllerEnemy && MaybeSetEnemy( Seen ) )
			Pawn.MakeNoise( 1.0 );
	}

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

	singular function eventHearNoiseThreat( float Loudness, Actor NoiseMaker )
	{
		if( NoiseMaker.Instigator != ControllerEnemy && !LineOfSightTo( ControllerEnemy ) )
		{
			#debug DMAI( "eventHearNoiseThreat -- calling MaybeSetEnemy" );
			if( MaybeSetEnemy( NoiseMaker.Instigator ) )
			{
				HandleEnemyNoise( NoiseMaker );
				Pawn.MakeNoise( 1.0 );
			}
		}
	}

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

	function bool FaceTarget( float F )
	{
		return Pawn.bCanStrafe; // always face target when using fallback?
	}

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

	function bool CanFire( bool bTest ) { return ( U2PBasic.bHasMovingRangedAttack && Global.CanFire( bTest ) ); }

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

	function ETacticalMoveType GetTacticalMoveType()
	{
		if( FDecision( U2PBasic.TacticalMoveFallbackOdds ) && GetTimeSinceEnemyLastSeen() < 1.0 )
			return Pawn.TacticalMoveType;
		else
			return TMT_None;
	}

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

	function bool OverrideSpecialAttraction()
	{
		return false;
	}

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

	function bool ShouldClearSpecialColliders()
	{
		return true; // so can fall back to special destination
	}

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

	function bool HasReachedOrdersObject()
	{
		return AtDestinationActor( OrdersObject, OrdersThreshold );

		/* old
		local float Distance;
		
		if( Pawn.Physics == PHYS_Walking )
			Distance = VSize2D( Pawn.Location - OrdersObject.Location );
		else	
			Distance = VSize( Pawn.Location - OrdersObject.Location );
		
		return ( Distance <= OrdersThreshold );
		*/
				
		/*!!mdf-tbd: used to be -- we don't currently have any cases afaik where we want an
		  NPC to stop short of the order object if its within sight if we do add cases like
		  this then we should have a way of determining when to use it.
		return( VSize( Pawn.Location - OrdersObject.Location ) < 20 || 
		       (VSize( Pawn.Location - OrdersObject.Location ) < 600 && LineOfSightTo( OrdersObject )) );
		*/
	}

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

	function HandleReachedOrdersObject()
	{
		//DMTNS( "got to OrdersObject: " $ OrdersObject );
		if( StationaryPawn(ControllerEnemy) != None || (GetTimeSinceEnemyLastSeen() > 5 && Orders == OrdersHold) )
		{
			#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
			#release SetControllerEnemy( OldControllerEnemy );
			OldControllerEnemy = None;
		}
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
	}

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

	function PickDestination()
	{
		local Actor PreviousMoveTarget;

		if( GetTimeSinceEnemyLastDetected() > MaxFallbackNoDetectTime )
		{
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		}
		
		if( !ValidEnemy( ControllerEnemy ) )
		{
			UpdateEnemy();
		}
		else
		{
			PreviousMoveTarget = MoveTarget;
		
			LastSpecialDestinationCheck = Level.TimeSeconds - 0.1;
	
			if( FindSpecialAttraction() )
			{
				if( !OverrideSpecialAttraction() )
				{
		   			if( MoveTarget == None )
		   			{
		   				#debug DMAI( " no destination in fallback!" );
		   				Orders = OrdersNone;
						#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
						#release BehaviorController.Update( BC_AttackUpdate );
					}
				}
			}
			else if( Orders == OrdersAttack || OrdersObject == None )
			{
				#debug DMAI( " attack fallback turned to freelance" );
				Orders = OrdersNone;
				#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
				#release BehaviorController.Update( BC_AttackUpdate );
			}
			else if( HasReachedOrdersObject() )
			{
				HandleReachedOrdersObject();
			}
			else
			{
				GetPathToActor( OrdersObject, MoveTarget, true );
				if( MoveTarget == None )
				{
					#debug DMAI( "fallback turned to freelance (no Path to " $ OrdersObject $ " )" );
					Orders = OrdersNone;
					#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
					#release BehaviorController.Update( BC_AttackUpdate );
				}
			}
		}
		
		if( MoveTarget != PreviousMoveTarget )
			NumMoveAttempts = 0;
	}

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

	function eventBumpEnemy( Pawn Other )
	{
		#debug DMAI( "eventBumpEnemy -- calling MaybeSetEnemy" );
		MaybeSetEnemy( Other );
	}

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

	function Actor GetFinalDestinationActor()
	{
		return None;
	}

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

	function float GetReachedDestinationDistance()
	{
		if( Orders != OrdersNone )
			return OrdersThreshold;
		else
			return -1.0; // use usual distance reached tests
	}

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

@ BeginLabel:
@ MovePickDestLabel:
	WaitForLanding();
	
	PickDestination();

@ MoveActiveLabel:
	if( MoveTarget == None )
		Goto( MoveNoDestLabel );

	//DMTNS( "MoveToActor  BEGIN  MoveTarget: " $ MoveTarget $ " TMT: " $ GetTacticalMoveType() $ " (final dest:" $ GetFinalDestinationActor() $ " Distance: " $ GetReachedDestinationDistance() $ " MoveSpeed:" $ GetMoveSpeed() $ ")" );
	if( FaceTarget( 1 ) )
	{
		//DMTNS( "  facing target" );
		MoveToActor( MoveTarget, GetTacticalMoveType(), GetFinalDestinationActor(), GetReachedDestinationDistance(), ControllerEnemy, GetMoveSpeed() );
	}
	else
	{
		//DMTNS( "  not facing target" );
		MoveToActor( MoveTarget, GetTacticalMoveType(), GetFinalDestinationActor(), GetReachedDestinationDistance(), , GetMoveSpeed() );
	}
	
	//DMTNS( "MoveToActor END returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );
	
	if( ++NumMoveAttempts > 8 )
	{
		//DMTNS( "ran out of move attempts" );
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() ); // try something else?
		#release BehaviorController.Update( BC_AttackUpdate ); // try something else?
	}	
	Goto( MovePickDestLabel );

@ MoveSpecialLabel:
	if( MoveTarget == None )
		MoveToPoint( Destination );
	else
		MoveToActor( MoveTarget, GetTacticalMoveType() ); 
	Goto( MovePickDestLabel ); // what if didn't get to special destination?

@ MoveNoDestLabel:
	#debug DMAIA( "AttackFallback.MoveNoDestLabel" );
	Focus = GetTarget();
	FinishRotation( DefaultRotationThreshold ); // try again in a bit
	Goto( MovePickDestLabel );
} // AttackFallbackState

//-----------------------------------------------------------------------------
// Similar to fallback basically except the destination will be a location from
// which the enemy won't have LOS to the NPC.

//2003.01.07 fix for "function not found problem" TTP #4616
function HandleRecoveredEnemy();

state @ AttackHuntState
{
	ignores EnemyNotVisible; 

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

	event MayFall()
	{
		Pawn.bCanJump = ( TestCanJump() || PointReachable( Destination ) );
	}

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

	function bool FaceTarget( float F )
	{
		// in general, never face face target when hunting -- shouldn't know where
		// it is, although PickDestination does "cheat" by using ControllerEnemy.Location.
		return false;
	}

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

	function bool IsFacingTarget( Actor Target, float CosMinFacingAngle )
	{
		return ( (Level.TimeSeconds - TimeSinceBeginState) < U2PBasic.MaxHuntFireAtLastSeenTime ); // so NPC can fire at last seen pos if facing it (AdjustAim will check this)?
	}

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

	function bool CanFire( bool bTest ) { return ( U2PBasic.bHasMovingRangedAttack && Global.CanFire( bTest ) ); }

	//-------------------------------------------------------------------------
	
	function HandleRecoveredEnemy()
	{
		// We're jumping to state code to shift and rotate the NPC and we
		// don't want to be spammed with SeeEnemy calls & keep ending up 
		// here. Senses will be re-enabled when we exit the state.
		DisableSenses();

		// And make sure shift + rotate isn't interrupted (or NPC won't be 
		// in a position to fire, possibly causing next state to bail).
		BehaviorController.SetMinTimeOutDelay( 1.0 );

		// !!mdf-tbd: actually getting cool behavior without this -- NPC runs 
		// across gap while firing at target and seemingly heading for cover.
		// This wouldn't be too hard to re-enable this "properly" -- just have 
		// some odds here of
		//  a) checking whether there is cover close by in the direction
		//     that the NPC is headed in
		//	b) if so, invalidate previous cover location (if any)
		//	c) put NPC into MoveToCover state with this destination
		StopMovement( true, false );
				
		if( LineOfSightTo( ControllerEnemy ) )
		{
			NumMoveAttempts	= 0;
			GotoLabel( AdjustPositionLabel );
		}
		else
		{
			GotoLabel( AdjustRotationLabel );
		}
	}
	
	//-------------------------------------------------------------------------
	
	function eventBumpEnemy( Pawn Other )
	{
		// NOTE: bump --> reevaluate attack situation
		#debug DMAI( "eventBumpEnemy -- calling MaybeSetEnemy" );
		MaybeSetEnemy( Other );
	}

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

	function bool ReduceThreat()
	{
		return true;
	}

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

	function FearThisSpot( Actor aSpot )
	{
		Destination = Pawn.Location + 120 * Normal( Normal( Destination - Pawn.Location ) + Normal( Pawn.Location - aSpot.Location ) ); 
		MoveTarget = None;
		GotoLabel( MoveSpecialLabel );
	}

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

	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			bFrustrated = true;
			Global.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
		}
	}

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

	singular function eventHearNoiseThreat( float Loudness, Actor NoiseMaker )
	{
		#debug DMAI( "eventHearNoiseThreat -- calling MaybeSetEnemy" );
		MaybeSetEnemy( NoiseMaker.Instigator );
	}

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

	function EnemyAcquired(); // go through HandleRecoveredEnemy (via MaybeSetEnemy)
	
	//-------------------------------------------------------------------------

	function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )
	{
		local bool bResult;

		bResult = Global.MaybeSetEnemy( NewEnemy, bAlertingOthers );

		if( bResult )
		{
			BlockedPath = None;
			Focus = ControllerEnemy;
			HandleRecoveredEnemy();
		}

		return bResult;
	} 

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

	function bool FindViewSpot()
	{
		local vector X, Y, Z;
		local bool bAlwaysTry, bResult;

		GetAxes( Rotation, X, Y, Z );

		// try left and right
		// if frustrated, always move if possible
		bAlwaysTry = bFrustrated;
		bFrustrated = false;

		if( Pawn.FastTrace( ControllerEnemy.Location, Pawn.Location + 2 * Y * Pawn.CollisionRadius ) )
		{
			Destination = Pawn.Location + 2.5 * Y * Pawn.CollisionRadius;
			bResult = true;
		}
		else if( Pawn.FastTrace( ControllerEnemy.Location, Pawn.Location - 2 * Y * Pawn.CollisionRadius ) )
		{
			Destination = Pawn.Location - 2.5 * Y * Pawn.CollisionRadius;
			bResult = true;
		}
		else if( bAlwaysTry )
		{
			if( FRand() < 0.5 )
				Destination = Pawn.Location - 2.5 * Y * Pawn.CollisionRadius;
			else
				Destination = Pawn.Location - 2.5 * Y * Pawn.CollisionRadius;
			bResult = true;
		}

		return bResult;
	}

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

	function MaybeClearHuntingEnemy()
	{
		// If no enemy, or I should see him but don't, then give up		
		if( GetTimeSinceEnemyLastDetected() > MaxHuntTime )
		{
			if( ControllerEnemy != None )
				U2P.AssetsHelperClass.static.HandleLostEnemy( U2P );

			#debug DMAI( "MaybeClearHuntingEnemy clearing enemy" );
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		}
	}

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

	function bool SpecialHuntDestination()
	{
		return false;
	}

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

	function PickDestination()
	{
		local NavigationPoint Path;
		local Actor HitActor;
		local vector HitNormal, HitLocation, NextSpot, ViewSpot;
		local float posZ;
		local bool bCanSeeLastSeen;
		local int i;

		MaybeClearHuntingEnemy();

		if( !ValidEnemy( ControllerEnemy ) )
		{
			UpdateEnemy();
			return;
		}

		Pawn.bAvoidLedges = false;
		Pawn.bCanJump = (Pawn.JumpZ > 0);

		if( ActorReachable( ControllerEnemy ) )
		{
			//DMTNS( "hunt using enemy reachable" );
			BlockedPath = None;
			if( (NumMoveAttempts < 8 + 8*GetSkill()) || 
				(GetTimeSinceEnemyLastDetected() < 15) || 
				((Normal( ControllerEnemy.Location - Pawn.Location ) dot vector(Pawn.Rotation)) > -0.5) )
			{
				Destination = ControllerEnemy.Location;
				MoveTarget = None;
				NumMoveAttempts++;
			}
			else
			{
				// giving up
				//2002.12.07 mdf-tbd: need to invalidate enemy if giving up?
				UpdateEnemy();
			}
			return;
		}

		if( SpecialHuntDestination() )
		{
			//DMTNS( "hunt using special hunt destination" );
			return;
		}
		
		NumMoveAttempts++;

		ViewSpot = Pawn.Location + Pawn.BaseEyeHeight * vect(0,0,1);
		bCanSeeLastSeen = Pawn.FastTrace( GetLastEnemySeenLocation( ), ViewSpot );
		
		//DMTNS( "bCanSeeLastSeen: " $ bCanSeeLastSeen );

		if( bCanSeeLastSeen )
			bHunting = !Pawn.FastTrace( GetLastEnemySeenLocation(), ControllerEnemy.Location );
		else
			bHunting = true;

		if( bDeviousHunting )
		{
			if( BlockedPath == None )
			{
				// block the first Path visible to the enemy
				if( GetPathToActor( ControllerEnemy, , false ) != PR_None )
				{
					for ( i=0; i<16; i++ )
					{
						if( NavigationPoint( RouteCache[i] ) == None )
							break;
						else if( ControllerEnemy.Controller.LineOfSightTo( RouteCache[i] ) )
						{
							BlockedPath = NavigationPoint( RouteCache[i] );
							break;
						}
					}
				}
				else if( CanStakeOut() )
				{
					//DMTNS( "stakeout" );
					UpdateEnemy();
					return;
				}
				else
				{
					//DMTNS( "update" );
					//2002.12.07 mdf-tbd: need to invalidate enemy if giving up?
					UpdateEnemy();
					return;
				}
			}
			// control Path weights
			ClearPaths();
			if( BlockedPath != None )
				BlockedPath.Cost = 1500;
			if( FindBestPathToward( ControllerEnemy, false ) )
			{
				//DMTNS( "using devious path" );
				return;
			}
		}
		else if( FindBestPathToward( ControllerEnemy, true ) )
		{
			//DMTNS( "using path to enemy" );
			return;
		}
		
		//DMTNS( "HERE?" );
		
		MoveTarget = None;
		
		if( NumMoveAttempts > 60 && ShouldGiveUpHunting() )
		{
			UpdateEnemy();
			U2P.AssetsHelperClass.static.HandleLostEnemy( U2P );
			UpdateEnemy();
			return;
		}

		if( !bTriedLastDetectedLocation )
		{
			Destination = GetLastEnemyDetectedLocation();
			bTriedLastDetectedLocation = true;
			if( Pawn.FastTrace( ControllerEnemy.Location, ViewSpot ) )
			{
				if( VSize( Pawn.Location - Destination ) < 20 )
				{
					#debug DMAI( "PickDestination -- calling MaybeSetEnemy" );
					MaybeSetEnemy( ControllerEnemy );
				}
				return;
			}
		}

		Pawn.bAvoidLedges = ( Pawn.CollisionRadius > 42 );
		posZ = GetLastEnemySeenLocation().Z + Pawn.CollisionHeight - ControllerEnemy.CollisionHeight;
		NextSpot = GetLastEnemySeenLocation() - Normal( ControllerEnemy.Velocity ) * Pawn.CollisionRadius;
		NextSpot.Z = posZ;
		if( Pawn.FastTrace( NextSpot, ViewSpot ) )
			Destination = NextSpot;
		else if( bCanSeeLastSeen )
			Destination = GetLastEnemySeenLocation();
		else
		{
			Destination = GetLastEnemySeenLocation();
			if( !Pawn.FastTrace( GetLastEnemySeenLocation(), ViewSpot ) )
			{
				// check if could adjust and see it
				if( PickWallAdjust( Normal( GetLastEnemySeenLocation( ) - ViewSpot ) ) || FindViewSpot() )
				{
					if( Pawn.Physics == PHYS_Falling )
						SetFall();
					else
						GotoLabel( AdjustFromWallLabel );
				}
				else if( VSize( ControllerEnemy.Location - Pawn.Location ) < 1200 )
				{
					//2002.12.07 mdf-tbd: need to invalidate enemy if giving up?
					UpdateEnemy();
					return;
				}
				else
				{
					//2002.12.07 mdf-tbd: need to invalidate enemy if giving up?
					UpdateEnemy();
					return;
				}
			}
		}
		
		// cheat -- update last detected location with enemy's current location
		SetLastEnemyDetectedLocation( ControllerEnemy.Location );
	}	

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

	function BlockFiring()
	{
		// make sure NPC can't fire for a bit
		if( (Level.TimeSeconds - AlertTime) > 8.0 )
			BCBlockFiring( U2PBasic.MinReAcquisitionDelay, false );	// don't react as quickly
		else
			BCBlockFiring( U2PBasic.MinAlertAcquisitionDelay, false ); // still fairly alert - react more quickly
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		SetAlertness( 0.5 );
		bTriedLastDetectedLocation = false;
		bDeviousHunting = GetShouldUseDeviousTactics( 0.50, 0.50 );
		U2PBasic.bAlertedEnemyHunted = false;
		AlertTime = Level.TimeSeconds - GetTimeSinceEnemyLastDetected();
		TimeSinceBeginState = Level.TimeSeconds;
	}

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

	event EndState()
	{
		bHunting = false;
		RestoreAlertness();
		if( Pawn != None )
		{
			Pawn.bAvoidLedges = Pawn.default.bAvoidLedges;
			Pawn.bCanJump = (Pawn.JumpZ > 0);
		}
		EnableSenses();		
		BlockFiring();
	}

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

@ AdjustFromWallLabel:
	MoveToPoint( Destination, , MoveTarget ); 
	Goto( HuntLabel );

@ BeginLabel:
	ClearMoveAttempts();

@ HuntLabel:
	//!!mdf-tbd: FindSpecialAttraction();

	/*!!mdf-tbd:
	if( bSniping )
	{
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() ); //!!tbd: BC_StakeOut?
	}	#release BehaviorController.Update( BC_AttackUpdate ); //!!tbd: BC_StakeOut?
	
	if( Orders == OrdersFollow ) 
	{
		if( !LineOfSightTo( Controller(OrdersObject).Pawn ) )
			GS( AttackFallbackState );  //GS-tbd
	}
	else if( Orders == OrdersHold ) 
	{
		if( !LineOfSightTo( OrdersObject ) )
			GS( AttackFallbackState );  //GS-tbd
	}
	else if( Orders == OrdersDefend )
	{
		if( AmbushSpot != None )
		{
			if( !LineOfSightTo( AmbushSpot ) )
				GS( AttackFallbackState );  //GS-tbd
		}
		else if( !LineOfSightTo( OrdersObject ) )
			GS( AttackFallbackState );  //GS-tbd
	}
	*/

	WaitForLanding();
	if( CanSee( ControllerEnemy ) )
	{
		#debug DMAI( "AttackHuntState (CanSee) -- calling MaybeSetEnemy" );
		//!!mdf-tbd 08/26 just do a BC_EnemyRecovered? 
		// MaybeSetEnemy( ControllerEnemy );
		#debug   BehaviorController.Update( BC_EnemyRecovered, GetContext() );
		#release BehaviorController.Update( BC_EnemyRecovered );
	}
	PickDestination();

	if( Level.TimeSeconds - TimeSinceBeginState > 8.0 && !U2PBasic.bAlertedEnemyHunted )
	{
		U2PBasic.bAlertedEnemyHunted = true;
		U2P.AssetsHelperClass.static.HandleHuntEnemy( U2P );
	}

@ MoveSpecialLabel:
	if( TimeSinceTargetLastSeen( GetTarget() ) < U2PBasic.MaxHuntFireAtLastSeenTime )
	{
		Focus = None;
		FocalPoint = GetLastEnemySeenLocation();
	}
	else if( FaceTarget( 1 ) )
		Focus = ControllerEnemy;
	else
		Focus = MoveTarget;
		
	if( MoveTarget == None )
		MoveToPoint( Destination, , Focus );
	else
		MoveToActor( MoveTarget, TMT_None, , , Focus ); 
	
	Goto( HuntLabel );
	
@ AdjustPositionLabel:
	#debug DMAIA( "adjusting firing position  ControllerEnemy: " $ ControllerEnemy );
	NumMoveAttempts = 0;
@ AdjustPositionAgainLabel:
	// make sure enemy can be targeted from current position
	// hack: trace to center of enemy blocked doesn't mean can't shoot head etc.
	//!!tbd: call AdjustAim?
	//AddArrow( GetFireOffset( Pawn.Location, ControllerEnemy.Location ), ControllerEnemy.Location, ColorMagenta() );
	if( !Pawn.FastTrace( GetFireOffset( Pawn.Location, ControllerEnemy.Location ), ControllerEnemy.Location ) )
	{
		NumMoveAttempts++;
		if( NumMoveAttempts > 2 )
			Goto( GiveUpLabel );
			
		//DMTNS( "Adjusting firing position!" );

		//AddActor( Pawn, ColorCyan() );
		//AddActor( ControllerEnemy, ColorRed() );
		//AddArrow( Pawn.Location, Pawn.Location + 256.0*vector(Pawn.Rotation), ColorRed() );
		
		if( GetPossibleFiringLocation( Destination ) )
		{
			// move to within 2.0 units of the given point (instead of using default "reached destination" checks)
			// always face enemy at this point (we've acquired it and we're just fine-tuning our position)
			Focus = ControllerEnemy;
			FocalPoint = Focus.Location;
			MoveToPoint( Destination, 2.0, ControllerEnemy );
			
			// see if enemy targetable now
			Goto( AdjustPositionAgainLabel );
		}
	}

@ AdjustRotationLabel:
	#debug DMAIA( "adjusting firing rotation  ControllerEnemy: " $ ControllerEnemy );
	
	Focus = ControllerEnemy;
	FocalPoint = Focus.Location;
	FinishRotation( DefaultRotationThreshold );

@ GiveUpLabel:
	#debug DMAIA( "CanFire before BC_EnemyRecovered: " $ CanFire( true ) $ " Target: " $ GetTarget() );
	#debug   BehaviorController.Update( BC_EnemyRecovered, GetContext() );
	#release BehaviorController.Update( BC_EnemyRecovered );
} // AttackHuntState

/*-----------------------------------------------------------------------------
NOTE: some NPCs are allowed to enter this state without having any line of 
sight to their enemy, e.g. so they can leap over walls and such at their enemy
(making them somewhat "psychic").
*/

// just in case...
function NotifyLeapBegin();
function FakeNotifyLeapBeginTimer();

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

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

	function TryToDodge( vector DuckDir, bool bDuckLeft );
	function PlayRandomSound();

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

	function int GetLeapDamage( Pawn Other )
	{
		local vector ForwardLocation;
		local float DamageDistance;
		
		ForwardLocation = Pawn.Location + (Pawn.CollisionRadius + Other.CollisionRadius) * vector(Pawn.Rotation);
		ForwardLocation.Z = Other.Location.Z; // 2D check
		
		DamageDistance = VSize( Other.Location - ForwardLocation );
		
		return class'Util'.static.ScaleLinear( DamageDistance, 0.0, 512.0, U2PBasic.LeapMaxDamage, 0.0 );
	}
	
	//-------------------------------------------------------------------------

	function vector GetLeapMomentumTransfer( Pawn Other )
	{
		local vector ForwardLocation;
		local vector MomentumVector;
		local float MomentumDistance;
		local vector Result;

		ForwardLocation = Pawn.CollisionRadius * vector(Pawn.Rotation);
		MomentumVector = Pawn.CollisionRadius * Normal( Other.Location - Pawn.Location );

		MomentumDistance = VSize( MomentumVector - ForwardLocation );
		
		Result = Normal( MomentumVector ) * class'Util'.static.ScaleLinear( MomentumDistance, 0.0, Pawn.CollisionRadius, U2PBasic.LeapMaxMomentumTransfer, 0.0 );

		// Momentum into the ground probably won't move the victim
		if( Result.Z < 0 )
			Result.Z *= -0.5;

		return Result;
	}
	
	//-------------------------------------------------------------------------

	function eventBumpEnemy( Pawn Other )
	{
		//DMTNS( "BumpEnemy: " $ Other );
		if( Level.TimeSeconds - LastBumpDamageTime > 1.0 )
		{
			U2PBasic.HandleLeapImpactSound();
			Other.TakeDamage( GetLeapDamage( Other ), Pawn, Other.Location, GetLeapMomentumTransfer( Other ), class'DamageTypePhysical' );
			LastBumpDamageTime = Level.TimeSeconds;
		}
		
		if( Other.Health > 0 )
			Global.eventBumpEnemy( Other );
			
		if( FDecision( U2PBasic.LeapToMeleeOdds ) )
		{
			BehaviorController.SetBCEnabled( true );
			if( ValidEnemy( ControllerEnemy ) )
			{
				#debug   BehaviorController.Update( BC_MeleeRange, GetContext() );
				#release BehaviorController.Update( BC_MeleeRange );
			}
		}
		else
		{
			#debug   UpdateBehavior( true, GetContext() );
			#release UpdateBehavior( true );
		}
	}
	
	//-------------------------------------------------------------------------

	event bool NotifyHitWall( vector HitNormal, Actor Wall )
	{
		if( LeapLastHitWallNormal != HitNormal ||
			Level.TimeSeconds - LeapLastHitWallTime > LeapMinHitWallDelay )
		{
			U2P.LandedOnTexture( VSize(Pawn.Velocity) );
			LeapLastHitWallNormal = HitNormal;
			LeapLastHitWallTime = Level.TimeSeconds;
			return Global.NotifyHitWall( HitNormal, Wall );
		}
	}

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

	function bool CanFire( bool bTest ) { return false; } //NOTE: leap animation could always contain spawnshot notifies...
	
	//-------------------------------------------------------------------------

	function NotifyLeapBegin()
	{
		//DMTNS( "NotifyLeapBegin" );
		RemoveTimer( FakeNotifyLeapBeginTimerName );
		if( !bLeaping ) // in case 2nd notify comes in somehow
		{
			bLeaping = true;
			
			//DMTNS( "NotifyLeapBegin" );
			//U2P.DumpAgentInfo();
			
			U2P.AssetsHelperClass.static.HandleLeapSound( U2P );
			GotoLabel( StartLeapLabel );
		}
		else
		{
			DMTNS( "WARNING: got a 2nd LeapBegin notify while already leaping?!" );
			//U2P.DumpAgentInfo();
			//U2P.MakeErrorObvious( ET_Other );
		}
	}
	
	//-------------------------------------------------------------------------
	// Sent by Pawn when (if) it receives NotifyLeapBegin.

	function ReflectNotify( name NotifyName )
	{
		if( NotifyName == LeapBeginNotify )
		{
			if( !bLeapNotifyTimeSet )
				U2PBasic.LeapNotifyTime = Level.TimeSeconds + U2PBasic.LeapNotifyTime;

			NotifyLeapBegin();
		}
		else
		{
			Super.ReflectNotify( NotifyName );
		}
	}

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

	function FakeNotifyLeapBeginTimer()
	{
		//DMTNS( "WARNING: NPC leap animation doesn't have a LeapBegin notification: " $ Pawn );
		//U2P.MakeErrorObvious( ET_Other );
		//U2P.DumpAgentInfo();
		NotifyLeapBegin();
	}

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

	function DoLeapAttack( rotator LeapRotation, float LeapSpeed )
	{
		//AddArrow( Pawn.Location, LeapDestination, ColorYellow() );
		Pawn.Velocity = LeapSpeed * vector(LeapRotation);
		Pawn.SetPhysics( PHYS_Falling );
		//DMTNS( "Jump Velocity: " $ Pawn.Velocity $ " VSize: " $ VSize( Pawn.Velocity ) );
		//AddArrow( Pawn.Location, Pawn.Location + Pawn.Velocity, ColorGreen() );
		//Focus = ControllerEnemy;
		//Destination = ControllerEnemy.Location;
		Enable( Event_NotifyBump );
	}

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

	function AbortedLeap()
	{
		//DMTNS( "AbortedLeap" );
		NextLeapTime = Level.TimeSeconds + U2PBasic.LeapDelayFailure;
		#debug   UpdateBehavior( true, GetContext() );
		#release UpdateBehavior( true );
	}

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

	function FinishedLeap()
	{
		//DMTNS( "FinishedLeap"  );
		#debug   UpdateBehavior( true, GetContext() );
		#release UpdateBehavior( true );
	}
	
	//-------------------------------------------------------------------------
		
	event BeginState()
	{
		Disable( Event_NotifyBump );
		//DMTNS( "BeginState Physics: " $ EnumStr( enum'EPhysics', Pawn.Physics ) $ " Velocity: " $ Pawn.Velocity $ " Health: " $ Pawn.Health );
		#debug   StopFiring( 0.5, SFI_Behavior, GetContext() );
		#release StopFiring( 0.5, SFI_Behavior );
		BehaviorController.SetBCEnabled( false );
		Pawn.bFallingHitWallNotifications = true;
	}

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

	event EndState()
	{
		//if( Pawn != None )
		//	DMTNS( "  Physics: " $ EnumStr( enum'EPhysics', Pawn.Physics ) $ " Velocity: " $ Pawn.Velocity $ " Health: " $ Pawn.Health );
		CheckBehaviorEnabled();
		BCStartFiring();
		Enable( Event_NotifyBump );
		EnableRotation( true );
		RemoveTimer( FakeNotifyLeapBeginTimerName ); //mdf-tbr:
		UnLockAnimationController();
		bLeaping = false;
		if( Pawn != None )
			Pawn.bFallingHitWallNotifications = Pawn.default.bFallingHitWallNotifications;
	}
	
	//-------------------------------------------------------------------------
	
@ BeginLabel:
	//DMTNS( "begin label" );
	//StopMovement( true, true );
	Focus = ControllerEnemy;
	//DMTNS( "call FinishRotation" );
	FinishRotation( DefaultRotationThreshold );
		
	// only get the leap parameters once the NPC is facing the enemy or could be *way* off
	if( !GetLeapParameters( PendingLeapRotation, PendingLeapSpeed ) )
		AbortedLeap();

	//DMTNS( "final turning delay" );
	
	// do final turning + delay			
	StopMovement( true, true );
	StartTurnTime = Level.TimeSeconds;
	Focus = None;
	FocalPoint = Pawn.Location + 512.0*vector(PendingLeapRotation);
	FinishRotation( DefaultRotationThreshold );
	Sleep( U2PBasic.LeapDelayPreJump - (Level.TimeSeconds - StartTurnTime) );
	
	//DMTNS( "start leap animation" );
	bLeaping = false;
	if( U2P.AnimationController.SpecialAnimationLeap() == 0.0 )
	{
		DMTNS( "WARNING: NPC doesn't have a leap animation AnimSequence: " $ Pawn.AnimSequence);
		AbortedLeap();
	}
	
	// the first notify will be used to "refine" the LeapNotifyTime for subsequent jumps
	if( !bLeapNotifyTimeSet )
		U2PBasic.LeapNotifyTime = -Level.TimeSeconds;
			
	// in case notify not present...
	//AddTimer( FakeNotifyLeapBeginTimerName, 2.0, false );
	AddTimer( FakeNotifyLeapBeginTimerName, 1.0, false );
	//AddTimer( FakeNotifyLeapBeginTimerName, 0.25, false );

	//DMTNS( "wait for LeapBegin notification" );
	Stop; // wait for leap begin notification
	
@ StartLeapLabel:
	EnableRotation( false );
	//DMTNS( "leaping" );
	DoLeapAttack( PendingLeapRotation, PendingLeapSpeed );
	NextLeapTime = Level.TimeSeconds + U2PBasic.LeapDelaySuccess;
	//DMTNS( "wait for landing" );
	WaitForLanding();
	//DMTNS( "landed" );

	U2PBasic.HandleLeapLandSound(); // sounds in addition to landing thump

	//DMTNS( "landed, not moving for a bit" );	
	StopMovement( true, true );
	Sleep( U2PBasic.LeapDelayLand );
	EnableRotation( true );
	
	// turn to enemy (while stationary) before leaving state?
	if( U2PBasic.bTurnToEnemyAfterLeap )
	{
		Focus = ControllerEnemy;
		//DMTNS( "calling FinishRotation" );
		FinishRotation( DefaultRotationThreshold );
		//DMTNS( "called FinishRotation" );
	}
	
	//DMTNS( "FinishedLeap" );
	FinishedLeap();
} // AttackLeapState

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

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

	function PlayRandomSound();

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

	event EnemyNotInMeleeRange()
	{
		//DMTNS( "EnemyNotInMeleeRange" );
		if( bMeleeDamagedTarget )
		{
			#debug   BehaviorController.Update( BC_MeleeRangeLostHit, GetContext() );
			#release BehaviorController.Update( BC_MeleeRangeLostHit );
		}
		else
		{
			#debug   BehaviorController.Update( BC_MeleeRangeLost, GetContext() );
			#release BehaviorController.Update( BC_MeleeRangeLost );
		}
	}

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

	function NotifyMeleeDamagedEnemy( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		// update behavior once animation ends
		//DMTNS( "NotifyMeleeDamagedEnemy" );
		bMeleeDamagedTarget = true;
	}

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

	function bool CanFire( bool bTest ) { return false; }
	function bool CanDodge( optional bool bIgnoreFalling ) { return false; }
	
	//-------------------------------------------------------------------------

	function eventEnemyNotVisible()
	{
		#debug   BehaviorController.Update( BC_EnemyNotVisible, GetContext() );
		#release BehaviorController.Update( BC_EnemyNotVisible );
	}

	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		//DMTNS( "BeginState!" );
		#debug   StopFiring( 0.0, SFI_Behavior, GetContext() );
		#release StopFiring( 0.0, SFI_Behavior );
		if( U2PBasic.MeleeSpeed > 0.0 )
		{
			Pawn.Velocity =  U2PBasic.MeleeSpeed * Normal(Pawn.Velocity) * Pawn.default.GroundSpeed;
			Pawn.DesiredSpeed = U2PBasic.MeleeSpeed;
		}
		if( StationaryPawn(ControllerEnemy) != None )
			Enable( Event_SeeEnemy );
		else
			Disable( Event_SeeEnemy );
	}
	
	//-------------------------------------------------------------------------
		
	event EndState()
	{
		//DMTNS( "EndState!" );
		
		MeleeAttackAbort();
		BCBlockFiring( 0.5, false ); // fire no sooner than 0.5 secs from now?
		//DMTNS( "EndState" );
		if( U2PBasic != None && U2PBasic.MeleeSpeed > 0.0 )
			U2PBasic.DesiredSpeed = U2PBasic.default.DesiredSpeed;
		bMeleeDamagedTarget = false;
	}

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

@ BeginLabel:
	Pawn.DesiredRotation = Rotator( ControllerEnemy.Location - Location );

@ FaceTargetLabel:
	//NOTE: if we just returned from MoveToXXX acceleration is now 0,0,0

	if( IsMobile() && U2PBasic.bHasMovingMeleeAttack )
	{
		#debug DMAIA( "moving melee attack -- matching enemy acceleration" );
		UpdateAcceleration( ControllerEnemy, U2PBasic.MeleeAccelerationChangeLimit, U2PBasic.MeleeAccelRate, U2PBasic.MeleeSpeed );
	}
	else
	{
		#debug DMAIA( "stationary melee attack -- stopping" );
		StopMovement( true, false );
	}

	if( NeedToTurn( ControllerEnemy.Location, NeedToTurnAngleCos ) )
	{
		Focus = GetTarget();
		FinishRotation( DefaultRotationThreshold );
	}

@ ReadyToAttackLabel:
	Pawn.DesiredRotation = Rotator( ControllerEnemy.Location - Pawn.Location );

	if( FDecision( U2PBasic.ImpaleToMeleeOdds ) && CanImpale( ControllerEnemy ) )
	{
		#debug DMAIA( "calling ImpaleAttack from MeleeAttackState" );
		ImpaleAttack();
		Goto( AttackDoneLabel );
	}
	else
	{
		#debug DMAIA( "calling MeleeAttack from MeleeAttackState" );
		MeleeAttack( 0 ); // attack!
		
		#debug DMAIA( "setting focus and calling FinishRotation, Target:" $ GetTarget() );
		Focus = GetTarget();
		FinishRotation( DefaultRotationThreshold ); // note: this latent yield guarantees we won't immediately loop again (infinite recursion)
		Sleep( MeleeEndTime - Level.TimeSeconds );
		#debug DMAIA( "melee attack done  bMeleeDamagedTarget: " $ bMeleeDamagedTarget );
		//DMTNS( "melee attack done  bMeleeDamagedTarget: " $ bMeleeDamagedTarget );
		if( bMeleeDamagedTarget )
		{
			#debug   BehaviorController.Update( BC_MeleeUpdateHit, GetContext() );
			#release BehaviorController.Update( BC_MeleeUpdateHit );
		}
		else
		{
			#debug   BehaviorController.Update( BC_MeleeUpdate, GetContext() );
			#release BehaviorController.Update( BC_MeleeUpdate );
		}
			
		Goto( FaceTargetLabel );
	}

@ AttackDoneLabel:
	Stop;
} // AttackMeleeState

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

state @ AttackMoveToCoverBaseState extends @ AttackFallbackState
{
	//ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise; // only worry about the current threat?
    ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise; // only worry about the current threat?
	function eventBumpEnemy( Pawn Other );

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

	function SetCurrentCoverSpot( CoverSpot NewCoverSpot )
	{
		AssignCoverSpot( NewCoverSpot );
		LastSpecialDestinationCheck = Level.TimeSeconds;	
	}
	
	//-------------------------------------------------------------------------

	function bool VerifyCoverSpot()
	{
		local bool bResult;

		if( CurrentCoverSpot == None )
		{
			#debug DMAI( "VerifyCoverSpot - CurrentCoverSpot not set, returning false" );
			bResult = false;
		}
		else if( CurrentCoverSpot.bDeleteMe )
		{
			#debug DMAI( "VerifyCoverSpot - CurrentCoverSpot was deleted, returning false" );
			bResult = false;
		}
		else if( (Level.TimeSeconds - LastSpecialDestinationCheck) < VerifyCoverRate )
		{
			#debug DMAI( "VerifyCoverSpot - was checked " $ (Level.TimeSeconds - LastSpecialDestinationCheck) $ " secs ago - returning true" );
			bResult = true;
		}
		else
		{
			#debug DMAI( "VerifyCoverSpot calling ValidCoverActor (somewhat expensive)" );
			bResult = ValidCoverActor( CurrentCoverSpot, ControllerEnemy, false );
			#debug DMAI( "  bResult: " $ bResult );
			LastSpecialDestinationCheck = Level.TimeSeconds;	
		}

		//DMTNS( "VerifyCoverSpot returning: " $ bResult );
		return bResult;
	}

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

	function TryToFindCover()
	{
		DMTNS( "WARNING: TryToFindCover needs to be overridden in a derived state!" );
	}
	
	//-------------------------------------------------------------------------

	function CoverSpot FindCoverActor( float MaxDistance, float	CosMinAngle, float CosMaxAngle, bool bIncludePathable )
	{
		local CoverSpot BestSpot;

		BestSpot = FindCoverSpot( ControllerEnemy, 0.0, MaxDistance, -2048.0, 2048.0, CosMinAngle, CosMaxAngle, bIncludePathable );
		if( BestSpot != None )
		{
			#debugbegin
			if( CurrentCoverSpot != None && VSize(CurrentCoverSpot.Location - BestSpot.Location) ~= 0.0 )
				DMTNS( "Warning: reselected same spot?!" );
			#debugend

			SetCurrentCoverSpot( BestSpot );
		}

		return BestSpot;
	}

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

	function bool ShouldClearSpecialColliders()
	{
		return Global.ShouldClearSpecialColliders(); // so won't try to reach cover through XMP items
	}

	//-------------------------------------------------------------------------
	// Head towards a good cover location and stick with it as long as the 
	// (any?) enemy can't see it. We can assume that there is LOS to the enemy 
	// (otherwise eventEnemyNotVisible should take us out of this state).

	function PickDestination()
	{
		local Controller C;
		
		/*!!mdf-tbd:
		// shook off enemy?
		if( GetTimeSinceEnemyLastSeen() > 3 ) //9
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		*/
		
		if( !ValidEnemy( ControllerEnemy ) )
		{
			UpdateEnemy();
		}
		else
		{
			#debug DMAI( "CurrentCoverSpot IN: " $ CurrentCoverSpot );
			if( !ControllerEnemy.LineOfSightTo( Pawn ) ) // can this ever happen without getting eventEnemyNotVisible first?
			{
				// current location / stance is safe
				#debug DMAI( "current location not visible from enemy" );
				MoveTarget = Pawn;
				//!!mdf-tbd: we *don't* want to clear the CurrentCoverSpot here since
				//we pbly want to go back to it (only clear when its invalid or when
				//the meta state changes)
				//ClearCoverSpot();
			}
			else
			{
				if( !VerifyCoverSpot() )
				{
					#debug DMAI( "CurrentCoverSpot is invalid or not set - calling TryToFindCoverSpot" );
					ClearCoverSpot();
					TryToFindCover();
					#debug DMAI( "TryToFindCover returned: " $ CurrentCoverSpot );
				}
				else
				{
					#debug DMAI( "Keeping current cover spot: " $ CurrentCoverSpot );
				}

				//DMTNS( "CurrentCoverSpot: " $ CurrentCoverSpot );
	
				if( CurrentCoverSpot != None )
				{
					// have to keep making sure whether directly reachable or pathing required
					//!!! GMoveType = GetMoveTarget( CurrentCoverSpot );
	
					GetPathToActor( CurrentCoverSpot, MoveTarget, true );
					
					/* mdf-tbd: in situations with lots of NPCs, this happens on a regular basis.
					   From what I can tell, this may be happening in cases where the NPC should
					   be able to build a path but I'm not sure and a) this is happening rarely
					   enough that I don't want to spend time on this now and b) "fixing" this
					   might give undesirable results, since this seems to happen when the cover
					   spot is blocked by another NPC and the only path to it might be an
					   undesireable one (e.g. takes NPC way out of his way and possibly towards
					   his enemy. Just let the MoveNoDestLabel code handle this situation for
					   now and NPC will eventually try something else.
					if( MoveTarget == None )
					{
						//DMTNS( "Warning: can't build path to cover spot: " $ CurrentCoverSpot );
						//AddActor( Pawn, ColorCyan() );
						//AddActor( CurrentCoverSpot, ColorRed() );
						//AddArrow( Pawn.Location, CurrentCoverSpot.Location, ColorRed() );
						//for( C=Level.ControllerList; C!= None; C = C.nextController )
						//	AddActor( C.Pawn, ColorBlue() );
							
						//hack: try again and enable debug info (requires that FindPathToActor looks for this hack)
						//Pawn.CrouchHeight = 31.0;
						//FindPathToActor( CurrentCoverSpot, MoveTarget , , , false );
						//Pawn.CrouchHeight = Pawn.default.CrouchHeight;
					}
					*/
				}
				else
				{
					MoveTarget = None;
				}
			}
		}
	}
	
	//-------------------------------------------------------------------------

	function Actor GetFinalDestinationActor()
	{
		return CurrentCoverSpot;
	}
	
	//-------------------------------------------------------------------------

	function float GetReachedDestinationDistance()
	{
		return 1.0; // need to get real close to cover spot
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		Super.BeginState();
		
		if( CurrentCoverSpot != None && VSize2D(Pawn.Location - CurrentCoverSpot.Location) > 512 )
		{
			//!!mdf-tbd: does this make sense - is there a better way?
			// the idea here is that generally NPC's will step a short distance
			// to re-acquire their enemy but if they have to move further to
			// hunt the enemy then we should clear the old cover spot or else
			// they will always tend to go back to it
			ClearCoverSpot();
		}
	}	

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

@ MoveNoDestLabel:
	#debug DMAIA( "setting focus and calling FinishRotation, Focus:" $ GetTarget() );
	Focus = GetTarget();
	if( Focus != None )
	{
		StopMovement( true, false );
		if( NeedToTurn( Focus.Location, NeedToTurnAngleCos ) )
			FinishRotation( DefaultRotationThreshold );
		else
			Sleep( 0.5 );
	}
	#debug DMAIA( "calling BC_CoverNotFound" );
	#debug   BehaviorController.Update( BC_CoverNotFound, GetContext() );
	#release BehaviorController.Update( BC_CoverNotFound );
	Goto( MovePickDestLabel ); // really just a fallback in case Update does nothing
} // AttackMoveToCoverBaseState

//-----------------------------------------------------------------------------
// State for "combat" use of cover when trying to get away from an enemy while
// attacking that enemy. Generally maintains focus on enemy (so can fire).

state @ AttackMoveToCoverCombatState extends @ AttackMoveToCoverBaseState
{
    ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise; // only worry about the current threat?
    //ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise; // only worry about the current threat?

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

	function eventEnemyNotVisible()
	{
		local Pawn TempPawn;

		//DMTNS( "eventEnemyNotVisible" );
		//AddActor( Pawn, ColorGreen() );
		// current enemy no longer visible
		if( OldControllerEnemy != None && LineOfSightTo( OldControllerEnemy ) )
		{
			// old enemy visible - swap with current enemy
			TempPawn = OldControllerEnemy;
			OldControllerEnemy = ControllerEnemy;
			#debug   SetControllerEnemy( TempPawn, GetContext() );
			#release SetControllerEnemy( TempPawn );
		}
		else 
		{
			#debug   BehaviorController.Update( BC_CoverReachedCover, GetContext() );
			#release BehaviorController.Update( BC_CoverReachedCover );
		}
	}

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

	function ETacticalMoveType GetTacticalMoveType()
	{
		return TMT_None; // otherwise bumps into walls & such plus "use of cover" should be the advanced tactic in the first place
	}

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

	function bool FaceTarget( float F )
	{
		return Pawn.bCanStrafe; // always face target when using cover (i.e. whether moving towards enemy or cover spot)
	}

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

	function TryToFindCover()
	{
		//DMTNS( "picking new cover spot" );
		#debug DMAIM( "looking for a cover spot within " $ U2PBasic.MaxUseCoverSearchDistance );
/*
		better to just allow pathable
		if( FindCoverActor( U2PBasic.MaxUseCoverSearchDistance, 0.0, -1.0, false ) != None )
			return;

		if( FindCoverActor( U2PBasic.MaxUseCoverSearchDistance, 0.707, 0.0, false ) != None)
			return;
*/

		// is direction meaningless? better to go by min distance?
		// could need to force shorter move time so MoveToActor returns every 0.25 secs or so instead of 1.2
		// at least 90 degrees and at most 180 (directly away -- to allow for pathing, not final destination)
//		if( FindCoverActor( U2PBasic.MaxUseCoverSearchDistance, 0.0, -1.0, true ) != None)
			//return;

//		FindCoverActor( U2PBasic.MaxUseCoverSearchDistance, 0.707, 0.0, true );
		FindCoverActor( U2PBasic.MaxUseCoverSearchDistance, 1.0, -1.0, true );
	}

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

	function PickDestination()
	{
		if( Pawn != None )
		{
			if( StationaryPawn(ControllerEnemy) != None && !StationaryPawn(ControllerEnemy).bHasAttack )
			{
				MoveTarget = None;
				#debug   BehaviorController.Update( BC_CoverNotNeeded, GetContext() );
				#release BehaviorController.Update( BC_CoverNotNeeded );
			}
			else
			{
				Super.PickDestination();
			}
		}	
	}
} // AttackMoveToCoverCombatState

//-----------------------------------------------------------------------------
// State for "fearful" use of cover when trying to get away from an enemy 
// without trying to attack that enemy. Generally maintains focus on 
// destination rather than enemy.

state @ AttackMoveToCoverFleeState extends @ AttackMoveToCoverBaseState
{
	//ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise; // only worry about the current threat?
    ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise; // only worry about the current threat?

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

	function bool FaceTarget( float F )
	{
		return false;
	}

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

	function TryToFindCover()
	{
		//DMTNS( "picking new cover spot" );
		if( FindCoverActor( U2PBasic.MaxFleeSearchDistance, 0.0, -1.0, true ) != None )
			return;

		if( FindCoverActor( U2PBasic.MaxFleeSearchDistance, 0.707, 0.0, true ) != None )
			return;

		if( FindCoverActor( U2PBasic.MaxFleeSearchDistance, 0.930, 0.707, true ) != None )
			return;
			
		FindCoverActor( U2PBasic.MaxFleeSearchDistance, 1.0, -1.0, true );
	}
} // AttackMoveToCoverFleeState

//-----------------------------------------------------------------------------
//!!mdf-tbd: mainly just use hunting behavior initially. We will probably want
// to track where the NPC came from when going to the cover spot so we can move
// between there and the cover spot.

state @ AttackRecoverEnemyState extends @ AttackHuntState
{
	ignores EnemyNotVisible; 

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

	function bool FaceTarget( float F )
	{
		local vector MoveLocation;
		local bool bResult;

		if( !Pawn.bCanStrafe )
			return false;
			
		// always face target when coming out of cover and heading towards
		// enemy's last seen or detected position as long as we started
		// this state fairly recently (don't want NPC looking at hidden
		// enemy all the time -- player should be able to get behind NPC).
		
		if( (Level.TimeSeconds - TimeSinceBeginState) < 3.0 )
		{
			/* doesn't work currently because PickDestination (in AttackHunt)
			   generally sends NPC directly towards enemy (cheats)
			if( MoveTarget != None )
				MoveLocation = MoveTarget.Location;
			else
				MoveLocation = Destination;
				
			bResult = ( VSize( MoveLocation - GetLastEnemySeenLocation() < 100.0 || 
					    VSize( MoveLocation - GetLastEnemyDetectedLocation() ) < 100.0 );
			*/
			
			bResult = true;
		}
		
		//DMTNS( "FaceTarget returning " $ bResult );
		return bResult;
	}

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

	function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )
	{
		local bool bResult;

		bResult = Global.MaybeSetEnemy( NewEnemy, bAlertingOthers );

		if( bResult )
			HandleRecoveredEnemy();

		return bResult;
	} 
*/	

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

	function BlockFiring()
	{
		// make sure NPC can't fire for a bit
		BCBlockFiring( U2PBasic.MinAlertAcquisitionDelay, false );
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		Super.BeginState();
		TimeSinceBeginState = Level.TimeSeconds;
	}
} // AttackRecoverEnemyState

/*-----------------------------------------------------------------------------
Retreating for an NPC is going toward an item while still engaged with an enemy,
but fearing that enemy (so no desire to remain engaged).
*/

state @ AttackRetreatState extends @ MoveToGoalWithEnemyState
{
	ignores EnemyNotVisible, EnemyInLeapRange, EnemyInMeleeRange;

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

	event MayFall()
	{
		if( IsFacingTarget( ControllerEnemy, CosMinFacingTargetAngle ) ) // MoveTarget is enemy, not destination
			Pawn.bCanJump = TestCanJump();
	}

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

	function ShotFiredNotification( Pawn Shooter, vector FireDir, class<Projectile> ProjectileClass, float ProjSpeed )
	{	
		if( IsFacingTarget( ControllerEnemy, CosMinFacingTargetAngle ) && FRand() < 0.4 ) 
			return;

		Global.ShotFiredNotification( Shooter, FireDir, ProjectileClass, ProjSpeed );
	}

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

	function eventSeeEnemy( Pawn Seen )
	{
		if( Seen != ControllerEnemy && MaybeSetEnemy( Seen ) )
			Pawn.MakeNoise( 1.0 );
	}

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

	singular function eventHearNoiseThreat( float Loudness, Actor NoiseMaker )
	{
		if( ( NoiseMaker.Instigator == ControllerEnemy ) || LineOfSightTo( ControllerEnemy ) )
			return;

		#debug DMAI( "eventHearNoiseThreat -- calling MaybeSetEnemy" );
		if( MaybeSetEnemy( NoiseMaker.Instigator ) )
		{
			Pawn.MakeNoise( 1.0 );
			#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
			#release BehaviorController.Update( BC_AttackUpdate );
		}
	}

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

	function bool StopFearingEnemy()
	{
		return ( GetTimeSinceEnemyLastDetected() > 12 );
	}

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

	function bool CanFire( bool bTest ) { return ( U2PBasic.bHasMovingRangedAttack && Global.CanFire( bTest ) ); }

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

	function bool FindRetreatDestination()
	{
		return false; // mdt-tbd: add fleeing for NPCs (pick non-inventory destination away from enemy)?
	}

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

	function PickDestination()
	{
		// do I still fear my enemy?
		if( StopFearingEnemy() )
		{
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		}
		
		if( ControllerEnemy == None )
		{
			#debug   BehaviorController.Update( BC_UpdateInactive, GetContext() );
			#release BehaviorController.Update( BC_UpdateInactive );
		}
		else if( GetReactionToEnemy( ControllerEnemy ) > REACTION_Fear )
		{
			#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
			#release BehaviorController.Update( BC_AttackUpdate );
		}
		else if( !FindRetreatDestination() )
		{
			#debug DMAI( " give up retreat" );
	
			// if nothing, then tactical move
			if( LineOfSightTo( ControllerEnemy ) )
			{
				LastInvFind = Level.TimeSeconds;
				bKamikaze = true;
				GotoState( AttackTacticalMoveState, DontCloseLabel );
			}
			else
			{
				#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
				#release BehaviorController.Update( BC_AttackUpdate );
			}
		}
	}

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

	function ChangeDestination()
	{
		local Actor OldTarget;
		local Actor Path;
		
		OldTarget = Home;
		PickDestination();
		if( Home == OldTarget )
		{
			bKamikaze = true;
			//log( "same old target" );
			GotoState( AttackTacticalMoveState, TacticalTickLabel );  //GS-tbd
		}
		else
		{
			GetPathToActor( Home, Path, true );
			if( Path == None )
			{
				//log( "no new target" );
				bKamikaze = true;
				GotoState( AttackTacticalMoveState, TacticalTickLabel );  //GS-tbd
			}
			else 
			{
				MoveTarget = Path;
				Destination = Path.Location;
			}
		}
	}
	
	//-------------------------------------------------------------------------

	function eventBumpEnemy( Pawn Other )
	{
		if( Other == ControllerEnemy && ((Other.Location - Pawn.Location) dot Pawn.Velocity) > 0 )
			bKamikaze = true;
		
		#debug DMAI( "eventBumpEnemy -- calling MaybeSetEnemy" );
		if( MaybeSetEnemy( Other ) && ControllerEnemy == Other && IsPreparedToFire( true ) )
		{
			GotoState( AttackStationaryState );  //GS-tbd
		}
	}
	
	//-------------------------------------------------------------------------

	function ReachedHome()
	{
		if( LineOfSightTo( ControllerEnemy ) )
			ChangeDestination();
		else
		{
			bKamikaze = true;
			#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
			#release BehaviorController.Update( BC_AttackUpdate );
		}
	}

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

	function PickNextSpot()
	{
		local Actor Path;

		if( Home == None )
		{
			PickDestination();
			if( Home == None )
				return;
		}
		//log( "find retreat spot" );
		if( AtDestinationActor( Home ) )
		{
			ReachedHome();
		}
		else
		{
			GetPathToActor( Home, Path, true );
			if( Path == None )
			{
				ChangeDestination();
			}
			else
			{
				MoveTarget = Path;
				Destination = Path.Location;
			}
		}
	}

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

@ BeginLabel:
@ MovePickDestLabel:
	WaitForLanding();
	PickDestination();

@ MoveActiveLabel:
	if( MoveTarget == None )
	{
		Sleep( 0.0 );
		Goto( MovePickDestLabel );
	}

@ FaceTargetLabel:

	if( FaceTarget( 2 ) )
		MoveToActor( MoveTarget, GetTacticalMoveType(), , , ControllerEnemy );
	else
		MoveToActor( MoveTarget, GetTacticalMoveType() );
	Goto( MovePickDestLabel );
} // AttackRetreatState

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

state @ AttackStakeOutState
{
	ignores EnemyNotVisible; 

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

	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			bFrustrated = true;
			Global.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
		}
	}

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

	/*!!-mdf-tbd: I'm not sure when/if we want to do this -- currently an NPC
	  that is in AttackStakeOut (or a derived state) will immediately go out
	  of that state if, e.g. the enemy fires his weapon (which calls MakeNoise).
	  For now it seems that we should only set the enemy if there is nothing
	  between the instigator and the NPC? */
	  
	singular function eventHearNoiseThreat( float Loudness, Actor NoiseMaker )
	{
		#debug DMAI( "eventHearNoiseThreat -- calling MaybeSetEnemy" );
		if( Pawn.FastTrace( Pawn.Location, NoiseMaker.Instigator.Location ) )
		{
			if( MaybeSetEnemy( NoiseMaker.Instigator ) )
				EnemyDetected( ControllerEnemy.Location ); 
		}
	}
	
	//-------------------------------------------------------------------------

	function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )
	{
		if( Global.MaybeSetEnemy( NewEnemy, bAlertingOthers ) )
		{
			Focus = ControllerEnemy;
			#debug   BehaviorController.Update( BC_EnemyAcquired, GetContext() );
			#release BehaviorController.Update( BC_EnemyAcquired );
			return true;
		}
		return false;
	} 
	
	//-------------------------------------------------------------------------

	function bool ContinueStakeOut()
	{
		local float StrengthDelta;
		local bool bResult;

		if( ControllerEnemy != None )
		{
			StrengthDelta = RelativeStrength( ControllerEnemy );
			bResult = ( (VSize( ControllerEnemy.Location - Pawn.Location ) <= 300 + (FRand() * StrengthDelta - U2PBasic.CombatStyle)*350) &&
						(Level.TimeSeconds - GetLastEnemyDetectedTime() <= 2.5 + FMax( -1, 3*(FRand() + 2*(StrengthDelta - U2PBasic.CombatStyle)))) &&
						CanStakeOut() );
		}

		return bResult;
	}

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

	event BeginState()
	{
		StopMovement( true, false );
		//DM( "BeginState StakeOut bClearShot: " $ bClearShot );
		Pawn.bCanJump = false;
		SetAlertness( 0.5 );
		RealLastDetectedLocation = GetLastEnemyDetectedLocation();
		if( GetTimeSinceEnemyLastSeen() > 5.0 || (GetTimeSinceEnemyLastDetected() > 6.0 && FRand() < 0.5) )
			FindNewStakeOutDir( ControllerEnemy );
	}

	//-------------------------------------------------------------------------
	
	event EndState()
	{
		SetLastEnemyDetectedLocation( RealLastDetectedLocation );
		RestoreAlertness();
		if( Pawn != None )
			Pawn.bCanJump = (Pawn.JumpZ > 0);
	}

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

@ BeginLabel:
	if( AmbushSpot == None )
		bSniping = false;

	if( bSniping && ( VSize( Pawn.Location - AmbushSpot.Location ) > 3 * Pawn.CollisionRadius ) )
	{
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		OldControllerEnemy = None;
		#debug   BehaviorController.Update( BC_UpdateInactive, GetContext() );
		#release BehaviorController.Update( BC_UpdateInactive );
	}
	StopMovement( true, false );
	Focus = None;
	FocalPoint = GetLastEnemyDetectedLocation();
	FinishRotation( DefaultRotationThreshold );
	if( !ValidEnemy( ControllerEnemy ) )
		UpdateEnemy();

	Sleep( 1 + FRand() );
	FindSpecialAttraction();

	if( ContinueStakeOut() )
	{
		if( bSniping && AmbushSpot != None )
			EnemyDetected( Pawn.Location + AmbushSpot.LookDir );
		else if( FRand() < 0.3 || !Pawn.FastTrace( GetLastEnemyDetectedLocation() + vect( 0, 0, 0.9 ) * ControllerEnemy.CollisionHeight, Pawn.Location + vect( 0, 0, 0.8 ) * Pawn.CollisionHeight ) )
			FindNewStakeOutDir( ControllerEnemy );
		Goto( BeginLabel );
	}
	else
	{
		if( bSniping )
		{
			#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
			#release BehaviorController.Update( BC_AttackUpdate );
		}
		
		BlockedPath = None;	
		#debug   BehaviorController.Update( BC_StakeOutEnd, GetContext() );
		#release BehaviorController.Update( BC_StakeOutEnd );
	}
} // AttackStakeOutState

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

state @ AttackStakeOutCoverState extends @ AttackStakeOutState
{
	ignores EnemyNotVisible; 

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

	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Super.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );

		//DMTNS( "eventTookDamage Instigator" $ Instigator );
		//!!mdf-tbd: react to friendly fire also?
		if( Instigator != None && !Pawn.SameTeam( Instigator ) )
		{
			//DMTNS( "adding a FearLocation" );
			
			// discourage NPC from staying at this location when re-selecting cover		
			AddFearLocation( Pawn.Location, 5.0 );
			#debug   BehaviorController.Update( BC_CoverLeavingCover, GetContext() );
			#release BehaviorController.Update( BC_CoverLeavingCover );
		}
	}
	
	//-------------------------------------------------------------------------

	function bool ContinueStakeOut()
	{
		return ( Pawn != None); // let BC determine time to stay in stake out
	}
}

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

function FreezeNPCHackTimer()
{
	Pawn.GroundSpeed = Pawn.default.GroundSpeed;
}

//-----------------------------------------------------------------------------
// While in this state, NPC is stationary and (usually) firing at target.

state @ AttackStationaryState
{
	// 2002.11.11 added SeeEnemy -- we have an enemy, we can assume its in sight, no?
	//  and without this, additional SeeEnemy events can cause the behavior set up
	//  for this state (e.g. crouch for at least 1 sec) to get spammed?
	ignores HearNoise, NotifyBump, SeeFriend, SeeOther, SeeAlertFriend;

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

	event EnemyRangeTransition( float Distance )
	{
		#debug DMAIA( "EnemyRangeTransition calling CheckEnemyDistance: " $ Distance );
		CheckEnemyDistance( Distance );
	}

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

	function SharedTimerEvent()
	{
		#debug DMAIA( "SharedTimerEvent" );
		UpdateEnemy();
	}
	
	//-------------------------------------------------------------------------

	function eventSeeEnemy( Pawn Seen )
	{
		#debug   SetControllerEnemy( Seen, GetContext() ); //!!mdf-tbd: directly setting enemy?
		#release SetControllerEnemy( Seen ); //!!mdf-tbd: directly setting enemy?
		Disable( Event_SeeEnemy );
		Enable( Event_EnemyNotVisible );
		SetSharedTimer( 0.0, false );
		BCStartFiring();
	}
	
	//-------------------------------------------------------------------------

	function eventEnemyNotVisible()
	{
		if( IsMobile() || HasScript() )
		{
			#debug   BehaviorController.Update( BC_EnemyNotVisible, GetContext() );
			#release BehaviorController.Update( BC_EnemyNotVisible );
		}
		else
		{
			// not mobile (and not scripted) -- start a timer and UpdateEnemy if enemy not seen within X secs 
			Disable( Event_EnemyNotVisible );
			Enable( Event_SeeEnemy );
			SetSharedTimer( 30.0, false ); // may as well track enemy for a long time (stay alert)
		}
	}

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

	function bool CanUseStillAnimations() { return true; }

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

	function KeepAttacking()
	{
		if( !ValidEnemy( ControllerEnemy ) )
			UpdateEnemy();
	}

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

	function InitializeState()
	{
		//2002.12.08 mdf: don't change stance if last aim trace hit a friendly
		//since we'll probably have to move soon?
		if( !bLastAimLocationHitFriendly )
		{
			if( SelectStance( false ) )
			{
				#debug DMAIA( "stance changed" );
				GotoLabel( StanceChangeDelayLabel );
			}
		}
	}

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

	function bool IgnoreTargetRange() { return bAcceptedState; }
	
	//-------------------------------------------------------------------------
	// Try to find a location to the right or left of the NPC relative to the
	// enemy from which the NPC is likely to be able to fire. If one is found
	// sets Destination to that location and returns true. Sets bBlocked to 1
	// if move was blocked (so caller shouldn't bother trying longer moves 
	// in that direction).
	
	function bool SetValidFiringLocation( bool bTryRight, float Distance, out byte bBlocked )
	{
		local Actor TargetActor;
		local vector RightAngleDirection;
		local vector TargetActorLocation, TargetDestination, BaseLocation;
		local Actor HitActor;
		local vector HitNormal, HitLocation;
		
		TargetActor = GetTarget();
		TargetActorLocation = TargetActor.Location;
		
		RightAngleDirection = Normal( (TargetActorLocation - Pawn.Location) cross vect(0,0,1) );

		if( bTryRight )
			TargetDestination  = Pawn.Location + Distance *  RightAngleDirection;
		else
			TargetDestination  = Pawn.Location + Distance * -RightAngleDirection;

		class'UtilGame'.static.AdjustDestinationForPhysics( Pawn, TargetDestination );

		if( !Pawn.FitActorAt( TargetDestination ) )
		{
			bBlocked = 1;
			return false;
		}

		//AddArrow( Pawn.Location, TargetDestination, ColorOrange() );
		
		if( !PointReachable( TargetDestination ) )
		{
			bBlocked = 1;
			return false;
		}

		//2002.11.23 !!mdf-tbd: check for geometry under NPC so won't adjust partially/mostly off ledges
		BaseLocation = Pawn.Location - Pawn.CollisionHeight*vect(0,0,1);
		if( Pawn.Physics == PHYS_Walking && Pawn.FastTrace( BaseLocation - 16.0*vect(0,0,1), BaseLocation ) )
		{
			//DMTNS( "  ==> NOTHING UNDER NPC! <== " );
			return false;
		}
			
		//!!tbd: call AdjustAim (watch for recursion though)?
		//2002.12.08 -- FastTrace won't hit friendly force fields & NPCs & such
		//if( !Pawn.FastTrace( GetFireOffset( TargetDestination, TargetActorLocation ), TargetActorLocation ) )
		HitActor = Pawn.Trace( HitLocation, HitNormal, TargetActorLocation, GetFireOffset( TargetDestination, TargetActorLocation ), true );
		if( HitActor != None && 
			HitActor != TargetActor &&
			!OKToHit( HitActor, HitLocation, HitNormal ) ) // maybe ok to hit this actor anyway? (AdjustAim will make the final call)
		{
			return false;
		}

		Destination = TargetDestination;
		return true;
	}
	
	//-------------------------------------------------------------------------

	#debug   function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr )
	#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo )
	{
		local bool bFoundAdjustedLocation;
		local byte bRightBlocked, bLeftBlocked;
		
		#debug   Global.StopFiring( SuggestedFireAgainDelay, SFInfo, ContextStr );
		#release Global.StopFiring( SuggestedFireAgainDelay, SFInfo );

		// if we still have a valid enemy, see if we can get to a firing position by
		// moving slightly right/left
		//DMTNS( "StopFiring Basic (" $ SuggestedFireAgainDelay $ "): " $ EnumStr( enum'EStopFiringInfo', SFInfo ) $ " (" $ ContextStr $ ")" );

		if( Level.TimeSeconds >= NextAdjustPositionTime ) // don't adjust if already adjusting
		{
			if( (SFInfo == SFI_NoLOS || SFInfo == SFI_NoShot || SFInfo == SFI_OutOfRange) && // only try to adjust if shot is blocked (e.g. as opposed to SFI_Behavior)
				U2PBasic.bCanAdjustStationaryPosition && // mainly for full-body animations -- can't interrupt these by moving NPC
				BehaviorController.GetCheckBehaviorDelay() >= AdjustAgainDelay && // don't adjust if behavior is about to timeout anyway -- just update behavior below
				IsMobile() &&
				ValidEnemy( ControllerEnemy ) )
			{
				//DMTNS( "  trying to adjust position" );
				
				// moving side to side while prone won't look good
				if( Pawn.GetStance() != ST_Prone || Pawn.GetDesiredStance() != ST_Prone )
				{
					bFoundAdjustedLocation = SetValidFiringLocation( true, Pawn.CollisionRadius, bRightBlocked );
					if( !bFoundAdjustedLocation )
						bFoundAdjustedLocation = SetValidFiringLocation( false, Pawn.CollisionRadius, bLeftBlocked );
					if( !bFoundAdjustedLocation && bRightBlocked == 0 )
						bFoundAdjustedLocation = SetValidFiringLocation( true, 2*Pawn.CollisionRadius, bRightBlocked );
					if( !bFoundAdjustedLocation && bLeftBlocked == 0 )
						bFoundAdjustedLocation = SetValidFiringLocation( false, 2*Pawn.CollisionRadius, bLeftBlocked );
					if( !bFoundAdjustedLocation && bRightBlocked == 0 )
						bFoundAdjustedLocation = SetValidFiringLocation( true, 4*Pawn.CollisionRadius, bRightBlocked );
					if( !bFoundAdjustedLocation && bLeftBlocked == 0 )
						bFoundAdjustedLocation = SetValidFiringLocation( false, 4*Pawn.CollisionRadius, bLeftBlocked );
				}
			
				if( bFoundAdjustedLocation )
				{
					NextAdjustPositionTime = Level.TimeSeconds + AdjustAgainDelay;
					GotoLabel( AdjustPositionLabel );
				}
				else
				{
					// NOTE: don't do this if SFI_Behavior because a) we may
					// not want to leave the state in that case and b) we could
					// get an infinite recursion crash because UpdateBehavior
					// can result in additional calls to StopFiring with 
					// SFI_Behavior.
					#debug   UpdateBehavior( true, GetContext() );
					#release UpdateBehavior( true );
				}
			}				
		
			//DMTNS( "  bFoundAdjustedLocation: " $ bFoundAdjustedLocation );
		}
		else
		{
			//DMTNS( "  still carrying out last adjust position" );
		}
	}

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

	function bool ShouldAbortState()
	{
		// bail right away if NPC can't/isn't going to fire (if NPC is one that can fire)
		return( U2PBasic.bHasRangedAttack &&
			  (BehaviorController.GetMinFiringDelay() > U2PBasic.MaxStationaryFiringDelay || 
			  !FDecision( U2PBasic.AttackStationaryCanFireOdds ) || 
			  !CanFire( false ) || 
			  !IsPreparedToFire( true, true, U2Weapon.RatingLow )) );
	}

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

	event BeginState()
	{
		if( ShouldAbortState() )
		{
			bAcceptedState = false;
			#debug DMAIA( " bailing from AttackStationary state" );
			#debug   BehaviorController.Update( BC_AttackCantFire, GetContext() );
			#release BehaviorController.Update( BC_AttackCantFire );
		}
		else
		{
			bAcceptedState = true;
			if( StationaryPawn(ControllerEnemy) != None )
				Enable( Event_SeeEnemy );
			else
				Disable( Event_SeeEnemy );
		}
		#debug DMAIA( " bHasRangedAttack:            " $ U2PBasic.bHasRangedAttack );
		#debug DMAIA( " MinFiringDelay:              " $ BehaviorController.GetMinFiringDelay() ); 
		#debug DMAIA( " AttackStationaryCanFireOdds: " $ U2PBasic.AttackStationaryCanFireOdds );
		#debug DMAIA( " CanFire:                     " $ CanFire( true ) );
		#debug DMAIA( " IsPreparedToFire:            " $ IsPreparedToFire( true ) );
	}

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

	event EndState()
	{
		local byte OldStance;
		
		#debug DMAIA( "EndState" );
		SetSharedTimer( 0.0, false );
		#debug SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
		NextAdjustPositionTime = 0.0;
		
		if( Pawn != None )
		{
			OldStance = Pawn.GetStance();
		
			if( RestoreStance() )
			{
				//DMTNS( "restoring stance OldStance: " $ OldStance );
				
				// utter hack -- keep NPC from moving for long enough to change stance?
				if( OldStance == ST_Prone )
					AddTimer( FreezeNPCHackTimerName, ProneStanceChangeDuration );
				else
					AddTimer( FreezeNPCHackTimerName, CrouchStanceChangeDuration );
					
				Pawn.GroundSpeed = 0.0;
			}
		}
	}

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

@ ChallengeLabel:
	#debug DMAIL( ChallengeLabel );
	StopMovement( true, false );
	Pawn.DesiredRotation = rotator( ControllerEnemy.Location - Pawn.Location );
	Goto( FaceTargetLabel );

@ BeginLabel:
	#debug DMAIL( BeginLabel );
	Focus = GetTarget();

	if( Focus == None )
	{
		#debug   BehaviorController.Update( BC_UpdateInactive, GetContext() );
		#release BehaviorController.Update( BC_UpdateInactive );
	}
	if( Pawn(Focus) != None && !ValidEnemy( Pawn(Focus) ) )
		UpdateEnemy();
		
	StopMovement( true, true );
	#debug DMAIA( " calling initialize state" );
	InitializeState();
	
@ FaceTargetLabel:
	Focus = GetTarget();
	//!!mdf-tbd: check whether prepared to attack and have possibility of aborting 
	// stationary attack (e.g. to use cover). Should there be a meta state like
	// MS_NotPrepared with associated behaviors (close,findcover?
	#debug DMAIL( FaceTargetLabel );
	if( NeedToTurn( Focus.Location, NeedToTurnAngleCos ) )
	{
		#debug DMAIL( "FinishRotation -- begin" );
		FinishRotation( DefaultRotationThreshold );
		#debug DMAIL( "FinishRotation -- end" );
	}

	#debug DMAIA( "Ready to attack in " $ GetStateName() );

@ AttackOngoingLabel:
	Focus = GetTarget();
	#debug DMAIL( AttackOngoingLabel );

	if( Focus != None && Focus.bDeleteMe )
	{
		#debug   BehaviorController.Update( BC_TargetInvalid, GetContext() );
		#release BehaviorController.Update( BC_TargetInvalid );
	}
	else if( ControllerEnemy != None && !ValidEnemy( ControllerEnemy ) )
	{
		UpdateEnemy();
	}
	
	//!!mdf CheckAttackStatus();

	//!!mdf-tbd: need a latent yield here but with new approach we probably
	//don't even need to be looping this code?
	RefireDelay = GetCurrentFireRate();

	if( RefireDelay >= 0.05 && RefireDelay <= U2Weapon.MaxRapidFireRate )
		Sleep( RefireDelay );
	else
		Sleep( 0.5 ); // need at least some latent yield here

	Goto( AttackOngoingLabel );

@ StanceChangeDelayLabel:
	#debug DMAIA( "StanceChangeDelayLabel" );

	// NOTE: DesiredStance is set but Stance won't change (if possible) until next tick
	
	// make sure state doesn't time-out for at least some time after going to crouching/prone
	BehaviorController.GetTimeOutDelays( OldCheckBehaviorDelay, OldCheckMetaStateDelay ); // save off old times in case stance change fails
	if( Pawn.GetDesiredStance() == ST_Crouching )
	{
		BehaviorController.SetMinTimeOutDelay( U2PBasic.MinStayCrouchingTime );
	}
	else if( Pawn.GetDesiredStance() == ST_Prone )
	{
		BehaviorController.SetMinTimeOutDelay( U2PBasic.MinStayProneTime );
	}
		
	// when we stand up (assume stance change won't fail) don't crouch/go prone again for a while
	ReduceStanceAgainTime = Level.TimeSeconds + U2PBasic.MinReduceStanceAgainDelay;

	FinishAnim();   // let stance change anim finish (if any)
	Sleep( 0.001 ); // make sure at least 1 tick passes
	
	if( Pawn.GetStance() == ST_Standing )
	{
		// stance change failed -- restore timers
		BehaviorController.RestoreTimeOutDelays( OldCheckBehaviorDelay, OldCheckMetaStateDelay );
	}
	
	#debug DMAIA( "after FinishAnim  Stance: " $ Pawn.GetStance() );
	
	Goto( FaceTargetLabel );

@ AdjustPositionLabel:
	#debug DMAIA( "adjusting firing position  ControllerEnemy: " $ ControllerEnemy );
	//AddActorAt( Pawn, Destination, ColorPink() );
	Focus = ControllerEnemy;
	FocalPoint = Focus.Location;
	MoveToPoint( Destination, 2.0, ControllerEnemy );
	//DMTNS( "  MoveToPoint returned " $ EnumStr( enum'EMoveResult', MoveResult ) );
	StopMovement( true, true );
	NextAdjustPositionTime = 0.0;
	
@ AdjustRotationLabel:
	#debug DMAIA( "adjusting firing rotation  ControllerEnemy: " $ ControllerEnemy );
	
	Focus = ControllerEnemy;
	FocalPoint = Focus.Location;
	FinishRotation( DefaultRotationThreshold );
	//DMTNS( "  finished rotation" );
	
	Goto( AttackOngoingLabel );
} // AttackStationaryState

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

state @ AttackTacticalMoveState
{
	ignores HearNoise, NotifyBump, SeeFriend, SeeOther, SeeAlertFriend;

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

	function UpdateTacticalMoveBehavior()
	{
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
	}

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

	function bool CanFire( bool bTest )	{ return ( U2PBasic.bHasMovingRangedAttack && FDecision( U2PBasic.AttackTacticalMoveCanFireOdds ) && Global.CanFire( bTest ) ); }

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

	function ShotFiredNotification( Pawn Shooter, vector FireDir, class<Projectile> ProjectileClass, float ProjSpeed )
	{	
		#debug DMAI( "RW: " $ Shooter );

		if( IsFacingTarget( ControllerEnemy, CosMinFacingTargetAngle ) && FRand() < 0.4 ) 
			return;

		Global.ShotFiredNotification( Shooter, FireDir, ProjectileClass, ProjSpeed );
	}

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

	function SetFall() //about to fall
	{
		#debug DMAI( "SetFall" );

		StopMovement( true, false );
		Destination = Pawn.Location; //!! what if NPC is jumping/falling to a destination -- shouldn't we keep Destination?
		Global.SetFall();
	}

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

	function StartFalling()
	{
		//!!mdf-tbd: shut movement down until landed?
		GotoLabel( BeginLabel );
	}
	
	//-------------------------------------------------------------------------

	event bool NotifyHitWall( vector HitNormal, Actor Wall )
	{
		#debug DMAI( "NotifyHitWall" );

		if( Pawn.Physics != PHYS_Falling )
		{
			if( !ValidEnemy( ControllerEnemy ) )
			{
				UpdateEnemy();
			}
			else
			{
				if( bChangeDir || FRand() < 0.5 || ((ControllerEnemy.Location - Pawn.Location) dot HitNormal) < 0 )
				{
					Focus = ControllerEnemy;
				}
				else
				{
					bChangeDir = true;
					Destination = Pawn.Location - HitNormal * FRand() * 500;
				}
			}
		}

		return false;
	}

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

	function FearThisSpot( Actor aSpot )
	{
		#debug DMAI( "FearThisSpot" );

		Destination = Pawn.Location + 120 * Normal( Pawn.Location - aSpot.Location ); 
	}

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

	function eventEnemyNotVisible()
	{
		#debug DMAI( "eventEnemyNotVisible" );

		#debug   StopFiring( 0.2, SFI_Behavior, GetContext() );
		#release StopFiring( 0.2, SFI_Behavior );
		
		if( Aggressiveness > RelativeStrength( ControllerEnemy ) )
		{
			if( Pawn.FastTrace( ControllerEnemy.Location, GetLastEnemySeeingLocation() ) )
			{
				GotoLabel( RecoverEnemyLabel );
			}
			else
			{
				#debug   BehaviorController.Update( BC_EnemyNotVisible, GetContext() );
				#release BehaviorController.Update( BC_EnemyNotVisible );
			}
		}
		Disable( 'EnemyNotVisible' );
	}

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

	//!!mdf-tbd: pain volumes, gas grenades & such?
	function PawnIsInPain( PhysicsVolume PainVolume )
	{
		#debug DMAI( "PawnIsInPain -- GS AttackRetreat #4" );
		GotoState( AttackRetreatState ); //GS-tbd
	}

	/*-------------------------------------------------------------------------
	Choose a destination for the tactical move, based on aggressiveness and the
	tactical situation. Make sure destination is reachable.
	*/

	function PickDestination( bool bCanCharge )
	{
		local vector PickDir, EnemyDir, EnemyPart, X, Y, Z, MinDest;
		local Pawn CurrentEnemy;
		local Actor HitActor;
		local vector HitLocation, HitNormal, CollSpec;
		local float Aggression, EnemyDist, MinDist, StrafeSize, OptDist;
		local bool bSuccess, bNoReach;

		#debug DMAI( "PickDestination: " $ bCanCharge );

		CurrentEnemy = ControllerEnemy;
		
		if( !ValidEnemy( CurrentEnemy ) )
		{
			UpdateEnemy();
			return;
		}

		if( Orders == OrdersHold )
			bCanCharge = false;

		bChangeDir = false;
		if( Pawn.PhysicsVolume.bWaterVolume && !Pawn.bCanSwim && Pawn.bCanFly )
		{
			Destination = Pawn.Location + 75 * ( VRand() + vect(0,0,1) );
			Destination.Z += 100;
			return; //!!mdf-tbd no reachability check
		}
		if( CurrentEnemy.PhysicsVolume.bWaterVolume )
			bCanCharge = bCanCharge && Pawn.bCanSwim;
		else 
			bCanCharge = bCanCharge && (Pawn.bCanFly || Pawn.bCanWalk);

		EnemyDist = VSize( Pawn.Location - CurrentEnemy.Location );

		bSuccess = false;
		if( (bSniping || Orders == OrdersHold) /*!!mdf && PriorityObjective() == 0 */ )
			bCanCharge = false;

		Aggression = 2 * ( U2PBasic.CombatStyle + FRand() ) - 1.1;
		if( CurrentEnemy.IsPlayerPawn() && ( GetReactionToEnemy( CurrentEnemy ) == REACTION_Fear ) && ( U2PBasic.CombatStyle > 0 ) )
			Aggression = Aggression - 2 - 2 * U2PBasic.CombatStyle;

		//DMTNS( "Base Aggression: " $ Aggression );
		
		// adjust Aggression based on attack capabilities
		if( !IsPreparedToAttack( true ) )
		{
			//DMTNS( "  not prepared to attack -- Aggression += 2  * StyleRunAway" );
			Aggression += 2 * StyleRunAway;
		}
		else
		{
			// mdf-tbd: 2nd parameter should be passed the likely use (fire/altfire) for the attack.
			// but we pbly don't want to call RateSelf here (slow & might not get same result as
			// when shot is actually fired. It might make sense if we simply call RateSelf/
			// SwitchToBestWeapon periodically in a timer and squirrel away relevant info such
			// as what those calls returned and the time at which they were last called
			Aggression += GetAttackStyle( CurrentEnemy );
		}

		// adjust Aggression based on enemy's attack capabilities
		Aggression += 2 * CurrentEnemy.Controller.GetDefenseStyle( Pawn );

		// mdf-tbd: in some cases should really be going to a "runaway" state

		if( EnemyDist > 1000 )
		{
			//DMTNS( "  boosting Aggression by 1" );
			Aggression += 1;
		}
			
		if( bCanCharge )
			bCanCharge = ( Aggression >= FRand() );

		if( ( Pawn.Physics == PHYS_Walking ) || ( Pawn.Physics == PHYS_Falling ) )
		{
			if( Pawn.Location.Z > CurrentEnemy.Location.Z + 150 ) //tactical height advantage
			{
				//DMTNS( "  tactical height advantage" );
				Aggression = FMax( 0.0, Aggression - 1.0 + U2PBasic.CombatStyle );
			}
			else if( Pawn.Location.Z < CurrentEnemy.Location.Z - Pawn.CollisionHeight ) // below enemy
			{
				if( EnemyDist < (1.1 * (CurrentEnemy.Location.Z - Pawn.Location.Z)) && !ActorReachable( CurrentEnemy ) ) 
				{
					bNoReach = true;
					//DMTNS( "  can't reach enemy -- reducing Aggression" );
					Aggression = -1.5 * FRand();
				}
			}
		}

		if( UseTacticalJumps() )
		{
			GetAxes( Rotation, X, Y, Z );

			if( FRand() < 0.5 )
			{
				Y *= -1;
				TryToDodge( Y, false );
			}
			else
				TryToDodge( Y, true );
		}
				
		if( ((CurrentEnemy.Velocity - Pawn.Velocity) dot (CurrentEnemy.Location - Pawn.Location)) > 0 )
		{
			//DMTNS( "  boosting Aggression by up to 0.4" );
			Aggression += 0.4 * FRand();
		}
		
		//DMTNS( "  final Aggression: " $ Aggression );
			 
		EnemyDir = (CurrentEnemy.Location - Pawn.Location)/EnemyDist;
		if( U2PBasic.bJumpy )
			MinDist = 160;
		else
			MinDist = FMin( 160.0, 3*Pawn.CollisionRadius );
		OptDist = 80 + FMin( EnemyDist, 250 * ( FRand() + FRand() ) );  
		Y = EnemyDir cross vect(0,0,1);
		if( Pawn.Physics == PHYS_Walking )
		{
			Y.Z = 0;
			EnemyDir.Z = 0;
		}
		else 
			EnemyDir.Z = FMax( 0, EnemyDir.Z );

		StrafeSize = FMax( -0.7, FMin( 0.85, ( 2 * Aggression * FRand() - 0.3 ) ) );
		EnemyPart = EnemyDir * StrafeSize;
		StrafeSize = FMax( 0.0, 1 - Abs( StrafeSize ) );
		// mdf-tbd: fix? Y not normalized above?
		//PickDir = StrafeSize * Y;
		PickDir = StrafeSize * Normal( Y );
		if( bStrafeDir )
			PickDir *= -1;
		bStrafeDir = !bStrafeDir;
		CollSpec.X = Pawn.CollisionRadius;
		CollSpec.Y = Pawn.CollisionRadius;
		CollSpec.Z = FMax( 6, Pawn.CollisionHeight - 18 );
		
		MinDest = Pawn.Location + MinDist * ( PickDir + EnemyPart );
		HitActor = Pawn.Trace( HitLocation, HitNormal, MinDest, Pawn.Location, false, CollSpec );
		if( HitActor == None )
		{
			bSuccess = ( Pawn.Physics != PHYS_Walking );
			if( !bSuccess )
			{
				CollSpec.X = FMin( 14, 0.5 * Pawn.CollisionRadius );
				CollSpec.Y = CollSpec.X;
				HitActor = Pawn.Trace( HitLocation, HitNormal, MinDest - (18 + Pawn.MaxStepHeight) * vect(0,0,1), MinDest, false, CollSpec );
				bSuccess = ( HitActor != None );
			}
			if( bSuccess )
				Destination = MinDest + ( PickDir + EnemyPart ) * OptDist;
		}
	
		if( !bSuccess )
		{					
			CollSpec.X = Pawn.CollisionRadius;
			CollSpec.Y = Pawn.CollisionRadius;
			MinDest = Pawn.Location + MinDist * ( EnemyPart - PickDir ); 
			HitActor = Pawn.Trace( HitLocation, HitNormal, MinDest, Pawn.Location, false, CollSpec );
			if( HitActor == None )
			{
				bSuccess = ( Pawn.Physics != PHYS_Walking );
				if( !bSuccess )
				{
					CollSpec.X = FMin( 14, 0.5 * Pawn.CollisionRadius );
					CollSpec.Y = CollSpec.X;
					HitActor = Pawn.Trace( HitLocation, HitNormal, MinDest - (18 + Pawn.MaxStepHeight) * vect(0,0,1), MinDest, false, CollSpec );
					bSuccess = ( HitActor != None );
				}
				if( bSuccess )
					Destination = MinDest + ( EnemyPart - PickDir ) * OptDist;
			}
			else 
			{
				if( ( U2PBasic.CombatStyle <= 0 ) || ( CurrentEnemy.IsPlayerPawn() && ( GetReactionToEnemy( CurrentEnemy ) == REACTION_Fear ) ) )
					EnemyPart = vect(0,0,0);
				else if( ( EnemyDir dot EnemyPart ) < 0 )
					EnemyPart = -1 * EnemyPart;
				PickDir = Normal( EnemyPart - PickDir + HitNormal );
				MinDest = Pawn.Location + MinDist * PickDir;
				CollSpec.X = Pawn.CollisionRadius;
				CollSpec.Y = Pawn.CollisionRadius;
				HitActor = Pawn.Trace( HitLocation, HitNormal, MinDest, Pawn.Location, false, CollSpec );
				if( HitActor == None )
				{
					bSuccess = ( Pawn.Physics != PHYS_Walking );
					if( !bSuccess )
					{
						CollSpec.X = FMin( 14, 0.5 * Pawn.CollisionRadius );
						CollSpec.Y = CollSpec.X;
						HitActor = Pawn.Trace( HitLocation, HitNormal, MinDest - (18 + Pawn.MaxStepHeight) * vect(0,0,1), MinDest, false, CollSpec );
						bSuccess = ( HitActor != None );
					}
					if( bSuccess )
						Destination = MinDest + PickDir * OptDist;
				}
			}	
		}
					
		if( bSuccess )
		{
			// mdf-tbd: should !NeedToTurn test go into || (has X || Y && Z currently)?
			if( U2PBasic.bJumpy || 
				(TrySplashDamageAttack() && 
				 (FRand() < 0.1 + 0.8 * GetSkill()) && 
				 (CurrentEnemy.Location.Z - CurrentEnemy.CollisionHeight <= Pawn.Location.Z + Pawn.MaxStepHeight - Pawn.CollisionHeight)) && 
				!NeedToTurn( CurrentEnemy.Location, NeedToTurnAngleCos ) )
			{
				if( (U2PBasic.bJumpy && FRand() < 0.75) || SplashJump() )
				{
					// try jump move
					Pawn.SetPhysics( PHYS_Falling );
					StopMovement( true, false );
					Destination = MinDest;
					return; 
				}
			}
			PickDir = ( Destination - Pawn.Location );
			EnemyDist = VSize( PickDir );
			if( EnemyDist > MinDist + 2 * Pawn.CollisionRadius )
			{
				PickDir = PickDir/EnemyDist;
				HitActor = Pawn.Trace( HitLocation, HitNormal, Destination + 2 * Pawn.CollisionRadius * PickDir, Pawn.Location, false );
				if( ( HitActor != None ) && ( ( HitNormal dot PickDir ) < -0.6 ) )
					Destination = HitLocation - 2 * Pawn.CollisionRadius * PickDir;
			}
		}
	}

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

	event BeginState()
	{
		if( !IsMobile() )
		{
			#debug DMAIA( " bailing from AttackTacticalMove state" );
			#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
			#release BehaviorController.Update( BC_AttackUpdate );
		}
		else
		{
			MinHitWall += 0.15;
			bAdjustFromWalls = false;
			if( Pawn != None )
			{
				Pawn.bAvoidLedges = true;
				Pawn.bStopAtLedges = true;
				Pawn.bCanWalkOffLedges = false;
				Pawn.bCanJump = false;
				Pawn.bCanStrafe = Pawn.default.bCanStrafe || U2PBasic.bCanStrafeDuringTacticalMoves;
			}
		}
		if( StationaryPawn(ControllerEnemy) != None )
			Enable( Event_SeeEnemy );
		else
			Disable( Event_SeeEnemy );
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		MinHitWall -= 0.15;
		bAdjustFromWalls = true;
		if( Pawn != None )
		{
			Pawn.bAvoidLedges = Pawn.default.bAvoidLedges;
			Pawn.bStopAtLedges = Pawn.default.bStopAtLedges;
			Pawn.bCanWalkOffLedges = Pawn.default.bCanWalkOffLedges;
			Pawn.bCanJump = (Pawn.JumpZ > 0);
			if( !Pawn.bCanStrafe )
			{
				// otherwise leftover velocity could cause NPC
				// to temporarily turn away from target in next state
				StopMovement( true, true );
			}
			RestoreCanStrafe();
		}
	}

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

@ TacticalTickLabel:
	Sleep( 0.02 );

@ BeginLabel:
@ MovePickDestLabel:
	Focus = ControllerEnemy;
	Destination = Focus.Location; //!!mdf-tbd: why set destination here?
	WaitForLanding();

	PickDestination( true ); // might change state
		
@ MoveActiveLabel:
	// don't try tactical moves through XMP items
	if( Level.HasSpecialColliders() && Pawn.FastTrace( Destination, Pawn.Location ) )
	{
		UpdateTacticalMoveBehavior();
		Stop;
	}
	
	if( !Pawn.bCanStrafe )
	{
		//DMTNS( "looking at destination during move" ); 
		MoveToPoint( Destination );
	}
	else
	{
@ MoveActiveStrafeLabel:
		//DMTNS( "looking at enemy during move" ); 
		MoveToPoint( Destination, , ControllerEnemy );	
	}

	if( !ValidEnemy( ControllerEnemy ) )
	{
		UpdateEnemy();
	}
	else if( !LineOfSightTo( ControllerEnemy ) )
	{
		if( Pawn.FastTrace( ControllerEnemy.Location, GetLastEnemySeeingLocation() ) )
		{
			Goto( RecoverEnemyLabel );
		}
		else
		{
			#debug   BehaviorController.Update( BC_EnemyNotVisible, GetContext() );
			#release BehaviorController.Update( BC_EnemyNotVisible );
		}
	}

@ DontCloseLabel:
	Focus = ControllerEnemy;
	Destination = ControllerEnemy.Location; //!!mdf-tbd: and here
	WaitForLanding();

	PickDestination( false ); // might change state
		
	Goto( MoveActiveLabel );

@ RecoverEnemyLabel:
	HidingSpot = Pawn.Location;

	Destination = GetLastEnemySeeingLocation() + 4 * Pawn.CollisionRadius * Normal( GetLastEnemySeeingLocation() - Pawn.Location );
	// don't try tactical moves through XMP items
	if( Level.HasSpecialColliders() && Pawn.FastTrace( Destination, Pawn.Location ) )
	{
		UpdateTacticalMoveBehavior();
		Stop;
	}
	//DMTNS( "recover enemy move" ); 
	MoveToPoint( Destination, , ControllerEnemy );

	if( CanFire( false ) && IsPreparedToFire( true ) && LineOfSightTo( ControllerEnemy ) )
	{
		// mdf-tbd: cleanup this mess -- Focus should be handled already in FireAt -- look at all cases like this
		Focus = ControllerEnemy;
		StopMovement( true, false );

		if( SplashDamageAttack() )
		{
			//mdf-tbd: stop firing?
			Sleep( 0.2 );
		}
		else
		{
			Sleep( 0.35 + 0.3 * FRand() );
		}

		if( ( FRand() + 0.1 > U2PBasic.CombatStyle ) )
		{
			Enable( Event_EnemyNotVisible );
			Destination = HidingSpot + 4 * Pawn.CollisionRadius * Normal( HidingSpot - Pawn.Location );
			Goto( MoveActiveLabel );
		}
	}

	Goto( MovePickDestLabel );
} // AttackTacticalMoveState

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

state @ AttackTacticalMoveMeleeState extends @ AttackTacticalMoveState
{
	ignores HearNoise, NotifyBump, SeeFriend, SeeOther, SeeAlertFriend;
	
	function UpdateTacticalMoveBehavior()
	{
		if( ControllerEnemy != None && CheckMeleeAttackRange( ControllerEnemy ) )
		{
			#debug   BehaviorController.Update( BC_MeleeUpdate, GetContext() );
			#release BehaviorController.Update( BC_MeleeUpdate );
		}
		else
		{
			Super.UpdateTacticalMoveBehavior();
		}
	}
}

//-----------------------------------------------------------------------------
// Retreat to a location while facing enemy.

state @ AttackTacticalRetreatState extends @ AttackTacticalMoveState
{
	ignores HearNoise, NotifyBump, SeeFriend, SeeOther, SeeAlertFriend;

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

	function UpdateRetreatBehavior()
	{
		//DMTNS( "AttackTacticalRetreatState.UpdateRetreatBehavior" );
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
	}
	
	//-------------------------------------------------------------------------

	function PickDestination( bool bCanCharge )
	{
		local vector RetreatDir, TargetLocation;
		local float RetreatDistance;
		local bool bTryLeftNext, bSuccess;
		local vector HitLocation, HitNormal;
		local Actor HitActor;
		local int i;

		if( !ValidEnemy( ControllerEnemy ) )
		{
			UpdateEnemy();
			return;
		}

		RetreatDistance = U2PBasic.MaxTacticalRetreatDistance - VSize( StateStartLocation - Pawn.Location );
		if( RetreatDistance <= 10.0 )
		{
			UpdateRetreatBehavior();
			return;
		}

		bTryLeftNext = (FRand() < 0.50 );			
		RetreatDir = Pawn.Location - ControllerEnemy.Location;
		if( Pawn.Physics == PHYS_Walking )
			RetreatDir.Z = 0;
		RetreatDir = Normal( RetreatDir );

		//!!mdf-tbd: make using a random vector an option
		//!!mdf-tbd: check for blocking pawns also?			
        for( i=0; i<3 && !bSuccess; i++ )
		{
			//RetreatDir =  Pawn.Location + RetreatDistance * vector(rotator(RetreatDir) + rotator(RandomSpreadVector( 90.0 )) );
			//TargetLocation = Pawn.Location + RetreatDistance * RetreatDir;

			if( i == 0 )
			{
				// try straight back
				//DMTNS( "back" );
				TargetLocation = Pawn.Location + RetreatDistance*RetreatDir;
				//AddArrow( Pawn.Location, TargetLocation, ColorPink() );
			}
			else if( bTryLeftNext )
			{
				// try left
				//DMTNS( "left" );
				TargetLocation = Pawn.Location + RetreatDistance*Normal( RetreatDir cross vect(0,0,1) );
				bTryLeftNext = false;
			}
			else
			{
				// try right
				//DMTNS( "right" );
				TargetLocation = Pawn.Location + RetreatDistance*Normal( vect(0,0,1) cross RetreatDir );
				bTryLeftNext = true;
			}
			
			class'UtilGame'.static.AdjustDestinationForPhysics( Pawn, TargetLocation );

			if( Pawn.FitActorAt( TargetLocation ) != 0 )
			{
				//AddActorAt( Pawn, TargetLocation, ColorPink() );
				bSuccess = PointReachable( TargetLocation );
			}
		}
		
		if( bSuccess )
		{
			//AddArrow( Pawn.Location, TargetLocation );
			Destination = TargetLocation;
		}
		else
		{
			#debug DMAI( "AttackTacticalRetreatState.PickDestinaion -- couldn't find a backoff destination" );
			UpdateRetreatBehavior();
			Destination = Pawn.Location;
		}
	}

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

	event BeginState()
	{
		Super.BeginState();
		
		Pawn.bCanStrafe = Pawn.default.bCanStrafe || U2PBasic.bCanStrafeDuringTacticalRetreat;
		
		if( ControllerEnemy != None )
			StateStartLocation = ControllerEnemy.Location;
		else
			StateStartLocation = Pawn.Location;
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		Super.EndState();
		
		if( Pawn != None )
		{
			if( !Pawn.bCanStrafe )
			{
				// otherwise leftover velocity could cause NPC
				// to temporarily turn away from target in next state
				StopMovement( true, true );
			}
			RestoreCanStrafe();
		}
	}
	
	//-------------------------------------------------------------------------

@ BeginLabel:
@ MovePickDestLabel:
	WaitForLanding();
	PickDestination( true ); // might change state
	
@ MoveActiveLabel:
	// don't try tactical moves through XMP items
	if( Level.HasSpecialColliders() && Pawn.FastTrace( Destination, Pawn.Location ) )
	{
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
		UpdateRetreatBehavior();
		Stop;
	}
	MoveToPoint( Destination, , ControllerEnemy );
	if( MoveResult == MR_DestinationReached )
		UpdateRetreatBehavior();
	
	Goto( MovePickDestLabel );
	//#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
	//#release BehaviorController.Update( BC_AttackUpdate );
} // AttackTacticalRetreatState

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

state @ AttackTacticalRetreatMeleeState extends @ AttackTacticalRetreatState
{
	ignores HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend;

	function UpdateRetreatBehavior()
	{
		//DMTNS( "AttackTacticalRetreatMeleeState.UpdateRetreatBehavior" );
		if( ControllerEnemy != None && CheckMeleeAttackRange( ControllerEnemy ) )
		{
			#debug   BehaviorController.Update( BC_MeleeUpdate, GetContext() );
			#release BehaviorController.Update( BC_MeleeUpdate );
		}
		else
		{
			Super.UpdateRetreatBehavior();
		}
	}
}

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

state @ AttackTauntState extends @ AcquisitionState
{
	ignores BeginFalling, EnemyInLeapRange, NotifyLanded; 

	function PlayRandomSound();

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

	event BeginState()
	{
		if( Pawn.Health < 0.60 * Pawn.default.Health )
		{
			#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
			#release BehaviorController.Update( BC_AttackUpdate );
		}
		else		
		{
			Super.BeginState();
		}
	}
	
	//-------------------------------------------------------------------------

@ PostBeginLabel:
	//DMTNS( "Finished rotating, sleeping for " $ U2PBasic.MinAcquisitionDelay - (Level.TimeSeconds - LastAcquireTime) $ " secs" );
	Sleep( U2PBasic.MinAcquisitionDelay - (Level.TimeSeconds - LastAcquireTime) );

	// tbd: separate properties for controlling taunts?	
	U2PBasic.HandleAcquireEnemySound();
	if( FDecision( U2PBasic.TauntAnimationOdds ) )
	{
		StopMovement( true, true );
		//DMTNS( "TAUNT!" );
		Sleep( SetSpecialAnim( 'U2_Taunt',  true ) );
		//Sleep( U2PBasic.PostAcquisitionAnimationDelay );
	}
	#debug   UpdateBehavior( false, GetContext() );
	#release UpdateBehavior( false );
} // AttackTauntState

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

state @ CantMoveState
{
@ BeginLabel:
	Stop;
}

/*-----------------------------------------------------------------------------
NPC stops moving and plays a cowering animation forever.
*/

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

	function PlayRandomSound();

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

	function bool CanFire( bool bTest ) { return false; }
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		StopMovement( true, false );
		#debug   StopFiring( 0.5, SFI_Behavior, GetContext() );
		#release StopFiring( 0.5, SFI_Behavior );
		BehaviorController.SetBCEnabled( false );
		Pawn.MeshAgentSetInputCurValue( 'specialstate', 'cower' );
		Pawn.MeshAgentSetInputLock( 'specialstate', true );
		AgentSpecialStateBegin();
	}

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

	event EndState()
	{
		if( Pawn != None )
			Pawn.MeshAgentSetInputLock( 'specialstate', false );
		AgentSpecialStateEnd();
		CheckBehaviorEnabled();
	}
			
	//-------------------------------------------------------------------------
	
@ BeginLabel:
@ TurnLabel:
	if( ControllerEnemy != None && NeedToTurn( ControllerEnemy.Location, NeedToTurnAngleCos ) )
	{
		Focus = ControllerEnemy;
		FocalPoint = ControllerEnemy.Location + vect(0,0,1) * ControllerEnemy.BaseEyeHeight;
		FinishRotation( DefaultRotationThreshold );
		Focus = None;
		FocalPoint = Pawn.Location + 256*vector(Pawn.Rotation);
    }
   	Sleep( 1.0 );
	Goto( TurnLabel );	
	
/* !!mdf-tbd: currently no way to get out of cowering	
@ StopCoweringLabel:	
	#debug   UpdateBehavior( true, GetContext() );
	#release UpdateBehavior( true );
*/		
} // CoweringState

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

state @ DeadLockedState
{
	ignores HearNoise, NotifyBump, SeeFriend, SeeOther, SeeAlertFriend;

@ BeginLabel:	
	Sleep( 0.1 );
	#debug   UpdateBehavior( false, GetContext() );
	#release UpdateBehavior( false );
} // DeadLockedState

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

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

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

	function PlayRandomSound();
	function bool CanDodge( optional bool bIgnoreFalling ) { return false; }
	function bool CanFire( bool bTest ) { return ( bDodgeFinished && Global.CanFire( bTest ) ); }
	function HandlePanic() { if( bDodgeFinished ) Global.HandlePanic(); }
	function HandleIncoming( Actor IncomingActor, vector IncomingDirection, float IncomingSpeed );
	function EnemyAcquired();
	
	//-------------------------------------------------------------------------

	function ReflectNotify( name NotifyName )
	{
		if( NotifyName == StayNotify )
		{
			if( U2PBasic.DodgeTime <= 0.0 )
				U2PBasic.DodgeTime = Level.TimeSeconds - StartDodgeTime;
			GotoLabel( DodgeFinishedLabel );
		}
		else
		{
			Super.ReflectNotify( NotifyName );
		}
	}

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

	function float GetDodgeSpeed()
	{
		local float DodgeDistance;
		local float RawDodgeSpeed;
		 
		DodgeDistance = VSize( U2PBasic.DodgeDestination - Pawn.Location );
		RawDodgeSpeed = DodgeDistance / Abs(U2PBasic.DodgeTime);
		
		//DMTNS( "DodgeDistance: " $ DodgeDistance );
		//DMTNS( "DodgeTime:     " $ U2PBasic.DodgeTime );
		//DMTNS( "RawDodgeSpeed: " $ RawDodgeSpeed );
		//DMTNS( "DodgeSpeed:    " $ RawDodgeSpeed / Pawn.GroundSpeed );
		return ( RawDodgeSpeed / Pawn.GroundSpeed );
	}

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

	event BeginState()
	{
		//DMTNS( "BeginState flipping Physics: " $ EnumStr( enum'EPhysics', Pawn.Physics ) $ " Velocity: " $ Pawn.Velocity );
		bDodgeFinished = false;
		EnableRotation( false );
		U2P.bIgnoreImpactForces = true;
		U2P.bCanKnockDown = false;
		BehaviorController.SetBCEnabled( false );
		StartDodgeTime = Level.TimeSeconds;
	}

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

	event EndState()
	{
		//DMTNS( "EndState" );
		EnableRotation( true );
		UnlockAnimationController( true );
		if( U2P != None )
		{
			//DMTNS( "  flipping Physics: " $ EnumStr( enum'EPhysics', U2P.Physics ) $ " Velocity: " $ U2P.Velocity $ " Speed: " $ VSize( U2P.Velocity ) );
			U2P.bIgnoreImpactForces = U2P.default.bIgnoreImpactForces;
			U2P.bCanKnockDown = U2P.default.bCanKnockDown;
		}
		CheckBehaviorEnabled();
	}
			
	//-------------------------------------------------------------------------

@ BeginLabel:
	//DMTNS( "BeginLabel" );
	if( U2PBasic.bJumpDodges )
	{
		//DMTNS( "doing a jump dodge" );
		// abort if NPC isn't falling or doesn't have right velocity (might happen if takes damage)
		if( Pawn.Physics != PHYS_Falling || Pawn.Velocity.Z <= 0 || VSize(Pawn.Velocity) < 70 )
		{
			//mdf-tbd: this would kill momentum xfer if NPC hit as about to dodge and resulting velocity isn't right
			Pawn.Velocity = vect(0,0,0);
			Goto( DoneLabel );
		}

		// velocity launched, just wait for the dodge animation to finish
		FinishAnim();
	}
	else
	{
		//DMTNS( "doing a roll dodge" );
		// dodge along the ground, use MoveToPoint
		
		//AddCylinder( U2PBasic.DodgeDestination, Pawn.CollisionRadius, Pawn.CollisionHeight, ColorBlue() );
		//DMTNS( "Moving " $ VSize( Pawn.Location - U2PBasic.DodgeDestination ) $ " units at speed of: " $ GetDodgeSpeed() );
		MoveToPoint( U2PBasic.DodgeDestination, , , GetDodgeSpeed() );
		//DMTNS( "MoveToPoint returned -- " $ VSize( Pawn.Location - U2PBasic.DodgeDestination ) $ " units from destination" );
	}

@ DodgeFinishedLabel:
	//DMTNS( "DodgeFinishedLabel" );
	if( U2P != None )
		U2P.LandedOnTexture( 500.0 );
		
	StopMovement( true, true ); // make sure movement stopped?
	bDodgeFinished = true;
	EnableRotation( true );
	
	// turn to enemy (if any)
	StartTurnTime = Level.TimeSeconds;
	Focus = ControllerEnemy;
	if( Focus != None )
	{
		if( NeedToTurn( Focus.Location, NeedToTurnAngleCos ) )
			FinishRotation( DefaultRotationThreshold );
	}
	else
	{
		FocalPoint = Pawn.Location + 256.0*vector(Pawn.Rotation);
	}
	
	Sleep( U2PBasic.PostDodgeDelay - (Level.TimeSeconds - StartTurnTime) );
	MaybeFire( 0 ); // alt fire too?

@ DoneLabel:
	#debug   UpdateBehavior( true, GetContext() );
	#release UpdateBehavior( true );
} // DodgingState

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

state @ EnemyKilledState
{
	ignores EnemyNotVisible; 

	//-------------------------------------------------------------------------
		
	event BeginState()
	{
		Super.BeginState();
		SetAlertness( -0.3 );
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		RestoreAlertness();
		Super.EndState();
	}
} // EnemyKilledState

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

state @ FindAirState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, NotifyBump;

	//-------------------------------------------------------------------------
	// NOTE: NotifyHeadVolumeChange appears to not be implemented currently --
	// its not being called anywhere. HeadVolumeChange *is* still being called 
	// (on the Pawn...)

	event bool NotifyHeadVolumeChange( PhysicsVolume NewHeadVolume )
	{
		Global.NotifyHeadVolumeChange( NewHeadVolume );
		if ( !NewHeadVolume.bWaterVolume )
		{
			#debug   UpdateBehavior( false, GetContext() );
			#release UpdateBehavior( false );
		}
		return false;
	}

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

	function eventEnemyNotVisible()
	{
		////log("enemy not visible");
		//mdf-tbd: tell BC?
	}

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

@ MoveDoneLabel:	
	#debug   UpdateBehavior( false, GetContext() );
	#release UpdateBehavior( false );
} // FindAirState

//-----------------------------------------------------------------------------
// Can't move, can't shoot, can't rotate/aim, not moved by damage.

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

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

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

	event BeginState()
	{
		if( BehaviorController != None )
			BehaviorController.SetBCEnabled( false );
		Super.BeginState();
		Focus = None;
	}

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

	event EndState()
	{
		CheckBehaviorEnabled();
		Super.EndState();
	}
} // FrozenState

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

state @ GameEndedState
{
	function PlayRandomSound();

	//-------------------------------------------------------------------------
	// Changing orders could result in a state change.

	function bool SetOrders( optional name NewOrders, optional Actor NewOrdersObject, optional float NewOrdersThreshold, optional Object NewOrderGiver, optional bool bAcknowledge );
} // GameEndedState

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

state @ HandleInvalidLandingState
{
	ignores EnemyNotVisible, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend; // sensory input
	ignores BeginFalling, NotifyLanded, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange; // physics
	ignores ShotFiredNotification;
	ignores DamageAttitudeTo, EnemyInLeapRange, EnemyInMeleeRange;

	//-------------------------------------------------------------------------
	
	function EnemyAcquired();

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

	function HandledInvalidLanding()
	{
		#debug   UpdateBehavior( true, GetContext() );
		#release UpdateBehavior( true );
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		BehaviorController.SetBCEnabled( false );
		Super.BeginState();
	}

	//-------------------------------------------------------------------------
	
	event EndState()
	{
		Super.EndState();
		CheckBehaviorEnabled();
	}
} // HandleInvalidLandingState

//-----------------------------------------------------------------------------
// NPC wants to (or has been ordered to) "hold" some location (OrdersObject).
// This state makes sure the NPC is close enough to this location at which 
// point NPC will transition to HoldingState. This is done without checking
// for LineOfSight to the Hold location (mdf-tbd: this seems like it has 
// potential for being a bug if the Hold location is on the other side of a
// wall for example)?

state @ HoldState
{
	//-------------------------------------------------------------------------

	function FearThisSpot( Actor aSpot )
	{
		#debug DMAIA( "FearThisSpot sending NPC to wandering state" );
		Destination = Pawn.Location + 120 * Normal( Pawn.Location - aSpot.Location ); 
		GotoState( WanderingState, MoveActiveLabel ); //GS-tbd
	}

	//-------------------------------------------------------------------------
	
	function HandleHoldAtDestination(); // refactoring hack
	
	//-------------------------------------------------------------------------

	function PickDestination()
	{
		local Actor HA;

		HA = GetHoldActor();
				
		#debug DMAIA( "PickDestination - HA: " $ HA );

		if( HA == None )
		{
			#debug DMAI( "PickDestination -- HA isn't a HoldSpot -- might go freelancing???" );
			#debug DMAI( "SetOrders " $ GetContext() );
			if( !bStationary )
				SetOrders( OrdersNone );
			bStationary = false;
			GotoState( DefaultState ); //GS-tbd
		} 
		else if( AtDestinationActor( HA ) )
		{
			#debug DMAI( "PickDestination -- close to HA go to HoldingState" );
			HandleHoldAtDestination();
			GotoState( HoldingState, WavingLabel ); //GS-tbd (allow hold and holding to work together?)
		}
		else
		{
			#debug DMAI( "PickDestination -- finding a path to HA" );
			GetPathToActor( HA, MoveTarget, true );
			if( MoveTarget == None ) 
			{
				#debug DMAI( "no path -- clearing orders and going to default state " $ GetContext() );
				SetOrders( OrdersNone );
				GotoState( DefaultState ); //GS-tbd
			} 
		}
	}

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

@ BeginLabel:
@ MovePickDestLabel:
	WaitForLanding();
	PickDestination();

@ MoveActiveLabel:
	if( MoveTarget == None )
	{
		#debug DMAIM( "Hold -- no MoveTarget?" );
		StopMovement( true, false );
		Sleep( 0.1 );
		Goto( MovePickDestLabel );
	}

	// try to get within 8 units in call to MoveToActor, but PickDestination may decide destination reached before this
	#debug DMAIM( "Hold -- moving toward " $ MoveTarget );
	MoveToActor( MoveTarget, TMT_None, , HoldReachedDistance2D );
	Goto( MovePickDestLabel );
} // HoldState

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

/* 
mdf-tbd: currently requires that the NPC has been ordered to hold at some
OrdersObject. Could be useful for basic NPCs, but not through Orders and 
currently relies on Roaming state to sent NPC to hold/holding state (current
basic wandering state won't do this?
*/

state @ HoldingState
{
	//-------------------------------------------------------------------------

	event bool NotifyLanded( vector HitNormal )
	{
		SetPhysics( PHYS_None );
		return true;
	}

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

	function bool CheckHoldActor()
	{
		local Actor HA;

		HA = GetHoldActor();
		
		if( HA == None )
		{
			#debug DMAI( "give up hold" );
			#debug DMAI( "SetOrders " $ GetContext() );
			if( !bStationary )
				SetOrders( OrdersNone );
			bStationary = false;
		} 
		else if( HoldSpot(HA) != None )
		{
			HoldSpot(HA).Holder = Pawn;
		}
		
		return ( HA != None );
	}

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

	function SetFocus()
	{
		local Actor HA;

		HA = GetHoldActor();
		
		Focus = None;
		MoveTarget = None;
		FocalPoint = HA.Location + 1000 * vector(HA.Rotation);
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		StopMovement( true, false );
		RestoreAlertness();
	}

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

	event EndState()
	{
		local Actor HA;
		
		if( !bStationary )
		{
			HA = GetHoldActor();
			ClearHoldSpot( HA );
		}
	}

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

@ BeginLabel:
	if( !CheckHoldActor() )
		GotoState( DefaultState ); //GS-tbd

@ WavingLabel:
	// mdf-tbd:
	if( bStationary && LPawn.GetStance() != StationaryStance )
	{
		//DMTN( "Setting stance to:" $ StationaryStance );
		LPawn.SetStance( StationaryStance );
	}
	//!!mdf-tbd: 
	//else 
		//have properties control odds of standing / crouching / going prone 

	// match holdspot's rotation if was ordered to it (stationary NPCs maintain their current rotation)
	// no -- just keep NPC in stakeout longer but once back to holding, restore rotation?
	SetFocus();
	//AddArrow( Pawn.Location, FocalPoint, ColorMagenta() );
	//Sleep( 2.5 ); replace with FinishRotation?
	FinishRotation( DefaultRotationThreshold );

	// Let NPC wander around once he reaches the holdspot (he'll periodically 
	// go back to it via hold/holding and this should be ok.
	if( IsMobile() )	
		GotoState( DefaultState );

	Stop;	
} // HoldingState

//-----------------------------------------------------------------------------
// Impaling attack behavior

state @ ImpalingState
{
	ignores BeginFalling, SeeEnemy, SeeFriend, SeeAlertFriend, SeeOther, NotifyBump, HearNoise, EnemyNotVisible; 
	ignores NotifyLanded, DamageAttitudeTo, EnemyInMeleeRange, NotifyHitWall/*, eventTakeDamage*/;

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

	function PlayRandomSound();
	function bool CanFire( bool bTest )	{ return false; } // mib-tbd: impaler shouldn't be shooting (allowable on unimpaling)
	function bool IsImpaling() { return true; }
	#debug   function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr );
	#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo );
	function bool FaceTarget( float F ) { return false; }

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

	event Tick( float DeltaTime )
	{
		Super.Tick( DeltaTime );
		ControllerEnemy.UpdateMountPhysics();
	}
	
	//-------------------------------------------------------------------------
	
	function ImpaleAttackAbort()
	{
		ImpaleAttackAnimationAbort();
		if( ImpaleVictim != None )
			UnImpalePawn();
		#debug   BehaviorController.Update( BC_AttackUpdate, GetContext() );
		#release BehaviorController.Update( BC_AttackUpdate );
	}
	
	//-------------------------------------------------------------------------
	
	event EnemyNotInMeleeRange()
	{
		if( ImpaleVictim == None )
			ImpaleAttackAbort();
	}

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

	function HandleKnockDown()
	{
		ImpaleAttackAnimationAbort();
		Global.HandleKnockDown();
	}

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

	function ImpalePawn()
	{
		local U2PlayerController U2PC;
		
		ImpaleVictim = ControllerEnemy;

		//DMTNS( "ImpalePawn: " $ ImpaleVictim );

		if( !ValidEnemy( ImpaleVictim ) || !CheckMeleeAttackRange( ImpaleVictim ) )
		{
			ImpaleAttackAbort();
		}
		else
		{
			EnableRotation( false );
			ImpaleVictim.SetCollision( false, false, false );

			U2PC = U2PlayerController( ImpaleVictim.Controller );
			if( U2PC != None )
			{
				U2PC.NotifyImpaled();
				U2PC.ClientFlash( class'Fell'.default.FlashScale*20, class'Fell'.default.FlashFog*20 );
				class'UtilGame'.static.MakeShake( ImpaleVictim, ImpaleVictim.Location, 512, U2PBasic.ImpaleAttachShakeMag, U2PBasic.ImpaleAttachShakeSecs );
			}

			ImpaleMountVictim( ImpaleVictim );

			U2PBasic.MeleeDamageTarget( U2PBasic.ImpaleAttachDamage, 0.0, Class'DamageTypePhysical' );

			StopMovement( true, true );
			Focus = None;
		}
	}

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

	function ImpaleMountVictim( Pawn Victim )
	{
		Victim.MountOrgRotation=rot(0,32768,0);
		Victim.MountParentNode = U2PBasic.ImpaleMountNode;
		Victim.SetPhysics(PHYS_MovingBrush);
		if( Pawn.Weapon != None )
			Victim.MountSetParent(Pawn.Weapon);
		else
			Victim.MountSetParent(Pawn);
	}

	//-------------------------------------------------------------------------
	
	function ImpaleUnMountVictim( Pawn Victim )
	{
		Victim.MountOrgRotation=rot(0,0,0);
		Victim.MountOrgLocation=vect(0,0,0);
		Victim.MountParentNode = "";
		Victim.SetPhysics(PHYS_Falling);
		Victim.MountSetParent(None);
	}

	//-------------------------------------------------------------------------
	
	function ImpaleSetLaunchVector( Pawn Victim )
	{
		// get the orientation of the mount point I'm attached to
		//!! CDH (mib): replace with mount node rotation accessor
		local LookTarget MountDummy;

		if( Pawn != None )
		{
			MountDummy = Spawn( class'LookTarget', Self );
			MountDummy.MountParentNode = U2PBasic.ImpaleMountNode;
			MountDummy.SetPhysics( PHYS_MovingBrush );
			if( Pawn.Weapon != None )
				MountDummy.MountSetParent( Pawn.Weapon );
			else
				MountDummy.MountSetParent( Pawn );
			MountDummy.UpdateMountPhysics();
			Victim.Velocity = vector( MountDummy.Rotation );
			MountDummy.Destroy();
			MountDummy = None;
		}
	}

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

	function UnImpalePawn()
	{
		//DMTNS( "UnImpalePawn: " $ ImpaleVictim );
		if( ImpaleVictim != None )
		{
			if( U2PlayerController(ImpaleVictim.Controller) != None )
				U2PlayerController(ImpaleVictim.Controller).NotifyUnImpaled();

			ImpaleUnMountVictim( ImpaleVictim );
			ImpaleSetLaunchVector( ImpaleVictim );
			ImpaleVictim.Velocity = ImpaleVictim.Velocity * U2PBasic.ImpaleDetachMomentum;
			ImpaleVictim.SetCollision( true, true, true );
			EnableRotation( true );
			ImpaleVictim.bRotateToDesired = ImpaleVictim.default.bRotateToDesired;

			class'UtilGame'.static.MakeShake( ImpaleVictim, ImpaleVictim.Location, 512, U2PBasic.ImpaleDetachShakeMag, U2PBasic.ImpaleDetachShakeSecs );
			//U2PBasic.MeleeDamageTarget( U2PBasic.ImpaleDetachDamage, 0, Class'DamageTypePhysical' );
			U2PBasic.MeleeDamageTarget( U2PBasic.ImpaleDetachDamage, U2PBasic.ImpaleDetachMomentum, Class'DamageTypePhysical' );
			
			ImpaleVictim = None;
		}
		
		#debug   UpdateBehavior( true, GetContext() );
		#release UpdateBehavior( true );
	}

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

	event BeginState()
	{
		//#debug DMAIA( "Impaling BeginState" );
		// start the impale animation
		// we don't want to get yanked out of this state by the BC
		BehaviorController.SetMinTimeOutDelay( U2P.AnimationController.SpecialAnimationImpaleAttack() );
		BehaviorController.SetBCEnabled( false );
		StopMovement( true, true );
	}

	//-------------------------------------------------------------------------
	
	event EndState()
	{
		//DMTNS( "Impaling EndState" );
		UnImpalePawn();
		CheckBehaviorEnabled();
	}
} // ImpalingState
	
//-----------------------------------------------------------------------------

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

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

	function PlayRandomSound();
	function bool CanFire( bool bTest ) { return false; }
	function bool CanDodge( optional bool bIgnoreFalling ) { return false; }
	function EnemyAcquired();
	function HandlePanic(); // make sure no panic until knockdown done (takes precendence)

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

	function float KnockDownAnim()
	{
		local float KnockDownTime;
		
		KnockDownTime = U2P.AnimationController.SpecialAnimationDamageKnockDown();
		if (KnockDownTime == 0.0)
		{
			DMTNS( "WARNING - no knockdown animation for " $ Pawn $ " AnimSequence: " $ Pawn.AnimSequence );
			KnockDownTime = 1.0;
		}
		
		return KnockDownTime;
	}
	
	//-------------------------------------------------------------------------

	function bool CanDoRagdollHit() { return false; }

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

	event BeginState()
	{
		//DMTNS( "BeginState Physics: " $ EnumStr( enum'EPhysics', Pawn.Physics ) $ " Velocity: " $ Pawn.Velocity $ " Health: " $ Pawn.Health );
		#debug   StopFiring( 0.5, SFI_Behavior, GetContext() );
		#release StopFiring( 0.5, SFI_Behavior );
		EnableRotation( false );
		BehaviorController.SetBCEnabled( false );
		LPawn.bSpecialHardLandings = false; // leaving this on can cause a state change, circumventing the knockdown anim below
	}

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

	event EndState()
	{
		//if( Pawn != None )
		//	DMTNS( "EndState Physics: " $ EnumStr( enum'EPhysics', Pawn.Physics ) $ " Velocity: " $ Pawn.Velocity $ " Health: " $ Pawn.Health );
		//else
		//	DMTNS( "EndState" );

		EnableRotation( true );
		UnlockAnimationController();
		if( LPawn != None )
			LPawn.bSpecialHardLandings = LPawn.default.bSpecialHardLandings;
		DodgeEnableTime = Level.TimeSeconds + 0.25;
		CheckBehaviorEnabled();
	}
			
	//-------------------------------------------------------------------------
	
@ BeginLabel:
	//DMTNS( "damage launch" );	
	U2P.AnimationController.SpecialAnimationDamageLaunch();
	//DMTNS( "wait for landing" );
	WaitForLanding();
	StopMovement( true, false );
	
	//DMTNS( "sleep 5.0" );
	//Sleep( 5.0 );
	//DMTNS( "KnockDownAnim" );	
	Sleep( KnockDownAnim() );
	#debug   UpdateBehavior( true, GetContext() );
	#release UpdateBehavior( true );
} // KnockDownState

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

state @ ScriptedState
{
	//-------------------------------------------------------------------------

	function EnemyAcquired()
	{
		// script might block reacting to enemy...
		AutoBegin( '', '' );
	}

	//-------------------------------------------------------------------------
	// If above call to AutoBegin is reflected back to this function then the
	// script is allowing the NPC to go autonomous.

	function eventAutoBegin( name DestinationState, name DestinationLabel )
	{
		#debug   BehaviorController.Update( BC_EnemyAcquired, GetContext() );
		#release BehaviorController.Update( BC_EnemyAcquired );
	}

	//-------------------------------------------------------------------------
	// mdf-tbd: how to handle blocking destinations like other Pawns etc.

	function eventBumpAll( Actor Other )
	{
		Super.eventBumpAll( Other );
		
		if( SpecialGoal != None && Other == SpecialGoal )
		{
			// If we bump the final destination generate a "destinationreached" event?
			
			//2002.11.23 !!mdf-tbd: don't spam avoid bump handling?
			//DMTNS( GetStateName() $ ": eventNotifyBump bumped SpecialGoal: " $ Other $ " time until ok to move: " $ NextScriptedMoveTime - Level.TimeSeconds );
			if( Level.TimeSeconds >= NextScriptedMoveTime )
				GotoLabel( ReachedDestinationLabel );
			/*OLD
			#debug DMAIM( GetStateName() $ ": eventNotifyBump bumped SpecialGoal -- jumping to ReachedDestination label: " $ Other );
			GotoLabel( ReachedDestinationLabel );
			*/
		}
		/*
		else if( (SpecialGoal != None) && VSize( Pawn.Location - MoveTarget.Location ) < 64.0 )
		{
			// bumped into something near movetarget -- pretend we reached it for now
			#debug DMAIM( GetStateName() $ ": eventNotifyBump bumped SpecialGoal -- jumping to ReachedDestination label: " $ Other );
			GL( ReachedDestinationLabel );
		}
		*/
	}

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

	function bool CanFire( bool bTest ) { return false; }
		
	//-------------------------------------------------------------------------

	function bool IsRepeatFire( bool bPrimary )
	{
		return ( GetSpecifiedFireRate( bPrimary ) <= U2Weapon.MaxRapidFireRate );
	}

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

	function MaybeFire( byte bUseAltMode )
	{
		bScriptPendingFire = false;
		
		#debug DMAIA( "MaybeFire: " $ bUseAltMode );
		if( IsPreparedToFire( true ) )
		{
			if( ControllerTarget == None || !NeedToTurn( ControllerTarget.Location, NeedToTurnAngleCos ) )
			{
				// tell script controller to start timing fire duration
				ScriptController.StartScriptedFiring();
	
				FireShot( bUseAltMode );
	
				#debug DMAIA( "MaybeFire: IsFiring(): " $ byte(IsFiring()) $ " (bFire=" $ bFire $ " bAltFire=" $ bAltFire $ ")" );
			}
			else
			{
				bScriptPendingFire = true;
				bScriptPendingFireUseAltMode = bUseAltMode;
				GotoLabel( TurnLabel );
				#debug DMAIA( "MaybeFire: NeedToTurn -- can't fire" );
			}
		}
		else
		{
			#debug DMAIA( "MaybeFire: not prepared for attack?" );
			#debug DMAIA( "  Weapon: " $ Pawn.Weapon );
			#debug DMAIA( "  IsPreparedToFire: " $ IsPreparedToFire( true ) );
		}
	}

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

	function HandleFinishedRotation()
	{
		if( bScriptPendingFire )
			GotoLabel( FireLabel );
		else
			Super.HandleFinishedRotation();
	}

	//-------------------------------------------------------------------------
	
	function StopFiringUpdate( float SuggestedFireAgainDelay )
	{
		// disabled when firing at a special target under script control?
		// no -- just always disable (special target doesn't have to be set)?
		//if( ControllerTarget == None )
		//	Global.StopFiringUpdate( SuggestedFireAgainDelay );
	}

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

	function Actor GetTarget()
	{
		// special target takes priority when under script control
		if( ControllerTarget != None )
			return ControllerTarget;
		else
			return ControllerEnemy;
	}

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

	function float TimeSinceTargetLastSeen( Actor TargetActor )
	{
		return 0.0;
	}
	
	//-------------------------------------------------------------------------

	function bool TryToHit( 
		Actor TargetActor, 
		float TargetDistance,
		float SpreadDegrees,
		bool bLOSToTarget, 
		float TryToHitBaseOddsMin, 
		float TryToHitBaseOddsMax, 
		float TryToHitBaseDistance, 
		float TryToHitMinMissDistance, 
		float TryToHitMaxHitDistance )
	{
		if( ScriptedAimOdds < 0.0 )
		{
			return Super.TryToHit( 
							TargetActor, 
							TargetDistance, 
							SpreadDegrees,
							bLOSToTarget, 
							TryToHitBaseOddsMin, 
							TryToHitBaseOddsMax, 
							TryToHitBaseDistance, 
							TryToHitMinMissDistance, 
							TryToHitMaxHitDistance );
		}
		else
		{
			return FDecision( ScriptedAimOdds );
		}
	}
	
	//-------------------------------------------------------------------------

	function bool ShouldTryToLead( Actor TargetActor, float TargetDistance, bool bTrySplash )
	{
		return true;
	}
	
	//-------------------------------------------------------------------------

	function bool TestAimLocation( vector ProjStart, float ProjSpeed, Actor TargetActor, vector AimLocation, float MaxMissDistance, bool bCanHitOtherPawns )
	{
		return true; // never fail to fire if firing under script control?
	}
	
	//-------------------------------------------------------------------------

	function bool AdjustAim( class<Projectile> ProjectileClass, float ProjSpeed, vector ProjStart, float WeaponFireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
	{
		#debug DMAIA( "AdjustAim: " $ ControllerTarget );
		Global.AdjustAim( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, bLeadTarget, bWarnTarget, bTossed, bTrySplash );
		
		// always return true for scripted firing?
		return true;
	}

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

	event BeginState()
	{
		//DMTNS( "BeginState: clearing Enemy and OldEnemy" );
		// 2002.12.14 (mdf) if we are going scripted (e.g. no more enemy or
		// SetScript called with a new script), make *sure* any enemy(s) cleared
		// and shut down the behavior controller.
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		OldControllerEnemy = None;
		UpdateEnemy( false );
		
		Super.BeginState();
	}
	
	//-------------------------------------------------------------------------

@ FireLabel:
	#debug DMAI( "FireLabel: " $ bScriptedIdleAnims );

	if( bScriptPendingFire )
	{
		MaybeFire( bScriptPendingFireUseAltMode );
		// mdf-this shouldn't be necessary (but it still seems to be for E3...)
		Sleep( 0.5 ); // mdf-tbr: FinishAnim not waiting?
		Goto( FireLabel );
	}

	if( Orders == OrdersFollow || Pawn(GetSpecialGoal()) != None )
	{
		Sleep( 1.5 );
		Goto( BeginLabel );
	}

	Stop;
} // ScriptedState

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

state @ TestMoveState
{
	ignores EnemyNotVisible;

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

	event BeginState()
	{
		Super.BeginState();
		SetOrdersObject( TestMoveTarget ); // so it shows up in the debug menu
	}
}
	
//-----------------------------------------------------------------------------

state @ WanderingState
{
	ignores EnemyNotVisible;

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

	function FearThisSpot( Actor aSpot )
	{
		Destination = Pawn.Location + 120 * Normal( Pawn.Location - aSpot.Location ); 
	}

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

	function float GetExtraWanderDistance()
	{
		local float OrderObjectDistance, MinDistance;
		local Actor ActualOrdersObject;
		
		if( Orders == OrdersFollow )
		{
			if( Controller(OrdersObject) != None )
				ActualOrdersObject = Controller(OrdersObject).Pawn;
			else
				ActualOrdersObject = OrdersObject;
			
			//!!mdf-tbd: orders shouldn't be handled in wandering (roaming?)
			OrderObjectDistance = VSize( Pawn.Location - ActualOrdersObject.Location );
			
			if( Pawn(ActualOrdersObject) != None )
				MinDistance = 256.0;
			else
				MinDistance = 32.0;
			
			if( OrderObjectDistance < MinDistance )
				return 0.0; // close enough?
			else
				return FMin( OrderObjectDistance - MinDistance, 200 + 6*Pawn.CollisionRadius );
		}
		else
		{
			return Super.GetExtraWanderDistance(); //!!mdf was: ( 450 + 12*Pawn.CollisionRadius );
		}
	}

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

	function SetWanderMoveSpeed()
	{
		if( OrdersObject != None )
			WanderMoveSpeed = 1.0;
		else
			Super.SetWanderMoveSpeed();
	}
	
	//-------------------------------------------------------------------------

	function bool ShouldWanderPause()
	{
		return ( OrdersObject == None && Super.ShouldWanderPause() );
	}
	
	//-------------------------------------------------------------------------
	
	function bool PickDestination()
	{
		local Actor LocalMoveTarget;
		
		if( OrdersObject != None )
			GetPathToActor( OrdersObject, LocalMoveTarget, true );
		
		if( LocalMoveTarget == None )
			return Super.PickDestination();
		
		Destination = LocalMoveTarget.Location;
		return true;
	}
} // WanderingState

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

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

	//-------------------------------------------------------------------------
	
	function EndPanic()
	{
		#debug   UpdateBehavior( true, GetContext() );
		#release UpdateBehavior( true );
		Global.EndPanic();
	}
	
	//-------------------------------------------------------------------------
	
	event BeginState()
	{
		BehaviorController.SetBCEnabled( false );
		Super.BeginState();
	}
	
	//-------------------------------------------------------------------------
	
	event EndState()
	{
		Super.EndState();
		CheckBehaviorEnabled();
	}
}
	
//-----------------------------------------------------------------------------

defaultproperties
{
	Aggressiveness=0.300000
	VerifyCoverRate=0.500000
	ExecuteOrdersThreshold=0.500000
	BehaviorControllerClass=Class'U2AI.BehaviorControllerBasic'
	DefaultAcquisitionState='Acquisition'
	DefaultDeadLockedState='DeadLocked'
	DefaultImmobileState='hold'
	DefaultImmobileAttackState='AttackStationary'
	MaxFallbackNoDetectTime=5.000000
	MaxHuntTime=30.000000
	LeapMinHitWallDelay=0.200000
	bProbeHearNoise=true
	bProbeNotifyBump=true
	bProbeEnemyInMeleeRange=true
	bProbeSeeEnemy=true
	CosMinFacingTargetAngle=0.866000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}