U2AIOld.U2NPCControllerBaseOld

//=============================================================================
// U2NPCControllerBaseOld.uc
// Created By: Steve Polge, Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 12/17/02 8:33p $
// $Revision: 56 $
//=============================================================================

//NOTE (mdf): U2AIOld used for bot support only

class U2NPCControllerBaseOld extends U2NPCControllerShared
	config(User);

/*-----------------------------------------------------------------------------
Orders:

For the time being I'm keeping Orders support here so these can be used by both
advanced and basic creatures. Afaik, there will be no need for basic NPCs to
be ordered by the player, but internally, or through scripting, we may need to
use some of these:

Pbly need:
	follow:		designate one NPC as a leader and the others follow that one
	here:		used for testing
	hold:		stay in some general area
	none:		freelancing
	
Not sure:
	attack:		not applicable except for bots in team games?
	defend:		not applicable except for bots in team games?

Afaik, all of the ReplicationInfo stuff should be moved down to the bot code. 
Unless we are going to need to replicate order-related info for basic NPCs in 
multiplayer games, or if we want clients to be able to see the internal orders
for basic NPCs this should only be needed for bots (when players want to see
what their bot teammates' orders are). The PRI also contains a bunch of other
stuff related to players' scores etc. which should be totally irrelevant for
basic NPCs.

bIsPlayer BS:

Currently NPCs with !bIsPlayer:
	+have somewhat reduced ability to see other Pawns (tbd)
	+have somewhat reduced LOS checks (tbd)
	+won't show themselves to other non-players (fixed? and tbd)
	+won't be heard by other NPCs unless has a player enemy or tags match (tbd)
	+won't hear some sounds played through PlaySound
	+won't use R_PLAYERONLY paths (obsolete?)
	+have lower net priority (ok?)
	+can't be outside of the game world in some cases (ok?)

Ideally, this would only be set for real (human) players and bots but I 
currently have this set for advanced NPCs because:

	+these need to
		+be able to react to other NPCs, including monsters
		+should have good visibility checks

*/

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

Replacing all occurences of 'TeamCannon' (doesn't exist in U2 or UW) with
StationaryPawn -- see comments there for more info.

Keep here:
	Stationary Pawn code -- might want some Basic NPCs (e.g. Araknids) to be
	able to react to these (attack/avoid etc.) if they are smart enough.

Move to U2NPCControllerAdvancedOld:
	weapon code (add interface here, extend using weapon code in Advanced)

Move to U2NPCControllerBotOld:
	teamgame code
	anything bIsPlayer related (unless it should be generalized to base/advanced classes

+clean up timer mess

+bots would be more fun if they would choose somewhat randomly among weapons
 which have more or less the same AIRating. Currently one weapon will tend
 to completely dominate.

+really need code (especially if above done) so that bot will prefer to
 keep current selection (high odds initially, decreasing with time, 
 possibly according to success vs current enemy). Currently, bot often
 rapidly switching between alt/pri fire for example.


=== misc todo ===

+wtf is up with mesh offsets (see U2MarineLight in TestU2). The feet seem to 
be almost 16 units below the CC, with the head not poking out at all. -- 

Reference pose only?

=== Todo ===

Where did polyc go?

Orders: NPCs without PRI's will need to store RealOrders elsewhere in case, say, they go freelancing 
then want to return to their original Orders.

=== Misc ===

Should Triggers be placeable?

Can we adopt "Super" with an uppercase "S" as the standard -- of the 430 or so uses of this 
in the script code about 410 of these are using "Super" with only a few cases using "super".
This would make these always be syntax-colored correctly (currently the "standard" in 
usertype.dat uses "S"). Same for "Global"...

(I personally don't care which but since most of the existing cases are using Super...).

Same with self/Self (mostly using Self currently but lots of engine uses of self, so either
way is fine with me...).

=== Thoughts ===

We should really support team dm if possible (potentially not more than a day's work 
and provides a nice option).

Would be neat if NPCs could destroy pickups which they don't use (bPlayerOnly pickups etc.) but 
this would mean having support for damageable pickups and maybe showing damage with smoke. This
is pretty similar to how the translocator worked in UT.

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

+base controller supports dialog so non-weapon using NPCs (like the seagoat) can
be ordered

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

// state name consts exclusive to (old) U2AI
const AttackingState					= 'Attacking';				// master attack state -- decide what to do
const FallingState						= 'Falling';				// falling	
const TakeHitState						= 'TakeHit';				// reacting to taking a hit

// label name consts exclusive to (old) U2AI
const ContinueWanderLabel				= 'ContinueWander';
const FallSpecialLabel					= 'FallSpecial';
const FallLongLabel						= 'FallLong';
const FireWhileFallingLabel				= 'FallWhileFiring';
const LandedLabel						= 'Landed';
const PausingLabel						= 'Pausing';
const PlayOutLabel						= 'PlayOut';
const SplashLabel						= 'Splash';
const TakeHitLabel						= 'TakeHit';

const NonRangedFireTimerName			= 'NonRangedFireTimer';

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

const HoldReachedDistance2D				=  16.0;
const HoldReachedDistanceSquared2D		= 256.0;

const MinMoveSpeedMultiplier			=  0.05;	// min movement speed for scripting

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

var name DefaultMeleeAttackState;	// state used to carry out melee attacks (UT bots basically closed until weapon close enough to discharge)

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

var float MaxHuntTime;
var int MaxMoveToActorAttemptsRoaming;

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

// orders
var name	Orders;						// orders a bot is carrying out 
var	Actor	OrdersObject;				// object referred to by orders ( if applicable )
var Object  OrderGiver;					// source of orders (e.g. player, GameAIController)

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

// internal AI flags
var bool	bBigJump;
var bool	bCamping;					
var bool	bCampOnlyOnce;
var bool	bChangeDir;					// tactical move boolean
var bool	bClearShot;					
var bool	bDeviousHunting;			// if true, try to sneak up behind enemy when hunting
var bool	bFireFalling;
var bool	bFiringPaused;				//!!mdf-tbd: pbly broken at this point...
var bool	bFrustrated;				
var bool	bGathering;					
var bool	bInitLifeMessage;
var bool	bIsPaused;					// is the script paused? (i.e. by dialog)
var bool	bKamikaze;					
var bool	bLeading;					// set when NPC attacking and has followers
var bool	bMustHunt;
var bool	bNoShootDecor;				// set to true to prevent NPC from targetting a decoration 2x within Roaming state (cleared on entering Roaming state)
var bool	bReadyToAttack;				// can attack again 
var bool	bSniping;					// mdf-tbd: approach changed in 777?
var bool	bStationary;				// if set NPC can only rotate/aim
var bool	bStayFreelance;				// in UT was used by assault to force bot to stay freelancing? Never true currently.
var bool	bStrafeDir;					
var bool	bTriedLastDetectedLocation; // used with hunting state
var bool	bWantsToCamp;				

var float LastInvFind;
var float RefireDelay;

var name LastPainAnim;
//mdf-tbe: moved to "shared" for now var	float LastAcquireTime;

var float CampTime;
var float LastCampCheck;
var float LastAttractCheck;
var Ambushpoint AmbushSpot;				// current AmbushSpot if applicable
var Actor RoamTarget;					// current goal actor for roaming state if applicable
var Actor OldMoveTarget;

var NavigationPoint BlockedPath;
var vector RealLastDetectedLocation;

var name NextState, NextLabel;			// mdf-tbd: can we eliminate these (see 777+ approach)?

//mdf-tbd: not used? 
//var float Rating;
//var name RealState, RealLabel;
//var bool	bSpecialAmbush;
//var bool	bPowerPlay;
//var bool	bViewTarget;				// is being used as a viewtarget
//var AlternatePath AlternatePath;		// used by game AI for team games with bases
var bool  bGoosedTimer;					// !!mdf hack
var float AttackStationaryStopTime;

var float AttackNonRangedCheckRate;		// rate at which to check for firing situation in attack states apart from ranged attack
var float AttackNonRangedFailedRate;	// inreased rate to use if check at AttackNonRangedCheckRate failed
var float AttackReadyToAttackOdds;		// !!mdf hack
var float TimeBetweenAttacks;			// seconds - modified by difficulty (not used with new ai)

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

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

	ErrorStr = "";

	// ignore transitions within the same state for now?
	if( NewState != OldState )
	{
		switch( NewState )
		{
		case AttackStationaryState:
			if( !IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
				ErrorStr = "transition to ranged attack when not prepared!";
			break;

		case AttackMeleeState:
			if( !IsPreparedToMelee( true, true, U2Weapon.RatingIneffective ) )
				ErrorStr = "transition to melee attack when not prepared!";
			break;
		}
	}

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

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

	if( bStationary )
	{
		if( AssignHoldSpot( Pawn ) ) // 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; }

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

function bool AssignHoldSpot( Actor LocationActor )
{
	local HoldSpot HS;

	HS = LocationActor.Spawn( class'HoldSpot' );

	if( HS != None )
	{
		if( HoldSpot(OrdersObject) != None )
			OrdersObject.Destroy();
		OrdersObject = HS;
	}
	else
	{
		#debug DMAI( "Can't create holdspot at given location" );
	}

	return ( HS != None );
}

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

event Destroyed()
{
	#debug DMAIA( "Calling RemoveAllTimers" );
	RemoveAllTimers();
	ClearHoldSpots();
	Super.Destroyed();
}

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

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

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

function ResetGlobalAISettings()
{
	bFire = 0;
	bAltFire = 0;
	bKamikaze = false;
	BlockedPath = None;
}

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

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

	#debug DMAI( "Restart" );
	GotoState( DefaultState );
}

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

function Possess( Pawn P )
{
	#debug DMAI( "Possess" );

	Super.Possess( P );

	P.PreSetMovement();
	
	SetPeripheralVision();

	Aggressiveness = U2PBasic.BaseAggressiveness;

	// preserve Pawn's rotation initially for placed Pawns
	FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);

	Pawn.SetMovementPhysics(); 
	if( Pawn.Physics == PHYS_Walking )
		Pawn.SetPhysics( PHYS_Falling );
	Enable( Event_NotifyBump );

	AssignScriptController();

	#debug DMAI( "Possess: Controller=" $ Self $ " Pawn=" $ Pawn $ " script controller=" $ ScriptController );

	//!!mdf hack
	//DMTNS( "AddTimer in Possess: " $ AttackNonRangedCheckRate );
	AddTimer( NonRangedFireTimerName, AttackNonRangedCheckRate, true );

	if( U2PBase.bFrozen )
	{
		SetFrozen( true ); // mainly for looking at animations in-game
	}
	else 
	{
		if( U2PBase.bStationary )
			SetStationary( true );
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
}

//-----------------------------------------------------------------------------
/* mdf-tbd:
event PreBeginPlay()
{
	Super.PreBeginPlay();
	//bInitialFear = ( Pawn.ReactionToPlayer == REACTION_Fear );
}
*/

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

/*
mdf-tbr: for testing
event PostBeginPlay()
{
	Super.PostBeginPlay();
}
*/

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

function EnemyAcquired()
{
	GotoState( AcquisitionState );
}

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

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

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

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

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

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

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

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

function SharedTimerEvent()
{
	#debug DMAIA( "Global.SharedTimerEvent called (event will be ignored)" );
}

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

function bool IsMeleeAttacking()
{
	return false;
}

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

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

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

function float GetAttackStyle( Actor TargetActor )
{
	return 0.0;
}

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

function MaybeStopFiring( optional float SuggestedFireAgainDelay )
{
	if( GetCurrentFireRate() > U2Weapon.MaxRapidFireRate )
	{
		#debug   StopFiring( SuggestedFireAgainDelay, SFI_Behavior, GetContext() );
		#release StopFiring( SuggestedFireAgainDelay, SFI_Behavior );
	}
}

//-----------------------------------------------------------------------------
//!!mdf hack return true if should up timer rate

function bool NonRangedFireCheck()
{
	local bool bGooseTimer;

	//if( ControllerEnemy != None )
	if( ControllerEnemy != None && (bFire + bAltFire) == 0 )
	{
		if( CanFire( false ) && IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
		{
			//if( Pawn.IsA( 'U2Izarian' ) )
			//	DMTNS( "  NonRangedFireCheck calling CombatMove" );
			CombatMove();
		}
		/*
		else
		{
			bFire = 0;
			bAltFire = 0;
		}
		*/

		bGooseTimer = ( (bFire + bAltFire) == 0 );
		
	}

	return bGooseTimer;
}

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

final function NonRangedFireTimer()
{
	local bool bGooseTimer;

	//DMTNS( "==> NonRangedFireTimer  bGoosedTimer: " $ bGoosedTimer );
	bGooseTimer = NonRangedFireCheck();

	if( bGoosedTimer != bGooseTimer )
	{
		if( bGooseTimer )
		{
			//DMTNS( "  AddTimer 0.1" );
			AddTimer( NonRangedFireTimerName, AttackNonRangedFailedRate, true );
			bGoosedTimer = true;
		}
		else
		{
			AddTimer( NonRangedFireTimerName, AttackNonRangedCheckRate, true );
			bGoosedTimer = false;
		}
	}
}

//-----------------------------------------------------------------------------
// Returns true if the NPC is "prepared", e.g. has a good enough weapon and 
// enough inventory and Health to carry out the orders, go hunting etc. Returns 
// true by default subclasses can override this as necessary.

// mdf-tbd: add a "risk" parameter to indicate how "well-stocked" NPC should
// be and scale return value accordingly in subclasses. Maybe also path in
// a minimum  Health amount (percentage of max Health)?

function bool ReadyForAction()
{
	return true;
}

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

function bool ReadyForOrders()
{
	return true;
}

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

function bool CanMeleeAttack()
{
	// check Weapon.bMeleeWeapon / in inventory?
	return false;
}

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

function bool ShouldTransitionToMeleeAttack()
{
	#debug DMAI( "ShouldTransitionToMeleeAttack" );
	return CanMeleeAttack();
}

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

function bool SpecialAttackTransition()
{
	return false;
}

//-----------------------------------------------------------------------------
// Should be implemented in subclasses which use weapons to support weapon
// firing. NPCs which have notification based ranged attacks will fire their
// projectiles though their animations.

function FireShot( byte bUseAltMode );

function ResetAttackTimer( float SuggestedFireAgainDelay )
{
	local float TimerTime;

	if( SuggestedFireAgainDelay <= 0.0 )
	{
		// if there is time left on the timer, leave it alone
		if( TimerCounter > 0.0 )
			return;

		SuggestedFireAgainDelay = TimeBetweenAttacks;
	}

	TimerTime = (0.5 + 0.5 * FRand()) * SuggestedFireAgainDelay;
	
	// mdf-tbd: pretty much impossible to know what this
	// does unless you understand the code intimately -- who handles this timer?
	// NOTE: In retreating state this doesn't seem to result in a check for
	// being able to fire once the time is up but other states seem to be 
	// reacting fairly well. I'd much rather see this map to a global "check
	// whether should fire now" timer.
	SetSharedTimer( TimerTime, false );
}

//-----------------------------------------------------------------------------
// Stop the actual attack animation / weapon firing.

protected function ClearAttack()
{
}

//-----------------------------------------------------------------------------
// Specified time used to determine when NPC next checks for being able to
// attack (defaults to TimeBetweenAttacks).
// 
// If bDisabled = true, then NPC won't be able to fire for a while because the
// weapon is changing or the NPC isn't facing his enemy.

#debug function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr )
#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo )
{
	#debug DMAIA( "StopFiring base (" $ ContextStr $ "): " $ SuggestedFireAgainDelay );

	//mdf-tbd: LastFireTime = -1.0;
	U2P.AnimationController.SpecialAnimationClear();

	ResetAttackTimer( SuggestedFireAgainDelay );
}

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

function ChangedWeapon()
{
	local byte bUseAltMode;

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

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

function FireAt( Actor A )
{
	DMN( "FireAt() -- should be implemented in subclass!" );
}

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

function DoRangedAttack()
{
	FireAt( ControllerEnemy );
}

//-----------------------------------------------------------------------------
// combo move

function SpecialFire()
{
	bFiringPaused = true;
	NextState = AttackingState;
	NextLabel = BeginLabel; 
	StopMovement( true, false );
	GotoState( AttackStationaryState );
}

//-----------------------------------------------------------------------------
//@ INPUT -- PROCESSED EVENTS
//-----------------------------------------------------------------------------

function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	//DMTNS( "NPCCBase eventTakeDamage -- Damage" @ Damage @ "Instigator" @ Instigator @ "HitLocation" @ HitLocation @ "Momentum" @ Momentum @ "DamageType" @ DamageType );

	U2PBase.eventTakeDamage( Damage, Instigator, HitLocation, Momentum, DamageType );

	// NOTE: actual damage might be filtered out later one but we still want the NPC
	// to possibly react to having "taken damage" even if he wasn't hurt.
	if( Pawn != None && Pawn.Health > 0 ) //note: otherwise can get accessed nones due to NPC dying from damage and ScriptController getting cleared
		TookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
}

//-----------------------------------------------------------------------------
// mdf-tbi: move into eventTookDamage once I'm sure this is OK

function TookDamageBase( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	local name DestinationState;
	local name DestinationLabel;

	// mdf: don't react if dead (was resurrecting dead NPCs...)
	if( Pawn != None && Pawn.Health > 0 )
	{
		// set Instigator as enemy?
		DamageAttitudeTo( Instigator, Damage, DamageType );
	
		// mdf-tbd: does this make sense? enemy might be nowhere in sight and might not have had anything to do with the damage?
		if( ControllerEnemy != None )
			EnemyDetected( ControllerEnemy.Location );
	
		if( NextState == TakeHitState )
		{
			if( ControllerEnemy != None && GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear )
			{
				NextState = AttackRetreatState;
				NextLabel = BeginLabel;
			}
			else
			{
				NextState = AttackingState;
				NextLabel = BeginLabel;
			}
			DestinationState = TakeHitState;
		}
		else
		{
			DestinationState = AttackingState;
		}

		#debug DMAI( "TookDamageBase -- Pawn is valid (set and alive)  DestinationState: " $ DestinationState $ " DestinationLabel: " $ DestinationLabel );
		StateTransition( DestinationState, DestinationLabel ); 
	}
	else
	{
		#debug DMAI( "TookDamageBase -- Pawn is NOT valid (not set/dead)" );
	}
}

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

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

	TookDamageBase( Damage, Instigator, HitLocation, Momentum, DamageType );
}

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

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

function EReaction GetReactionToEnemy( Pawn EnemyPawn )
{
	local EReaction ReturnedReaction;
	local float CurrentRelativeStrength;
	
	if( bKamikaze )
		ReturnedReaction = REACTION_Attack;
	else if( StationaryPawn(EnemyPawn) != None  )
		ReturnedReaction = REACTION_Fear;
	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;
		}
	}
	
	//DMTNS( "GetReactionToEnemy " $ EnemyPawn $ " returning: " $ EnumStr( enum'EReaction', ReturnedReaction ) $ " bKamikaze: " $ bKamikaze $ " RelativeStrength: " $ RelativeStrength( EnemyPawn ) $ " Aggresiveness: " $ Aggressiveness );

	return ReturnedReaction;
}

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

function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
{
	if( Pawn == None || Pawn.Health <= 0 )
		return;

	if( ControllerEnemy == None && ValidEnemy( Other ) )
	{
		#debug DMAI( "DamageAttitudeTo -- calling MaybeSetEnemy" );
		if( MaybeSetEnemy( Other ) )
		{ 
			NextState = AttackingState; 
			NextLabel = BeginLabel;
		}
	}

	if( ControllerEnemy != None && ControllerEnemy == Other )
		EnemyDetected( ControllerEnemy.Location );

	if( NextState == TakeHitState )
	{
		NextState = AttackingState; 
		NextLabel = BeginLabel;
		GotoState( TakeHitState ); 
	}
	else if( ControllerEnemy != None )
		GotoState( AttackingState );
}

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

function SetRoamTarget( Actor NewRoamTarget )
{
	// should only ever be set in Roaming state
	DMAssert( false, GetContext() );
}

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

function bool UseTacticalJumps()
{
	return false;
}

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

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

	if( OldControllerEnemy == P )
		OldControllerEnemy = None;

	if( ControllerEnemy == None )
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
}

//-----------------------------------------------------------------------------
// NOTE: Killed replaced by NotifyKilled in 777 (and duplicate calls to killed
// in both Pawn.Destroy and Pawn.Died removed).

function NotifyKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType )
{
	local Controller C;

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

	if( OldControllerEnemy == KilledPawn )
		OldControllerEnemy = None;

	if( ControllerEnemy == KilledPawn )
	{
		bFire = 0;
		bAltFire = 0;

		UpdateEnemy( true );

		if( ControllerEnemy == None )
			HandleEnemyKilledSafe( Killer, KilledPawn );
		else
			HandleEnemyKilledUnSafe( Killer, KilledPawn );

		GotoState( AttackingState ); 
	}
//	else
//	{
//		DMTN( "Enemy not = KilledPawn: " $ ControllerEnemy );
//	}

	// ick: tbd -- bot can't just call super unless we change NotifyKilled to return 
	// info back to indicate whether GameRelatedKilled code should be used.
	GameRelatedKilled( Killer, Killed, KilledPawn, DamageType );
}	

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

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

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

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

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

function bool PreparedToHunt()
{
	//DMTNS( "PreparedToHunt" );
	return( GetSkill() >= 0.5 && ReadyForAction() );
}

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

function bool TestCanJump()
{
	return( (MoveTarget != None) && (MoveTarget.Physics != PHYS_Falling || Pickup(MoveTarget) == None) );
}

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

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

// stubs for functionality which only exists in bots (ideally refactor code in
// here to get rid of these, but this may turn into a ROT item).
function SendMessageAcknowledgeOrders( Controller OrderGiver, float Wait );
function SendMessageNearPoint( Pawn Point, float Wait );
function SendMessageInPosition( float Wait );
function SetRealOrders( name NewOrders, Actor NewOrdersObject, Object NewOrderGiver );
function name GetRealOrders() { return Orders; }

//-----------------------------------------------------------------------------
// 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( bVisibleAI && OrdersObject != None && OrdersObject.default.bHidden )
		HideActor( OrdersObject );

	OrdersObject = NewOrdersObject;

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

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

function UpdateOrders( name NewOrders, Object NewOrderGiver, Actor NewOrdersObject )
{
	Orders = NewOrders;
	OrderGiver = NewOrderGiver;
	SetOrdersObject( NewOrdersObject );
}

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

function HandleOrdersAttack()
{
	U2PBasic.CampingRate = 0.0;
}

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

function HandleOrdersDefend()
{
	SetOrdersObject( SetDefense() );
	if( OrdersObject == None )
	{
		#debug DMAI( " defender couldn't find defense object" );
		#debug DMAI( "SetOrders " $ GetContext() );
		SetOrders( OrdersNone, None, 0.0, OrderGiver, false );
	}
	else
	{
		U2PBasic.CampingRate = 1.0;
	}
}

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

function HandleOrdersFollow()
{
	Aggressiveness += 1;
	SetOrdersObject( Actor(OrderGiver) );
}

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

function HandleOrdersHold()
{
	Aggressiveness += 1;
	if( Controller(OrderGiver) != None )
		AssignHoldSpot( Controller(OrderGiver).Pawn );
}

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

function HandleOrdersNone()
{
	OrderGiver = None;
}

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

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

	if( Orders == OrdersHold )
	{
		DestinationState = HoldState;
	}

	return ( DestinationState != NoState );
}

/*-----------------------------------------------------------------------------
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 bValidOrders;
	local name DestinationState, DestinationLabel;

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

	//-------------------------------------------------------------------------
	// cleanup, re-initialization
	//-------------------------------------------------------------------------

	// mdf-tbd: bLeading set if given attack orders & has followers -- applies to bots only currently
	bLeading = false;

	// mdf-tbd:
	if( NewOrders != GetRealOrders() && Pawn != None )
	{ 
		// mdf-tbd: resolve polymorphically by moving into appropriate states -- don't use IsInState!
		if( (IsInState( RoamingState ) && bCamping) || IsInState( WanderingState ) )
			GotoState( RoamingState, PreBeginLabel );
	}

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

	// mdf-tbd:
	bStayFreelance = false;

	Aggressiveness = U2PBasic.BaseAggressiveness;
	if( Orders == OrdersFollow )
		Aggressiveness -= 1;

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

	//-------------------------------------------------------------------------
	// process new orders
	//-------------------------------------------------------------------------

	UpdateOrders( NewOrders, OrderGiver, NewOrdersObject );

	bValidOrders = true;
	switch( NewOrders )
	{
		case OrdersNone:
			HandleOrdersNone();
			break;

		case OrdersAttack:
			HandleOrdersAttack();
			break;

		case OrdersDefend:
			HandleOrdersDefend();
			break;

		case OrdersFollow:
			HandleOrdersFollow();
			break;

		case OrdersHold:
			HandleOrdersHold();
			break;

		default:
			bValidOrders = false;
			break;
	}

	SetRealOrders( Orders, OrdersObject, OrderGiver );

	if( bAcknowledge && Controller(OrderGiver) != None )
		SendMessageAcknowledgeOrders( Controller(OrderGiver), 5.0 );

	// respond to orders asap
	if( Orders != OrdersNone && ReadyForOrders() )
	{
		if( DetermineOrdersTransition( DestinationState, DestinationLabel ) )
			GotoState( DestinationState, DestinationLabel );
	}

	#debug DMAI( "SetOrders (end) -- Orders: " $ Orders $ " OrdersObject: " $ OrdersObject $ " OrderGiver: " $ OrderGiver );

	return bValidOrders;
}

//-----------------------------------------------------------------------------
//@ PATHING/MOVEMENT
//-----------------------------------------------------------------------------

function EMoveType GetMoveTargetFollow( Actor GoalActor, out Actor Path, optional float GoalDistance )
{
	if( GoalActor == None || GoalActor.bDeleteMe )
	{
		if( Orders == OrdersFollow )
		{
			#debug DMAI( "SetOrders " $ GetContext() );
			SetOrders( OrdersNone );
		}

		return MT_None;
	}
	else
	{
		return Super.GetMoveTargetFollow( GoalActor, Path, GoalDistance );
	}
}

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

function EMoveType SetMoveTarget( Actor GoalActor, optional float GoalDistance, optional bool bWaitForLanding )
{
	if( Orders == OrdersFollow )
		GoalActor = OrdersObject;

	return Super.SetMoveTarget( GoalActor, GoalDistance, bWaitForLanding );
}

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

function AmbushPickSpot()
{
	local NavigationPoint N;

	for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
	{
		// find closest ambush spot which isn't already taken
		// mdf-tbd: this doesn't check for whether owner of ambush spot is an enemy
		if( AmbushPoint(N) != None && !N.Taken && 
			(AmbushSpot == None || VSize( Pawn.Location - AmbushSpot.Location ) > VSize( Pawn.Location - N.Location)) )
		{
				AmbushSpot = AmbushPoint( N );
		}
	}
}

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

function AmbushClearOtherSpots()
{
	local Controller C;

	#debug DMAI( "AmbushClearOtherSpots" );
	for ( C=Level.ControllerList; C!=None; C=C.NextController )
	{
		if( U2NPCControllerBaseOld(C) != None && 
			C.Pawn != Pawn && 
			GetAttitudeTo( C.Pawn ) != ATTITUDE_Enemy && 
			U2NPCControllerBaseOld(C).AmbushSpot == AmbushSpot )
		{
			U2NPCControllerBaseOld(C).AmbushSpot = None;
		}
	}
}

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

function bool AmbushFindSpot()
{
	if( AmbushSpot == None )
		AmbushPickSpot();

	// if none found, use current MoveTarget if possible mdf-tbd: this doesn't check for whether owner of ambush spot is an enemy
	if( AmbushSpot == None && AmbushPoint(MoveTarget) != None && !AmbushPoint(MoveTarget).Taken )
		AmbushSpot = AmbushPoint( MoveTarget );
					
	if( AmbushSpot != None )
	{
		if( VSize( AmbushSpot.Location - Pawn.Location ) < 2 * Pawn.CollisionRadius )
		{
			if( Orders == OrdersDefend )
				SendMessageInPosition( 60.0 );
			bSniping = ( Orders == OrdersDefend && AmbushSpot.bSniping );
			CampTime = 10.0;
			Pawn.SetSightRadius( AmbushSpot.SightRadius );
			GotoState( RoamingState, CampLongLabel );
		}
		else
		{	
			FindPathToActor( AmbushSpot, MoveTarget );
			if( MoveTarget == None )
				AmbushSpot = None;
		}

		if( AmbushSpot != None )
		{
			AmbushSpot.Taken = true;

			// make sure nobody else is after this spot
			AmbushClearOtherSpots();
		}
	}

	return( AmbushSpot != None );
}	

//-----------------------------------------------------------------------------
//@ STATE TRANSITIONS
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Used for specific state transitions so that subclasses/states can hook into
// these.

function StateTransition( name DestinationState, optional name DestinationLabel )
{
	GotoState( DestinationState, DestinationLabel );
}

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

function UpdateEnemy( optional bool bTryRadiusCheck )
{
	if( !ValidEnemy( OldControllerEnemy ) )
		OldControllerEnemy = None;

	// mdf-tbd: this is potentially bad if the enemy is still valid but went
	// out of sight etc. and wasn't cleared. Either code which handles loss
	// of LOS, will clear enemy 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 code.
	#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
	#release SetControllerEnemy( OldControllerEnemy );
	if( !ValidEnemy( ControllerEnemy ) )
	{
		#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
		#release SetControllerEnemy( OldControllerEnemy );
		OldControllerEnemy = None;
	}

	if( ControllerEnemy == None && bTryRadiusCheck )
	{
		#debug   SetControllerEnemy( FindLocalEnemy( MaxRadiusEnemiesDistance ), GetContext() );
		#release SetControllerEnemy( FindLocalEnemy( MaxRadiusEnemiesDistance ) );
	}
}

//-----------------------------------------------------------------------------
// @ WhatToDoNext

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

	DestinationState = NoState;
	DestinationLabel = NoLabel;

	#debug DMAI( "WhatToDoNext (" $ ContextStr $ ") script controller=" $ ScriptController $ " Enemy=" $ ControllerEnemy $ " OldControllerEnemy=" $ OldControllerEnemy );

	if( !ShouldDestroyNPC() )
	{
		ResetGlobalAISettings();
		RestoreRealOrders();

		UpdateEnemy();

		// mdf-tbd: should this only be cleared if !bKeepEnemy?
		bReadyToAttack = false;

		if( ControllerEnemy != None )
		{
			bReadyToAttack = (GetSkill() >= 0.5);
			DestinationState = AttackingState;
		}
		else if( HasScript() )
		{
			if( GetStateName() == ScriptedState )
			{
				bMaintainCurrentState = true;
			}
			else
			{
				DestinationState = ScriptedState;
				DestinationLabel = BeginLabel;
			}
		}
		else if( bStationary )
		{
			DestinationState = HoldState;
		}
		else if( Orders == OrdersNone || !ReadyForOrders() || !DetermineOrdersTransition( DestinationState, DestinationLabel ) )
		{
			DestinationState = DefaultState;
			if( GetSkill() > 0.625 )
				bReadyToAttack = true; 
		}

		if( bMaintainCurrentState )
		{
			#debug DMAI( "WTDN maintaining current state: " $ GetStateName() );
		}
		else
		{
			#debug DMAI( "WTDN (base) selecting " $ DestinationState $ "," $ DestinationLabel $ " bReadyToAttack=" $ bReadyToAttack );
			GotoState( DestinationState, DestinationLabel );
		}
	}
	else
	{
		#debug DMAI( "WTDN -- NPC will be destroyed" );
	}
} // WhatToDoNext

//-----------------------------------------------------------------------------
//@ UW BOT CODE 
//-----------------------------------------------------------------------------

function HandleTakeHit( vector HitLocation, int Damage, class<DamageType> DamageType )
{
	if( Pawn.LastPainAnimTime - Level.TimeSeconds > 0.1 )
	{
		Pawn.PlayTakeHit( HitLocation, Damage, DamageType );
		BeginState();
		GotoState( TakeHitState, BeginLabel );
	}
}	
	
//-----------------------------------------------------------------------------

function NotifyTakeHit( pawn InstigatedBy, vector HitLocation, int Damage, class<DamageType> DamageType, vector Momentum )
{
	local bool bOptionalTakeHit;

	bFireFalling = false;
	bOptionalTakeHit = ( ( Level.TimeSeconds - Pawn.LastPainAnimTime > 0.3 + 0.88 * GetSkill() )
						&& (Damage * FRand() > 0.08 * Pawn.Health) && (GetSkill() < 0.625) ); 

	if( (Pawn.Weapon == None || !Pawn.Weapon.bPointing) &&  // note: makes sure that ongoing shot isn't interrupted by taking damage (or NPCs might never get shots off)
		!Pawn.JumpInProgress() && 
		(bOptionalTakeHit || (Momentum.Z > 140) || (Damage * FRand() > ( 0.17 + 0.16 * GetSkill() ) * Pawn.Health)) ) 
	{
		HandleTakeHit( HitLocation, Damage, DamageType );  

		if( Pawn.SameTeam( InstigatedBy ) )
			U2P.AssetsHelperClass.static.HandleFriendlyFire( U2Pawn(InstigatedBy), U2P );

		if( ( ControllerEnemy != None ) && ( FRand() * ( 8*GetSkill() - 4 ) > 0.5 ) )
		{
			NextState = FallingState;
			NextLabel = FireWhileFallingLabel;
		}
	}
	else if ( (Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z)
				&& (Momentum.Z/Pawn.PhysicsVolume.Gravity.Z < -0.5) )
		bFireFalling = true;
	else if( NextState == TakeHitState )
		NextState = NoState;
}

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

function Actor SetDefense()
{
	return None;
}

//-----------------------------------------------------------------------------
// 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 GiveUpTactical( bool bCanCharge );

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

function byte PriorityObjective()
{
	return 0;
}

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

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

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

function bool FindSpecialAttraction()
{
	return false;
}

//-----------------------------------------------------------------------------
// 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 bool CanFire( bool bTest ) { return true; }

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

function bool IsPreparedToFire( bool bOwner, optional bool bCheckWeaponRating, optional int MinWeaponRating )
{
	local byte bUseAltMode;

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

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

function bool IsPreparedToMelee( bool bOwner, optional bool bCheckWeaponRating, optional int MinWeaponRating )
{
	/*
	tbd: pbly want this but need to test it carefully

	local byte bUseAltMode;
	return( (!bCheckWeaponRating || Pawn.Weapon.RateSelf( ControllerEnemy, bUseAltMode ) > MinWeaponRating ) &&
			Pawn.Weapon != None && 
			Pawn.Weapon.bMeleeWeapon && 
			(!bOwner || Pawn.Weapon.CanFire()) )
	);
	*/

	return ( Pawn != None && Pawn.Weapon != None && Pawn.Weapon.bMeleeWeapon && (!bOwner || Pawn.Weapon.CanFire()) );
}

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

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 );
		}
		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 = Normal( Pawn.Location - Other.Pawn.Location );
				GotoState( WanderingState, BeginLabel );
			}
		}

		// mdf-tbd: setting timer on other!?
		if( U2NPCControllerBaseOld(Other) != None )
			U2NPCControllerBaseOld(Other).SetSharedTimer( FClamp( TimerRate, 0.001, 0.2 ), false );

		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Enemy already set to Pawn that bumped us.

function HandleBumpedByEnemy()
{
	bReadyToAttack = true;
	GotoState( AttackStationaryState );
}

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

#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 bool FriendlyBumpSpecial()
{
	local bool bResult;

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

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

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

function eventBumpFriend( Pawn Other )
{
	if( TimerRate <= 0.0 )
		SetSharedTimer( 1.0, false );

	Super.eventBumpFriend( Other );
}

//-----------------------------------------------------------------------------
	
function SetFall()
{
	Super.SetFall();

	if( ControllerEnemy != None )
	{
		NextState = AttackingState; //default
		NextLabel = BeginLabel;
		GotoState( FallingState );
	}
}

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

event LongFall()
{
	SetFall();
	if( ControllerEnemy != None && Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z )
		GotoState( FallingState, FireWhileFallingLabel );
	else 
		GotoState( FallingState, FallLongLabel );
}

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

function ExecuteDodge( bool bLeft, vector DodgeDestination )
{
	Super.ExecuteDodge( bLeft, DodgeDestination );
	
	if( ( Pawn.Weapon != None ) && Pawn.Weapon.bSplashDamage
		&& ( ( bFire != 0 ) || ( bAltFire != 0 ) ) && ( ControllerEnemy != None ) 
		&& !Pawn.FastTrace( ControllerEnemy.Location, DodgeDestination ) 
		&& Pawn.FastTrace( ControllerEnemy.Location, Pawn.Location ) )
	{
		#debug DMAI( "ExecuteDodge - clear firing" );
		bFire = 0;
		bAltFire = 0;
	}

	GotoState( FallingState, DuckingLabel );
}

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

function CombatMove()
{	
	#debug DMAI( "CombatMove" );
	//DMTNS( "CombatMove" );

	if( ControllerEnemy == None )
		return;

	//if( GetSkill() > 0.5 )
	if( FDecision( AttackReadyToAttackOdds ) )
		bReadyToAttack = true;

	if( Pawn.Weapon == None )
	{
		bAltFire = 0;
		bFire = 0;
		return;
	}

	if( bReadyToAttack && IsFacingTarget( ControllerEnemy, CosMinFacingTargetAngle ) )
	{
		if( NeedToTurn( ControllerEnemy.Location, NeedToTurnAngleCos ) )
		{
			#debug   StopFiring( 0.1, SFI_Orientation, GetContext() );
			#release StopFiring( 0.1, SFI_Orientation );
		}
		else 
		{
			FireAt( ControllerEnemy ); 
		}
	}		
	else 
	{
		// keep firing if rapid fire weapon unless can't see enemy
		MaybeStopFiring( TimeBetweenAttacks );

		if( (bFire + bAltFire > 0) && (GetTimeSinceEnemyLastSeen() > 1.0 || NeedToTurn( ControllerEnemy.Location, NeedToTurnAngleCos )) )
		{
			bFire = 0;
			bAltFire = 0;
		}
	}
}

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

function BigJump( Actor JumpDest )
{
	Pawn.SetPhysics( PHYS_Falling );
	Pawn.Velocity = Pawn.GroundSpeed * Normal( JumpDest.Location - Pawn.Location );
	if( JumpSpot(JumpDest) != None && JumpSpot(JumpDest).bAlwaysAccel )
	{
		bBigJump = true;
		Pawn.Acceleration = Pawn.AccelRate * Normal( Destination - Pawn.Location );
	}
	else
	{ 
		StopMovement( true, false );
	}
		
	if( Pawn.bCountJumps )
		Pawn.Inventory.OwnerEvent( 'Jumped' );
	Pawn.Velocity.Z = Pawn.JumpZ;
	Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
	bSpecialJump = true;
	Pawn.DesiredRotation = rotator( JumpDest.Location - Pawn.Location );
	FocalPoint = JumpDest.Location + 100 * (JumpDest.Location - Pawn.Location);
	if ( Pawn.PhysicsVolume.Gravity == Pawn.PhysicsVolume.default.Gravity )
		MoveTarget = None;
	
	Pawn.bBlockAdjustJump = true;
	SetFall();
}

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

function bool PickLocalInventoryDestination( float MaxDist, float MinDistraction )
{
	local Pickup LocalPickup, BestPickup;
	local float NewWeight, BestWeight;
	local float DistanceToPickup;
	local bool bResult;

	#debug DMAIM( "PickLocalInventoryDestination -- MaxDist: " $ MaxDist $ " MinDistraction: " $ MinDistraction );
	bResult = false;
	if( Pawn != None && Pawn.bCanPickupInventory )
	{
		// first look at nearby inventory < MaxDist (mdf: use 2*MaxDist for weapons)
		//!!mdf-tbd: VCA seems to be really slow -- should it be avoided/fixed?
		foreach VisibleCollidingActors( class'Pickup', LocalPickup, 2*MaxDist, Pawn.Location, true )
		{
			DistanceToPickup = VSize( LocalPickup.Location - Pawn.Location );

			// only look for weapons at 2xMaxDist
			if( WeaponPickup(LocalPickup) == None && DistanceToPickup > MaxDist )
				continue;

			// mdf-tbd: check for PHYS_Falling means bots very unlikely to after
			// weapon tossed by immediate victim since it will take a while to
			// land. Ideally, bots would wait for the weapon to land but we don't
			// want them going after weapons that are going to fall a long way and/or
			// far away.
			if( LocalPickup.ReadyToPickup( 0.0 ) && 
				LocalPickup.MaxDesireability/60 > BestWeight && 
				LocalPickup.Physics != PHYS_Falling && 
				LocalPickup.Location.Z < (Pawn.Location.Z + Pawn.MaxStepHeight + Pawn.CollisionHeight) )
			{
				// mdf-tbd: BotDesireability not too good about encouraging bot to take
				// weapon even if it already has one as a defensive measure.
				
				NewWeight = LocalPickup.BotDesireability( Pawn );

				if( (NewWeight > MinDistraction) || 
					(LocalPickup.Inventory != None && WeaponPickup(LocalPickup) != None && (DistanceToPickup < 0.6*MaxDist)) )
				{
					NewWeight = NewWeight/DistanceToPickup;
					if( NewWeight > BestWeight )
					{
						BestWeight = NewWeight;
						BestPickup = LocalPickup;
					}
				}
			}
		}

		// mdf-tbd: add support for trying for next N best from above if can't reach best one (not more than 2/3 though)
	    if( BestPickup != None )
		{
			Pawn.bCanJump = ( BestPickup.Location.Z > Pawn.Location.Z - Pawn.CollisionHeight - Pawn.MaxStepHeight );
			if( ActorReachable( BestPickup ) )
			{
				MoveTarget = BestPickup;
				bResult = true;
			}
			Pawn.bCanJump = true;
		}
	}

	#debug DMAIM( "PickLocalInventoryDestination returning MoveTarget: " $ MoveTarget );
	return bResult;
}

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

function bool ShouldDestroyNPC()
{
	return false;
}

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

function GameRelatedKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType );

//-----------------------------------------------------------------------------
//@ STATE CODE -- BASE STATES
//-----------------------------------------------------------------------------

state @ EnemyKilledState
{
	ignores EnemyNotVisible; 

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

	//-------------------------------------------------------------------------
		
	event EndState()
	{
		RestoreAlertness();
	}
} // EnemyKilledState

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

state @ MoveToGoalBaseState
{
	//-------------------------------------------------------------------------

	function SharedTimerEvent()
	{
		//DMTNS( "SharedTimerEvent" );
		bReadyToAttack = true;
		Enable( Event_NotifyBump );
	}

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

	function SetFall()
	{
		NextState = GetStateName(); 
		NextLabel = LandedLabel;
		GotoState( FallingState ); 
	}

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

@ LandedLabel:
	if( MoveTarget == None )
		Goto( MovePickDestLabel );
	Goto( MoveActiveLabel );

@ TakeHitLabel:
	Goto( MoveActiveLabel );

// idiot checks (give more info than "invalid label xxx" and make obvious)
@ MovePickDestLabel:
	NPCError( ET_Other, "WARNING: label '" $ MovePickDestLabel $ "' needs to be implemented in " $ GetStateName() );
	Stop;

@ MoveActiveLabel:
	NPCError( ET_Other, "WARNING: label '" $ MoveActiveLabel $ "' needs to be implemented in " $ GetStateName() );
	Stop;

@ GiveUpLabel:
	#debug DMAIL( GiveUpLabel );
	NavigationError( ET_Move, "gave up trying to get to MoveTarget" );
	Goto( ErrorLabel );

@ ErrorLabel:
	#debug DMAIL( ErrorLabel );
	NavigationError( ET_InternalPath, "at move error label" );
	Pawn.StopMovement( true, true );
	Stop;
} // MoveToGoalBaseState

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

state @ MoveToGoalWithEnemyState extends @ MoveToGoalBaseState
{
	//-------------------------------------------------------------------------

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			if( NextState == TakeHitState )
			{
				NextState = GetStateName(); 
				NextLabel = TakeHitLabel;
				GotoState( TakeHitState ); 
			}
			else if( !IsFacingTarget( ControllerEnemy, CosMinFacingTargetAngle ) && ( GetSkill() > 0.75 * FRand() ) )
				GotoLabel( MoveActiveLabel );
		}
	}
} // MoveToGoalWithEnemyState

//-----------------------------------------------------------------------------
//@ STATE CODE -- MAIN STATES
//-----------------------------------------------------------------------------

/*-----------------------------------------------------------------------------
Creature has just reacted to stimulus, and set an enemy - depending on strength
of stimulus, and ongoing stimulii, vary time to focus on target and start 
attacking (or whatever).  FIXME - need some acquisition specific animation
HearNoise, SeeEnemy used to improve/change stimulus. */

state @ AcquisitionState
{
	ignores BeginFalling, NotifyLanded; 

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

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

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

	function eventSeeEnemy( Pawn Seen )
	{
		if( MaybeSetEnemy( Seen ) )
		{
			Pawn.MakeNoise( 1.0 );
			GotoState( AttackingState );
		}
	} 
	
	//-------------------------------------------------------------------------

	function eventBumpEnemy( Pawn Other )
	{
		if( MaybeSetEnemy( Other ) )
		{
			Pawn.MakeNoise( 1.0 );
			GotoState( AttackingState );
		}
	} 
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		SetAlertness( -0.5 );
	}

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

	event EndState()
	{
		RestoreAlertness();
		LastAcquireTime = Level.TimeSeconds;
	}
		
	//-------------------------------------------------------------------------

@ PlayOutLabel:
	StopMovement( true, false );
    if( Pawn.AnimFrame < 0.6 && Pawn.IsAnimating() )
	{
		Sleep( 0.05 );
		Goto( PlayOutLabel );
	}
		
@ BeginLabel:
	StopMovement( true, false );
	if( NeedToTurn( GetLastEnemySeenLocation(), NeedToTurnAngleCos ) )
	{	
		Focus = None;
		FocalPoint = GetLastEnemySeenLocation();
		FinishRotation( DefaultRotationThreshold );
	}
	FocalPoint = GetLastEnemySeenLocation();
	if( ControllerEnemy == None )
	{
		#debug   WhatToDoNext( GetContext() );	
		#release WhatToDoNext();	
	}
	
	if( StationaryPawn(ControllerEnemy) != None )
		GotoState( AttackingState );

	if( GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear )  //will run away from noise
	{
		EnemyDetected( ControllerEnemy.Location );
		GotoState( AttackingState );
	}
	else if( GetSkill() >= 0.5 )
	{
		bMustHunt = true;
		GotoState( AttackingState );
	}
	else if( Level.TimeSeconds - LastAcquireTime > 0.3 )
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
	else
	{
		Sleep( 0.1 );
		Goto( BeginLabel );
	}
} // AcquisitionState

/*-----------------------------------------------------------------------------
Master attacking state - choose which type of attack to do from here. 
*/

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

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

	function ChooseAttackMode()
	{
		local EReaction ReactionToEnemy;
		local Pawn TempPawn;
		local bool bWillHunt;

		bWillHunt = bMustHunt;
		bMustHunt = false;
		if( !ValidEnemy( ControllerEnemy ) )
		{
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
			return;
		}

		ReactionToEnemy = GetReactionToEnemy( ControllerEnemy );
		if( (Level.TimeSeconds - LastAttractCheck > 0.5) || 
			ReactionToEnemy == REACTION_Fear || 
			PriorityObjective() > 1 ) 
		{
			/*OLD
			// old approach totally borks attacking currently because GameAI approach
			// doesn't make state changes for the AI
			if( FindSpecialAttraction() )
				return;
			*/
			//NEW
			if( FindSpecialAttraction() )
			{
				GotoState( AttackFallbackState, MoveSpecialLabel );
				return;
			}

			if( ControllerEnemy == None )
			{
				#debug   WhatToDoNext( GetContext() );
				#release WhatToDoNext();
				return;
			}
		}
			
		if( IsMobile() && ReactionToEnemy == REACTION_Fear )
		{
			GotoState( AttackRetreatState );
			return;
		}
		/* mdf-tbd: shouldn't be in attacking state at all if enemy is a friend
		   and GetReactionToEnemy only returns fear/hate currently
		else if( ReactionToEnemy == REACTION_Friendly )
		{
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
			return;
		}
		*/
		else if( !LineOfSightTo( ControllerEnemy ) )
		{
			if( OldControllerEnemy != None && GetReactionToEnemy( OldControllerEnemy ) == REACTION_Attack && LineOfSightTo( OldControllerEnemy ) )
			{
				// swap current, old enemies
				TempPawn = ControllerEnemy;
				#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
				#release SetControllerEnemy( OldControllerEnemy );
				OldControllerEnemy = TempPawn;
			}	
			else 
			{
				// NEW BEGIN
				if( IsMobile() && FindSpecialAttraction() )
				{
					// old approach totally borks attacking currently because GameAI approach
					// doesn't make state changes for the AI
					GotoState( AttackFallbackState, MoveSpecialLabel );
				}
				else if( ControllerEnemy == None )
				{
					#debug   WhatToDoNext( GetContext() );
					#release WhatToDoNext();
				}
				else if( !IsMobile() || 
					(Orders == OrdersHold && GetTimeSinceEnemyLastSeen() > 5.0) ||
					(!bWillHunt && (bSniping || (VSize( ControllerEnemy.Location - Pawn.Location) <= 600 + (FRand() * RelativeStrength( ControllerEnemy ) - U2PBasic.CombatStyle) * 600))) )
				{
					ClearMoveAttempts();
					GotoState( AttackStakeOutState );
				}
				else
				{
					GotoState( AttackHuntState );
				}
				// NEW END

				return;
			}
		}	

		// mdf-tbd: ick
		if( !SpecialAttackTransition() )
		{		
			if( bReadyToAttack )
				SetSharedTimer( TimeBetweenAttacks, false );
			GotoState( AttackTacticalMoveState );
		}
	}
	
	//-------------------------------------------------------------------------
	// EnemyNotVisible implemented so engine will update LastEnemySeenLocation

	function eventEnemyNotVisible()
	{
	}

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

	function SharedTimerEvent()
	{
		//DMTNS( "SharedTimerEvent" );
		bReadyToAttack = true;
	}

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

	event BeginState()
	{
		// mdf-tbd: NPCs seem to be firing all the time and this helps but
		// ultimately need to look into the firing code. Its possible that
		// this is also causing problems firing, e.g. with the Takkra because
		// this stops firing as soon as it starts?
		//StopFiring();
		if( TimerRate <= 0.0 )
			SetSharedTimer( TimeBetweenAttacks  * ( 1.0 + FRand() ), false ); 
		if( Pawn != None && Pawn.Physics == PHYS_None )
			Pawn.SetMovementPhysics(); 
	}

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

@ BeginLabel:
	//log( class$" choose Attack" );
	ChooseAttackMode();
} // AttackingState

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

state @ AttackCloseState extends @ MoveToGoalWithEnemyState
{
    ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise;
	//mdf-tbd: -- hmm borks moving around friendly NPCs...
	//ignores NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise;

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

	event MayFall()
	{
		if( MoveTarget != ControllerEnemy )
			return;

		Pawn.bCanJump = ActorReachable( ControllerEnemy );
		if( !Pawn.bCanJump )
			GotoState( AttackTacticalMoveState, DontCloseLabel );
	}

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

	function FearThisSpot( Actor aSpot )
	{
		Destination = Pawn.Location + 120 * Normal( Normal( Destination - Pawn.Location ) + Normal( Pawn.Location - aSpot.Location ) ); 
		GotoState( AttackTacticalMoveState, MoveActiveStrafeLabel );
	}

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

	function TryToDodge( vector DuckDir, bool bDuckLeft )
	{
		if( FRand() < 0.6 )
		{
			Global.TryToDodge( DuckDir, bDuckLeft );
			return;
		}
		if( MoveTarget == ControllerEnemy ) 
			TryStrafe( DuckDir );
	}

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

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

		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 bool TryStrafe( vector SideDir )
	{ 
		local vector Extent, HitLocation, HitNormal;
		local Actor HitActor;

		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;
		}
		Destination = Pawn.Location + 250 * SideDir;
		GotoState( AttackTacticalMoveState, MoveActiveStrafeLabel );
		return true;
	}
			
	//-------------------------------------------------------------------------

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		local float Pick;
		local vector SideDir, Extent;
		local bool bWasOnGround;

		#debug DMAI( "DamageAttitudeTo" );
		bWasOnGround = ( Pawn.Physics == PHYS_Walking );

		if( Pawn.Health <= 0 )
			return;

		if( NextState == TakeHitState )
		{
			if( GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear )
			{
				NextState = AttackRetreatState;
				NextLabel = BeginLabel;
			}
			else if( StrafeFromDamage( damage, DamageType, false ) )
			{
				NextState = AttackTacticalMoveState;
				NextLabel = DontCloseLabel;
			}
			else
			{
				NextState = AttackCloseState;
				NextLabel = TakeHitLabel;
			}
			GotoState( TakeHitState ); 
		}
		else if( StrafeFromDamage( damage, DamageType, true ) )
			return; 
		else 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 SharedTimerEvent()
	{
		//DMTNS( "SharedTimerEvent" );

		bReadyToAttack = true;
		if( ControllerEnemy == None )
		{
			GotoState( AttackingState );
			return;
		}

		// mdf-tbd: ick
		if( !SpecialAttackTransition() )
		{
			//DMTNS( "not special attack transition" );

			if( IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
			{
				//DMTNS( "is prepared for ranged attack (checking rand vs 0.4 + 0.6*GetSkill())" );

				if((FRand() > 0.4 + 0.6 * GetSkill()) )
				{
					//DMTNS( "going attacking" );
					#debug DMAI( "going to AttackStationaryState " $ GetContext() );
					GotoState( AttackStationaryState );
				}
			}
		}
		else
		{
			//DMTNS( "not attacking" );
		}
	}

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

	//!!mdf(tbd) don't predict through floor under target		
	function vector GetPredictedChargeLocation( Pawn TargetPawn )
	{
		local vector PredictedLocation;

		class'UtilGame'.static.GetBestPredictedLocation( Pawn, ControllerEnemy, Pawn.GroundSpeed, 0.0, PredictedLocation );
			
		PredictedLocation = Pawn.Location + Pawn.CollisionRadius*2.0*Normal( PredictedLocation - Pawn.Location );

		return PredictedLocation;
	}

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

	function bool CanPredict( Actor TargetActor )
	{
		// tbd: do an extent trace and/or full reachability check?
		// reachability could be optional, e.g. dumb creatures might blindly attack enemy?
		return ( U2PBasic.bPredictChargeLocation && Pawn.FastTrace( Pawn.Location, TargetActor.Location ) );
	}

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

	function eventEnemyNotVisible()
	{
		GotoState( AttackHuntState ); 
	}

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

	function ETacticalMoveType GetTacticalMoveType()
	{
		if( GetSkill() >= 0.5 && !Level.Game.bTeamGame && IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) && FRand() < 0.75 )
			return TMT_Basic;
		else
			return TMT_None;
	}

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

	event EndState()
	{
		if( Pawn != None )
			Pawn.bCanJump = (Pawn.JumpZ > 0);
	}

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

@ LandedLabel:
	#debug DMAIL( LandedLabel );
	Goto( CloseLabel );

@ BeginLabel:
	#debug DMAIL( BeginLabel );

@ CloseLabel:
	#debug DMAIL( CloseLabel );
	
	if( !ValidEnemy( ControllerEnemy ) )
		GotoState( AttackingState );

	if( ControllerEnemy.PhysicsVolume.bWaterVolume )
	{
		if( !Pawn.bCanSwim )
			GotoState( AttackTacticalMoveState, DontCloseLabel );
	}
	else if( !Pawn.bCanFly && !Pawn.bCanWalk )
		GotoState( AttackTacticalMoveState, DontCloseLabel );

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

	if( CanPredict( ControllerEnemy ) || ActorReachable( ControllerEnemy ) )
	{
		if( IsMobile() )
		{
			if( U2PBasic.bPredictChargeLocation )
			{
				// note: MoveToPoint doesn't currently use advanced tactics
				// solutions: a) we don't care (default for now -- may be fine) 
				//            b) use a proxy actor for the destination 
				//			  c) (better than b) have MoveToPoint use same code as MoveToActor
				MoveToPoint( GetPredictedChargeLocation( ControllerEnemy ) );
			}
			else
			{
				MoveToActor( ControllerEnemy, GetTacticalMoveType() );
			}
		}
	}
	else
	{
@ CantReachLabel:
		#debug DMAIL( CantReachLabel );
		//!!mdf-tbd: shouldn't do this -- we could still be facing enemy? 
		//log( "route to enemy"@ControllerEnemy );
		if( !IsMobile() || !FindBestPathToward( ControllerEnemy, true ) )
		{
			Sleep( 0.0 );
			GotoState( AttackTacticalMoveState, DontCloseLabel );
		}
@ MoveActiveLabel:
		#debug DMAIL( MoveActiveLabel );
		if( IsMobile() )
		{
			if( VSize( MoveTarget.Location - Pawn.Location ) < (2.5 * Pawn.CollisionRadius) || FaceTarget( 1.5 ) )
				MoveToActor( MoveTarget, TMT_None, , , ControllerEnemy );	
			else
				MoveToActor( MoveTarget, TMT_None );
		}
	}

	GotoState( AttackingState );

@ TakeHitLabel:
	#debug DMAIL( TakeHitLabel );
	if( MoveTarget == ControllerEnemy )
		MoveToActor( MoveTarget, TMT_None );
	
	Goto( CloseLabel );

@ TurnLabel:
	if( ValidEnemy( ControllerEnemy ) )
	{
		#debug DMAI( "TurnLabel #1" );

		StopMovement( true, true );
		Focus = ControllerEnemy;
		FinishRotation( DefaultRotationThreshold );
		Goto( CloseLabel );
	}
	else
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
	Stop;

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

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

state @ AttackFallbackState extends @ MoveToGoalWithEnemyState
{
	ignores EnemyNotVisible;

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

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

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

	function eventEnemyNotVisible()
	{
		DMAssert( false , GetContext() );

		/* mdf-tbr: how can this ever get called if EnemyNotVisible is ignored in this state?
		local Pawn P;

		if( OldControllerEnemy != None && LineOfSightTo( OldControllerEnemy ) )
		{
			// swap current enemy (no longer visible) for old one (now visible)
			P = OldControllerEnemy;
			OldControllerEnemy = ControllerEnemy;
			#debug   SetControllerEnemy( P, GetContext() );
			#release SetControllerEnemy( P );
		}
		else if( !ControllerEnemy.IsMobile() )
		{
			// Enemy can't move
			#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
			#release SetControllerEnemy( OldControllerEnemy );
			OldControllerEnemy = None;
			if( ControllerEnemy == None )
				GS( DefaultState );
		}
		*/
	}

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

	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 ) )
		{
			HandleEnemyNoise( NoiseMaker );
			Pawn.MakeNoise( 1.0 );
		}
	}

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

	function PickDestination()
	{
		local byte TeamPriority;

		if( GetTimeSinceEnemyLastDetected() > 9 )
		{
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		}
			
		if( ControllerEnemy == None )
		{
    		#debug   WhatToDoNext( GetContext() );
    		#release WhatToDoNext();
			return;
		}
		LastAttractCheck = Level.TimeSeconds - 0.1;

		if( FindSpecialAttraction() )
		{
			TeamPriority = PriorityObjective();
   			if( TeamPriority > 16 )
   			{
   				PickLocalInventoryDestination( 160, 1.8 );
   				return;
   			}
   			else if( TeamPriority > 1 )
   			{
   				PickLocalInventoryDestination( 200, 1.0 );
   				return;
   			}
   			else if( TeamPriority > 0 )
   			{
   				PickLocalInventoryDestination( 200, 0.55 );
   				return;
   			}
   			PickLocalInventoryDestination( 400, 0.5 );
   			if( MoveTarget == None )
   			{
   				#debug DMAI( " no destination in fallback!" );
   				Orders = OrdersNone;
   				GotoState( AttackingState );
			}
			return;
		}
		else if( Orders == OrdersAttack || OrdersObject == None )
		{
			#debug DMAI( " attack fallback turned to freelance" );
			Orders = OrdersNone;
			GotoState( AttackingState );
		}
		else if( (VSize( Pawn.Location - OrdersObject.Location ) < 20)
			|| ( (VSize( Pawn.Location - OrdersObject.Location ) < 600) && LineOfSightTo( OrdersObject )) )
		{
			if( StationaryPawn(ControllerEnemy) != None || (GetTimeSinceEnemyLastDetected() > 5 && Orders == OrdersHold) )
			{
				#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
				#release SetControllerEnemy( OldControllerEnemy );
				OldControllerEnemy = None;
			}
			GotoState( AttackingState );
		}
		else
		{
			FindPathToActor( OrdersObject, MoveTarget );
			if( MoveTarget == None )
			{
				#debug DMAI( "fallback turned to freelance (no Path to " $ OrdersObject $ " )" );
				Orders = OrdersNone;
				GotoState( AttackingState );
			}
		}
	}

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

	function eventBumpEnemy( Pawn Other )
	{
		#debug DMAI( "eventBumpEnemy -- calling MaybeSetEnemy" );
		MaybeSetEnemy( Other );
		if( ControllerEnemy == Other )
			bReadyToAttack = true;
	}

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

	function ETacticalMoveType GetTacticalMoveType()
	{
		if( GetTimeSinceEnemyLastSeen() < 1.0 && GetSkill() > (1.25*FRand()-1) )
			return TMT_Basic;
		else
			return TMT_None;
	}
	
	//-------------------------------------------------------------------------

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

@ MoveSpecialLabel:

@ MoveActiveLabel:
	if( MoveTarget == None )
	{
		Sleep( 0.0 );
		Goto( MovePickDestLabel );
	}
	if( FaceTarget( 1 ) )
	{
		bReadyToAttack = true;
		MoveToActor( MoveTarget, GetTacticalMoveType(), , , ControllerEnemy );
	}
	else
	{
		MoveToActor( MoveTarget, GetTacticalMoveType() );
	}
	Goto( MovePickDestLabel );
} // AttackFallbackState

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

state @ AttackHuntState
{
	ignores EnemyNotVisible; 

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

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

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

	function eventBumpEnemy( Pawn Other )
	{
		#debug DMAI( "eventBumpEnemy -- calling MaybeSetEnemy" );
		MaybeSetEnemy( Other );
		if( ControllerEnemy == Other )
		{
			bReadyToAttack = true;
			EnemyDetected( ControllerEnemy.Location );
			GotoState( AttackingState );
		}
	}

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

	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;
		GotoState( AttackHuntState, MoveSpecialLabel );
	}

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

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			bFrustrated = true;
			if( NextState == TakeHitState )
			{
				if( GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear )
				{
					NextState = AttackRetreatState;
					NextLabel = BeginLabel;
				}
				else
				{
					NextState = AttackHuntState;
					NextLabel = LandedLabel;
				}
				GotoState( TakeHitState ); 
			}
		}
	}

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

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

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

	function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )
	{
		if( Global.MaybeSetEnemy( NewEnemy, bAlertingOthers ) )
		{
			BlockedPath = None;
			bReadyToAttack = true;
			Focus = ControllerEnemy;
			if( U2PBasic.CombatStyle > FRand() )
				GotoState( AttackCloseState ); 
			else
				GotoState( AttackingState );
			return true;
		}
		return false;
	} 

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

	function bool NonRangedFireCheck()
	{
		bReadyToAttack = true;
		return true;
	}

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

	function MaybeClearHuntingEnemy()
	{
		// If no enemy, or I should see him but don't, then give up		
		if( GetTimeSinceEnemyLastDetected() > MaxHuntTime )
		{
			#debug DMAI( "MaybeClearHuntingEnemy clearing enemy" );
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		}
	}

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

	function PickDestination()
	{
		local float MaxDist;
		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 ) )
		{
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
			return;
		}
	
		Pawn.bAvoidLedges = false;
		Pawn.bCanJump = (Pawn.JumpZ > 0);
		
		if( ActorReachable( ControllerEnemy ) )
		{
			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
			{
				#debug   WhatToDoNext( GetContext() );
				#release WhatToDoNext();
			}
			return;
		}
		if( Level.TimeSeconds - LastInvFind > 4 - 0.4 * 8*GetSkill() )
		{
			LastInvFind = Level.TimeSeconds;
			MaxDist = 600 + 320 * GetSkill();
			if( PickLocalInventoryDestination( MaxDist, 0.6/MaxDist ) )
				return;
		}

		NumMoveAttempts++;

		ViewSpot = Pawn.Location + Pawn.BaseEyeHeight * vect(0,0,1);
		bCanSeeLastSeen = Pawn.FastTrace( GetLastEnemySeenLocation(), ViewSpot );
		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( FindPathToActor( ControllerEnemy, MoveTarget, 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() )
				{
					GotoState( AttackStakeOutState );
					return;
				}
				else
				{
					#debug   WhatToDoNext( GetContext() );
					#release WhatToDoNext();
					return;
				}
			}
			// control Path weights
			ClearPaths();
			if( BlockedPath != None )
				BlockedPath.Cost = 1500;
			if( FindBestPathToward( ControllerEnemy, false ) )
				return;
		}
		else if( FindBestPathToward( ControllerEnemy, true ) )
			return;

		MoveTarget = None;
		
		if( (NumMoveAttempts > 60) && ShouldGiveUpHunting() )
		{
			U2P.AssetsHelperClass.static.HandleLostEnemy( U2P );
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
			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;
				}
				return;
			}
		}

		Pawn.bAvoidLedges = ( Pawn.CollisionRadius > 42 );
		posZ = GetLastEnemyDetectedLocation().Z + Pawn.CollisionHeight - ControllerEnemy.CollisionHeight;
		nextSpot = GetLastEnemyDetectedLocation() - Normal( ControllerEnemy.Velocity ) * Pawn.CollisionRadius;
		nextSpot.Z = posZ;
		if( Pawn.FastTrace( nextSpot, ViewSpot ) )
		{
			Destination = nextSpot;
		}
		else if( bCanSeeLastSeen )
		{
			Destination = GetLastEnemyDetectedLocation();
		}
		else
		{
			Destination = GetLastEnemyDetectedLocation();
			if( !Pawn.FastTrace( GetLastEnemyDetectedLocation(), ViewSpot ) )
			{
				// check if could adjust and see it
				if( PickWallAdjust( Normal( GetLastEnemyDetectedLocation() - ViewSpot ) ) || FindViewSpot() )
				{
					if( Pawn.Physics == PHYS_Falling )
						SetFall();
					else
						GotoState( AttackHuntState, AdjustFromWallLabel );
				}
				else if( VSize( ControllerEnemy.Location - Pawn.Location ) < 1200 )
				{
					GotoState( AttackStakeOutState );
					return;
				}
				else
				{
					#debug   WhatToDoNext( GetContext() );
					#release WhatToDoNext();
					return;
				}
			}
		}
		
		// cheat...
		SetLastEnemyDetectedLocation( ControllerEnemy.Location );
	}	

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

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

		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;
			return true;
		}

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

		return false;
	}

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

	event BeginState()
	{
		//log( Self$" hunting" );
		SetAlertness( 0.5 );
		bTriedLastDetectedLocation = false;
		bDeviousHunting = GetShouldUseDeviousTactics( 0.50,  0.50 );
	}

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

	event EndState()
	{
		bHunting = false;
		RestoreAlertness();

		// mdf-tbd: yet another fix for stupid accessed None because Pawn destroyed
		if( Pawn != None )
		{
			Pawn.bAvoidLedges = Pawn.default.bAvoidLedges;
			Pawn.bCanJump = (Pawn.JumpZ > 0);
		}
	}

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

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

@ BeginLabel:
	ClearMoveAttempts();

@ LandedLabel:

@ HuntLabel:
	FindSpecialAttraction();

	if( bSniping )
		GotoState( AttackStakeOutState );

	if( Orders == OrdersFollow ) 
	{
		if( !LineOfSightTo( Controller(OrdersObject).Pawn ) )
			GotoState( AttackFallbackState );
	}
	else if( Orders == OrdersHold ) 
	{
		if( !LineOfSightTo( OrdersObject ) )
			GotoState( AttackFallbackState );
	}
	else if( Orders == OrdersDefend )
	{
		if( AmbushSpot != None )
		{
			if( !LineOfSightTo( AmbushSpot ) )
				GotoState( AttackFallbackState );
		}
		else if( !LineOfSightTo( OrdersObject ) )
			GotoState( AttackFallbackState );
	}
	WaitForLanding();
	if( CanSee( ControllerEnemy ) )
	{
		#debug DMAI( "AttackHuntState (CanSee) -- calling MaybeSetEnemy" );
		MaybeSetEnemy( ControllerEnemy );
	}
	PickDestination();

@ MoveSpecialLabel:
	if( MoveTarget == None )
		MoveToPoint( Destination );
	else
		MoveToActor( MoveTarget, TMT_None ); 

	Goto( HuntLabel );
} // AttackHuntState

/*-----------------------------------------------------------------------------
Retreating for a bot 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;

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

	event MayFall()
	{
		if( IsFacingTarget( ControllerEnemy, CosMinFacingTargetAngle ) ) // MoveTarget is player, 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 );
			GotoState( AttackingState );
		}
	}

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

	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 );
			GotoState( AttackingState );
		}
	}

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

	function PickDestination()
	{
		local float MaxDist, BestWeight;
		local Actor BestPath;

		if( !bReadyToAttack && TimerRate == 0.0 )
			SetSharedTimer( 0.7, false );

		// do I still fear my enemy?
		if( (GetTimeSinceEnemyLastDetected() > 12 ) || (Level.Game.bTeamGame && (GetTimeSinceEnemyLastDetected() > 8)) )
		{
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
		}
		if( ( ControllerEnemy == None ) || ( GetReactionToEnemy( ControllerEnemy ) > REACTION_Fear ) )
		{
			GotoState( AttackingState );
			return;
		}

		//first look at nearby inventory < 500 Dist
		MaxDist = 500 + 320 * GetSkill();
		if( PickLocalInventoryDestination( MaxDist, 0.001 ) )
			return;

		 // look for long distance inventory 
		BestWeight = FindBestInventoryPath( BestPath, 0.0, false );
		if( Level.Game.bTeamGame && BestWeight < 0.0002 )
		{
			if( StationaryPawn(ControllerEnemy) == None && (ControllerEnemy.Location.Z < Pawn.Location.Z + 500) )
			{
				bKamikaze = true;
				if( LineOfSightTo( ControllerEnemy ) )
				{
					LastInvFind = Level.TimeSeconds;
					GotoState( AttackTacticalMoveState, DontCloseLabel );
					return;
				}
			}
		}
		if( BestPath != None )
		{
			MoveTarget = BestPath;
			return;
		}

		#debug DMAI( " give up retreat" );

		// if nothing, then tactical move
		if( LineOfSightTo( ControllerEnemy ) )
		{
			LastInvFind = Level.TimeSeconds;
			bKamikaze = true;
			GotoState( AttackTacticalMoveState, DontCloseLabel );
			return;
		}

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

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

	function ChangeDestination()
	{
		local Actor OldTarget;
		local Actor Path;
		
		OldTarget = Home;
		PickDestination();
		if( Home == OldTarget )
		{
			bKamikaze = true;
			//log( "same old target" );
			GotoState( AttackTacticalMoveState, TacticalTickLabel );
		}
		else
		{
			FindPathToActor( Home, Path );
			if( Path == None )
			{
				//log( "no new target" );
				bKamikaze = true;
				GotoState( AttackTacticalMoveState, TacticalTickLabel );
			}
			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, true, U2Weapon.RatingIneffective ) )
		{
			bReadyToAttack = true;
			GotoState( AttackStationaryState );
		}
	}
	
	//-------------------------------------------------------------------------

	function ReachedHome()
	{
		if( LineOfSightTo( ControllerEnemy ) )
			ChangeDestination();
		else
		{
			bKamikaze = true;
			GotoState( AttackingState );
		}
	}

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

	function PickNextSpot()
	{
		local Actor Path;

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

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

@ BeginLabel:
	if( bReadyToAttack && ( FRand() < 0.8 - 0.8 * GetSkill() ) )
		bReadyToAttack = false;
	if( TimerRate == 0.0 || !bReadyToAttack )
		SetSharedTimer( TimeBetweenAttacks, false );

@ MovePickDestLabel:
	WaitForLanding();
	PickDestination();

@ MoveActiveLabel:
	if( MoveTarget == None )
	{
		Sleep( 0.0 );
		Goto( MovePickDestLabel );
	}
	if( InventorySpot(MoveTarget) != None && 
		InventorySpot(MoveTarget).markedItem != None && 
		InventorySpot(MoveTarget).markedItem.ReadyToPickup( 0.0 ) && 
		Desireability( InventorySpot(MoveTarget).markedItem ) > 0 )
	{
			MoveTarget = InventorySpot( MoveTarget ).markedItem;
	}
	if( FaceTarget( 2 ) )
		MoveToActor( MoveTarget, GetTacticalMoveType(), , , ControllerEnemy );
	else
		MoveToActor( MoveTarget, GetTacticalMoveType() );
	Goto( MovePickDestLabel );
} // AttackRetreatState

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

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

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

	function bool ContinueAttackStationary()
	{
		if( AttackStationaryStopTime <= Level.TimeSeconds )
			return false;

		if( NeedToTurn( ControllerEnemy.Location, NeedToTurnAngleCos ) )
			return false;

		return ( CanFire( false ) && IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) );
	}

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

	function DoRangedAttack()
	{
		Global.DoRangedAttack();

		//!!mdf-tbd: support non-weapon using NPCs
		if( Pawn != None && U2Weapon(Pawn.Weapon) != None )
		{
			if( (bFire == 1 && U2Weapon(Pawn.Weapon).FireTime > 0.5 ) ||
				(bAltFire == 1 && U2Weapon(Pawn.Weapon).AltFireTime > 0.5) )
			{
				bReadyToAttack = false;
				GotoState( AttackTacticalMoveState );
			}
		}
	}

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

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			if( NextState == TakeHitState )
			{
				NextState = AttackStationaryState;
				NextLabel = BeginLabel;
			}
		}
	}

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

	#debug   function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo, string ContextStr )
	#release function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo )
    {
		#debug DMAIA( "StopFiring -- going to attacking" );
		#debug   Global.StopFiring( SuggestedFireAgainDelay, SFInfo, ContextStr );
		#release Global.StopFiring( SuggestedFireAgainDelay, SFInfo );
		GotoState( AttackingState );
	}

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

	function eventEnemyNotVisible()
	{
		////log( "enemy not visible" );
		//let attack animation complete
		if( bFiringPaused )
			return;

		if( !IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) || (FRand() < 0.13) )
		{
			bReadyToAttack = true;
			//DMTNS( "eventEnemyNotVisible -- going to attacking" );
			GotoState( AttackingState );
			return;
		}
	}

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

	function KeepAttacking()
	{
		local int BaseSkill;

		if( bFiringPaused )
		{
			//DMTNS( "KeepAttacking - bFiringPaused" );
			if( TimerRate <= 0.0 )
				GotoState( NextState, NextLabel );

			if( !ValidEnemy( ControllerEnemy  ) || !LineOfSightTo( ControllerEnemy ) )
			{
				bFire = 0;
				bAltFire = 0; 
				GotoState( NextState, NextLabel );
			}
		}

		if( !ValidEnemy( ControllerEnemy ) || !LineOfSightTo( ControllerEnemy ) || !IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
		{
			//DMTNS( "KeepAttacking - enemy not valid or lost LOS" );

			bFire = 0;
			bAltFire = 0; 
			GotoState( AttackingState );
			return;
		}

		bReadyToAttack = FDecision( AttackReadyToAttackOdds );

		if( ContinueAttackStationary() && bReadyToAttack )
		{
			return; // enemy is valid and can still see him so keep attacking
		}
		else 
		{
			#debug   StopFiring( 0.0, SFI_Behavior, GetContext() );
			#release StopFiring( 0.0, SFI_Behavior );
		}
		
		if( IsPreparedToMelee( true ) )
		{
			bReadyToAttack = true;
			//DMTNS( "KeepAttacking - IsPreparedToMelee( true )" );
			GotoState( AttackTacticalMoveState );
			return;
		}

		BaseSkill = 8*GetSkill();
		if( ControllerEnemy.Controller.IsPreparedToMelee( false ) && VSize( ControllerEnemy.Location - Pawn.Location ) < 500 )
			BaseSkill += 3;

		if( (BaseSkill > 3*FRand() + 2) || ((bFire + bAltFire == 0) && (BaseSkill > 6*FRand() - 1)) )
		{
			bReadyToAttack = true;
			//DMTNS( "KeepAttacking - going to tactical based on skill" );
			GotoState( AttackTacticalMoveState );
		}
	}

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

	function SharedTimerEvent()
	{
		//DMTNS( "SharedTimerEvent" );
		
		if( bFiringPaused )
		{
			//DMTNS( "SharedTimerEvent jumping to " $ NextState );
			GotoState( NextState, NextLabel );
		}
	}

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

	function CheckAttackStatus()
	{
		//!!mdf-refactor this crap

		if( !ValidEnemy( ControllerEnemy ) )
		{
			bFire = 0;
			bAltFire = 0; 
			GotoState( AttackingState );
			return;
		}

		if( ContinueAttackStationary() )
		{
			DoRangedAttack();
			return; // enemy is valid and can still see him (no eventEnemyNotVisible) so keep attacking
		}

		if( !IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) || !IsFiring() )
		{
			//DMTNS( "CheckAttackStatus - !IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) || !IsFiring()" );
			GotoState( AttackingState );
			return;
		}
		else
		{
			GotoLabel( AttackDoneLabel );
			return;
		}
		
		// mib-tbd temporarily bypassed this code to force npcs to leave this state
		if( FRand() - 1.2*GetSkill() < 0 )
		{
			//DMTNS( "CheckAttackStatus - goint to AttackStationaryState based on skill" $ GetContext() );
			GotoLabel( AttackDoneLabel );
		}
		else
		{
			DoRangedAttack();
		}
	}
	
	//-------------------------------------------------------------------------

	function SpecialFire()
	{
		if( ControllerEnemy == None )
			return;
		bFiringPaused = true;
		SetSharedTimer( 0.75 + VSize( ControllerEnemy.Location - Pawn.Location )/Pawn.Weapon.GetProjSpeed( true ), false );
		NextState = AttackingState;
		NextLabel = BeginLabel; 
	}

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

	function bool NonRangedFireCheck()
	{
		return false;
	}

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

	event BeginState()
	{
		local byte IncomingStance;

		if( bFiringPaused )
			SetSharedTimer( 0.75 + VSize( ControllerTarget.Location - Pawn.Location )/Pawn.Weapon.GetProjSpeed( true ), false );

		if( AttackStationaryStopTime > Level.TimeSeconds )
		{
			if( SelectStance( false ) )
				GotoLabel( StanceChangeDelayLabel );
		}
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		bFiringPaused = false;
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
		bFire = 0;
		bAltFire = 0;
		AttackStationaryStopTime = -1.0;

		// mdf-tbd: odds of keeping stance for movement (crouching only)
		if( StationaryStance == ST_None && !LPawn.IsStanding() && FDecision( U2PBasic.StationaryStandOdds ) )
			UpdateStance( ST_Standing ); //!!mdf-tbd: animation issues
	}

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

@ ChallengeLabel:
	#debug DMAIL( ChallengeLabel );
	StopMovement( true, false );
	Pawn.DesiredRotation = rotator( ControllerEnemy.Location - Pawn.Location );
	//TBD (servo) Pawn.PlayChallenge();
	//TBD (servo) #debug DMAIL( "FinishAnim #1 -- begin" );
	//TBD (servo) FinishAnim();
	//TBD (servo) #debug DMAIL( "FinishAnim #1 -- end" );
	//TBD (servo) Pawn.TweenToFighter( 0.1 );
	Goto( FaceTargetLabel );

@ BeginLabel:
	#debug DMAIL( BeginLabel );
	if( GetTarget() == None )
	{
		//DMTNS( "no target -- going to attacking" );
		GotoState( AttackingState );
	}
	StopMovement( true, false );
	
@ FaceTargetLabel:
	#debug DMAIL( FaceTargetLabel );
	Focus = GetTarget();
	if( NeedToTurn( Focus.Location, NeedToTurnAngleCos ) )
	{
		//DMTNS( "turn to target: " $ Target );
		#debug DMAIL( "FinishRotation -- begin" );
		FinishRotation( DefaultRotationThreshold );
		#debug DMAIL( "FinishRotation -- end" );
	}
	//TBD (servo) #debug DMAIL( "FinishAnim #2 -- begin" );
	//TBD (servo) FinishAnim();
	//TBD (servo) #debug DMAIL( "FinishAnim #2 -- end" );

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

	#debug DMAIA( "do ranged attack: " $ Focus );
	DoRangedAttack();

	if( IsPreparedToMelee( true ) )
	{
		//DMTNS( "IsPreparedToMelee( true )" );
		GotoState( AttackingState );
	}
@ AttackOngoingLabel:
	#debug DMAIL( AttackOngoingLabel );
	//DMTNS( "AttackOngoingLabel AnimSequence=" $ Pawn.AnimSequence $ " frame = " $ Pawn.AnimFrame $ "/" $ Pawn.GetAnimFrames( Pawn.AnimSequence ) );
	if( GetTarget() == None )
	{
		//DMTNS( "no target #2 -- going to attacking" );
		GotoState( AttackingState );
	}
	Focus = GetTarget();
	CheckAttackStatus();

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

@ AttackDoneLabel:
	#debug DMAIL( AttackDoneLabel );
	KeepAttacking();
	Goto( FaceTargetLabel );

@ StanceChangeDelayLabel:
	FinishAnim();
	Goto( ChallengeLabel );
} // AttackStationaryState

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

state @ AttackStakeOutState
{
	ignores EnemyNotVisible; 

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

	function bool RandomizeStakeOutDir()
	{
		return Level.Game.bTeamgame;
	}
	
	//-------------------------------------------------------------------------

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			bFrustrated = true;
			EnemyDetected( ControllerEnemy.Location );
			if( NextState == TakeHitState )
			{
				if( GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear )
				{
					NextState = AttackRetreatState;
					NextLabel = BeginLabel;
				}
				else
				{
					NextState = AttackingState;
					NextLabel = BeginLabel;
				}
				GotoState( TakeHitState ); 
			}
			else
				GotoState( AttackingState );
		}
	}

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

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

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

	function SetFall()
	{
		NextState = AttackStakeOutState; 
		NextLabel = BeginLabel;
		GotoState( FallingState ); 
	}

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

	function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )
	{
		if( Global.MaybeSetEnemy( NewEnemy, bAlertingOthers ) )
		{
			bReadyToAttack = true;
			Focus = ControllerEnemy;
			GotoState( AttackingState );
			return true;
		}
		return false;
	} 
	
	//-------------------------------------------------------------------------

	function SharedTimerEvent()
	{
		bReadyToAttack = true;
		Enable( Event_NotifyBump );
		SetSharedTimer( 1.0, false );
	}

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

	function bool AdjustAim( class<Projectile> ProjectileClass, float ProjSpeed, vector ProjStart, float WeaponFireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
	{
		local vector FireSpot, X, Y, Z;
		local Actor HitActor;
		local vector HitLocation, HitNormal;

		#debug DMAIA( "AdjustAim" );				
		FireSpot = GetLastEnemySeenLocation();
			 
		HitActor = Pawn.Trace( HitLocation, HitNormal, FireSpot, ProjStart, false );
		if( HitActor != None ) 
		{
			FireSpot += 2 * ControllerEnemy.CollisionHeight * HitNormal;
			bClearShot = Pawn.FastTrace( FireSpot, ProjStart );
			if( !bClearShot )
			{
				#debug   StopFiring( 0.2, SFI_NoLOS, GetContext() );
				#release StopFiring( 0.2, SFI_NoLOS );
				return false;
			}
		}

		//!!mdf-tbd: 
		//	Perfect aim here for most weapons (tossed projectiles not included) --
		//  -- should we be calling Global.AdjustAim to aim at FireSpot (use a 
		// proxy actor to set as target)?
		SetRotation( rotator( FireSpot - ProjStart ) );
		return true;
	}
	
	//-------------------------------------------------------------------------

	function bool ClearShot()
	{
		local bool bResult;
		local vector LastSeenLocation;
		
		//!!mdf-tbd: NPCs seem to be trying to shoot through walls with pistol etc. when in stakeout?

		LastSeenLocation = GetLastEnemySeenLocation();
		if( Pawn.Weapon == None ||
			(Pawn.Weapon.bSplashDamage && VSize( Pawn.Location - LastSeenLocation ) < 300) ||
			!Pawn.FastTrace( LastSeenLocation + vect(0,0,0.9)*ControllerEnemy.CollisionHeight, Pawn.Location ) )
		{
			bFire = 0;
			bAltFire = 0;
			bResult = false;
		}
		else
		{
			bResult = true;
		}

		return bResult;
	}
	
	//-------------------------------------------------------------------------

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

		if( bStationary )
		{
		 	// tend to stake out longer if stationary (singleplayer)
			bResult = (GetTimeSinceEnemyLastSeen() <= 8.0 && ClearShot() && CanStakeOut());
		}
		else if( ControllerEnemy != None )
		{
			StrengthDelta = RelativeStrength( ControllerEnemy );
			bResult = ( (VSize( ControllerEnemy.Location - Pawn.Location ) <= 300 + (FRand() * StrengthDelta - U2PBasic.CombatStyle)*350) &&
						(GetTimeSinceEnemyLastSeen() <= 2.5 + FMax( -1, 3*(FRand() + 2*(StrengthDelta - U2PBasic.CombatStyle)))) &&
						ClearShot() &&
						CanStakeOut() );
		}

		return bResult;
	}

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

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

	//-------------------------------------------------------------------------
	
	event EndState()
	{
		RestoreAlertness();
		SetLastEnemyDetectedLocation( RealLastDetectedLocation );
		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   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
	StopMovement( true, false );
//TBD (servo) Pawn.PlayChallenge();
	Focus = None;
	FocalPoint = GetLastEnemyDetectedLocation();
	FinishRotation( DefaultRotationThreshold );
	if( ControllerEnemy == None )
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
	
	if( IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) && FRand() < 0.5 && VSize( ControllerEnemy.Location - GetLastEnemyDetectedLocation() ) < 150 && ClearShot() && CanStakeOut() )
	{
		DoRangedAttack();
	}
	else
	{
		bFire = 0;
		bAltFire = 0;
	}
//TBD (servo) if( ( 8*GetSkill() <= 4 ) && ( FRand() >= 0.65 ) )
//TBD (servo) 		Pawn.PlayChallenge();
	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( IsMobile() )
	{
		if( bSniping )
		{
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
		}
		BlockedPath = None;	
		GotoState( AttackHuntState, LandedLabel );
	}
	else
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
} // AttackStakeOutState

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

state @ AttackTacticalMoveState
{
	// mdf-tbd: ignore bumps also? If nothing else, swarming araknids are generating tons of friendly bumps
	// borks dealing with clustering...
	//ignores NotifyBump, Bump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise;
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise;

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

	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 SetFall()
	{
		StopMovement( true, false );
		Destination = Pawn.Location;
		NextState = AttackingState;
		NextLabel = BeginLabel;
		GotoState( FallingState );
	}

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

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		if( Pawn.Health > 0 )
		{
			if( NextState == TakeHitState )
			{
				NextState = AttackTacticalMoveState;
				NextLabel = TakeHitLabel;
				GotoState( TakeHitState ); 
			}
		}
	}

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

	event bool NotifyHitWall( vector HitNormal, Actor Wall )
	{
		if( Pawn.Physics == PHYS_Falling )
			return false;

		if( ControllerEnemy == None )
		{
			GotoState( AttackingState );
			return false;
		}
		if( bChangeDir || FRand() < 0.5 || ((ControllerEnemy.Location - Pawn.Location) dot HitNormal) < 0 )
		{
			Focus = ControllerEnemy;
			GiveUpTactical( IsMobile() );
		}
		else
		{
			bChangeDir = true;
			Destination = Pawn.Location - HitNormal * FRand() * 500;
		}
		return false;
	}

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

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

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

	function SharedTimerEvent()
	{	
		//DMTNS( "SharedTimerEvent" );

		bReadyToAttack = true;
		Enable( Event_NotifyBump );
		if( ControllerEnemy == None )
			return;

		// mdf-tbd: ick
		if( !SpecialAttackTransition() )
		{
			if( IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) && !ControllerEnemy.Controller.IsPreparedToMelee( false ) && (FRand() > 0.3 + 0.8 * GetSkill() ) )
			{
				GotoState( AttackStationaryState );
			}
		}
	}

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

	function eventEnemyNotVisible()
	{
		if( !bGathering && Aggressiveness > RelativeStrength( ControllerEnemy ) )
		{
			if( Pawn.FastTrace( ControllerEnemy.Location, GetLastEnemySeenLocation( ) ) && IsMobile() )
				GotoLabel( RecoverEnemyLabel );
			else
				GotoState( AttackingState );
		}
		Disable( 'EnemyNotVisible' );
	}
		
	//-------------------------------------------------------------------------

	function GiveUpTactical( bool bCanCharge )
	{	
		if( bCanCharge && (IsPreparedToMelee( true ) || (2 * U2PBasic.CombatStyle + 0.8 * GetSkill() > FRand())) )
		{
			GotoState( AttackCloseState );
		}
		else if( IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
		{
			if( bReadyToAttack && IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) && GetSkill() >= 0.5 )
			{
				GotoState( AttackStationaryState );
			}
			else
			{
				GotoState( AttackStationaryState, ChallengeLabel ); 
			}
		}
		else
		{
			GotoState( AttackingState );
		}
	}		

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

	function PawnIsInPain( PhysicsVolume PainVolume )
	{
		GotoState( AttackRetreatState );
	}

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

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

		#debug DMAI( "TacticalMove.PickRegDestination: " $ bCanCharge );

		if( !ValidEnemy( ControllerEnemy ) )
		{
			GotoState( AttackingState );
			return;
		}

		bGathering = false;
		if( Orders == OrdersHold || !IsMobile() )
			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;
		}
		if( ControllerEnemy.PhysicsVolume.bWaterVolume )
			bCanCharge = bCanCharge && Pawn.bCanSwim;
		else 
			bCanCharge = bCanCharge && (Pawn.bCanFly || Pawn.bCanWalk);
		
		if( bCanCharge && IsPreparedToMelee( true ) )
		{
			GotoState( AttackCloseState );
			return;
		}
		EnemyDist = VSize( Pawn.Location - ControllerEnemy.Location );
		if( (!IsMobile() || (FRand() > 0.3 + 1.2 * GetSkill())) && 
			(EnemyDist > 900 || !ControllerEnemy.Controller.IsPreparedToMelee( false ) ) && 
			(PriorityObjective() == 0) )
		{
			#debug DMAI( "calling GiveUpTactical #1" );
			GiveUpTactical( false );
		}

		bSuccess = false;
		if( ( bSniping || ( Orders == OrdersHold ) )  
			&& ( PriorityObjective() == 0 ) )
			bCanCharge = false;

		if( bSniping && Pawn.Weapon.bInstantHit )
		{
			bReadyToAttack = true;
			GotoState( AttackStationaryState );
			return;
		}
						
		Aggression = 2 * ( U2PBasic.CombatStyle + FRand() ) - 1.1;
		if( ControllerEnemy != None && ControllerEnemy.IsPlayerPawn() && ( GetReactionToEnemy( ControllerEnemy ) == REACTION_Fear ) && ( U2PBasic.CombatStyle > 0 ) )
			Aggression = Aggression - 2 - 2 * U2PBasic.CombatStyle;

		// adjust Aggression based on attack capabilities (weapon or animation-based attack)
		if( !IsPreparedToAttack( true ) )
		{
			Aggression += 2 * StyleRunAway;
		}
		else
		{
			// mdf-tbd: 2nd parameter should be passed the likely use (fire/altfire) for the weapon.
			// but we pbly don't want to call RateSelf here (slow & might not get same result as
			// when weapon 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( ControllerEnemy );
		}

		//!!mdf-handle enemy which doesn't use weapons (animation-based attacks)
		if( ControllerEnemy != None && ControllerEnemy.Weapon != None )
		{
			// adjust Aggression based on enemy's weapon
			Aggression += 2 * ControllerEnemy.Weapon.SuggestDefenseStyle( Pawn );
		}

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

		if( EnemyDist > 1000 )
			Aggression += 1;
		if( bCanCharge )
			bCanCharge = ( Aggression >= FRand() );

		if( ( Pawn.Physics == PHYS_Walking ) || ( Pawn.Physics == PHYS_Falling ) )
		{
			if( Pawn.Location.Z > ControllerEnemy.Location.Z + 150 ) //tactical height advantage
				Aggression = FMax( 0.0, Aggression - 1.0 + U2PBasic.CombatStyle );
			else if( Pawn.Location.Z < ControllerEnemy.Location.Z - Pawn.CollisionHeight ) // below enemy
			{
				if( bCanCharge && Aggression > 0 &&  FRand() < 0.6 )
				{
					GotoState( AttackCloseState );
					return;
				}
				else if( ( EnemyDist < 1.1 * ( ControllerEnemy.Location.Z - Pawn.Location.Z ) ) 
						&& !ActorReachable( ControllerEnemy ) ) 
				{
					bNoReach = true;
					Aggression = -1.5 * FRand();
				}
			}
		}
	
		if( bCanCharge && Aggression > (2 * FRand()) )
		{
			if( bNoReach && (Pawn.Physics != PHYS_Falling) )
				GotoState( AttackCloseState, CantReachLabel );
			else
				GotoState( AttackCloseState );
			return;
		}

		if( UseTacticalJumps() && (U2PBasic.bJumpy || (FRand()*8*GetSkill() > 2.3)) )
		{
			GetAxes( Rotation, X, Y, Z );

			if( FRand() < 0.5 )
			{
				Y *= -1;
				TryToDodge( Y, false );
			}
			else
				TryToDodge( Y, true );
		}
			
		if( ( ( ControllerEnemy.Velocity - Pawn.Velocity ) dot ( ControllerEnemy.Location - Pawn.Location ) ) > 0 )
			Aggression += 0.4 * FRand();
			 
		EnemyDir = ( ControllerEnemy.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 ) || ( ControllerEnemy.IsPlayerPawn() && ( GetReactionToEnemy( ControllerEnemy ) == 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 )
		{
			#debug DMAI( "calling GiveUpTactical #2" );
			GiveUpTactical( bCanCharge );
		}
		else 
		{
			// mdf-tbd: added Pawn.Weapon != None for basic NPC use -- could go away if this code moved to Advanced
			// mdf-tbd: should !NeedToTurn test go into || (has X || Y && Z currently)?
			if( U2PBasic.bJumpy || 
				(Pawn.Weapon != None &&
				 Pawn.Weapon.bRecommendSplashDamage && 
				 (FRand() < 0.1 + 0.8 * GetSkill()) && 
				 (ControllerEnemy.Location.Z - ControllerEnemy.CollisionHeight <= Pawn.Location.Z + Pawn.MaxStepHeight - Pawn.CollisionHeight)) && 
				!NeedToTurn( ControllerEnemy.Location, NeedToTurnAngleCos ) )
			{
				FireAt( ControllerEnemy );
				if( ( U2PBasic.bJumpy && ( FRand() < 0.75 ) ) || Pawn.Weapon.SplashJump() )
				{
					// try jump move
					Pawn.SetPhysics( PHYS_Falling );
					StopMovement( true, false );
					Destination = MinDest;
					NextState = AttackingState; 
					NextLabel = BeginLabel;
					GotoState( FallingState );
					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;
			}
		}
	}

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

	function PickDestination( bool bCanCharge )
	{
		local float MaxDist;

		#debug DMAI( "TacticalMove.PickDestination: " $ bCanCharge );
		// possibly Pick nearby inventory
		// higher skill bots will always strafe, lower skill
		// both do this less, and strafe less

		if( !bReadyToAttack && TimerRate == 0.0 )
			SetSharedTimer( 0.7, false );

		if( !IsMobile() || (Level.TimeSeconds - LastInvFind < 5 - 4 * GetSkill()) )
		{
			PickRegDestination( bCanCharge );
		}
		else
		{
			LastInvFind = Level.TimeSeconds;
			bGathering = false;
			MaxDist = 700 + 240 * GetSkill();
			if( PickLocalInventoryDestination( MaxDist, 0.5/MaxDist ) )
				bGathering = true;
			else
				PickRegDestination( bCanCharge );
		}
	}

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

	event BeginState()
	{
		MinHitWall += 0.15;
		bAdjustFromWalls = false;
		if( Pawn != None )
		{
			Pawn.bAvoidLedges = true;
			Pawn.bStopAtLedges = true;
			Pawn.bCanWalkOffLedges = false;
			Pawn.bCanJump = false;
		}
	}
	
	//-------------------------------------------------------------------------

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

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

@ TacticalTickLabel:
	Sleep( 0.02 );

@ BeginLabel:
	Focus = ControllerEnemy;
	Destination = ControllerEnemy.Location;
	WaitForLanding();

	PickDestination( IsMobile() );

@ MoveActiveLabel:
	if( IsMobile() )
	{
		if( !Pawn.bCanStrafe )
		{ 
			MoveToPoint( Destination );
		}
		else
		{
@ MoveActiveStrafeLabel:
			MoveToPoint( Destination, , ControllerEnemy );	
		}
	}

	if( ControllerEnemy != None && !LineOfSightTo( ControllerEnemy ) && Pawn.FastTrace( ControllerEnemy.Location, GetLastEnemySeenLocation() ) && IsMobile() )
	{
		Goto( RecoverEnemyLabel );
	}
	else
	{
		bReadyToAttack = true;
		GotoState( AttackingState );
	}
	
@ DontCloseLabel:
	Focus = ControllerEnemy;
	Destination = ControllerEnemy.Location;
	WaitForLanding();

	PickDestination( false );

@ TakeHitLabel:
	Goto( MoveActiveLabel );

@ RecoverEnemyLabel:
	bReadyToAttack = true;
	HidingSpot = Pawn.Location;
	if( IsMobile() )
	{
		Destination = GetLastEnemySeenLocation() + 4 * Pawn.CollisionRadius * Normal( GetLastEnemySeenLocation() - Pawn.Location );
		MoveToPoint( Destination, , ControllerEnemy );
	}

	if( CanFire( false ) && IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) && LineOfSightTo( ControllerEnemy ) )
	{
		// mdf-tbd: cleanup this mess -- Focus should be handled already in FireAt -- look at all cases like this
		Focus = ControllerEnemy;
		FireAt( ControllerEnemy );
		StopMovement( true, false );
		if( Pawn.Weapon.bSplashDamage )
		{
			bFire = 0;
			bAltFire = 0;
			bReadyToAttack = true;
			Sleep( 0.2 );
		}
		else
			Sleep( 0.35 + 0.3 * FRand() );

		if( ( FRand() + 0.1 > U2PBasic.CombatStyle ) )
		{
			bFire = 0;
			bAltFire = 0;
			bReadyToAttack = true;
			Enable( 'EnemyNotVisible' );
			Destination = HidingSpot + 4 * Pawn.CollisionRadius * Normal( HidingSpot - Pawn.Location );
			Goto( MoveActiveLabel );
		}
	}

	GotoState( AttackingState );
} // AttackTacticalMoveState

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

state @ DeadState
{
	ignores EnemyNotVisible, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend; // sensory input
	ignores BeginFalling, NotifyLanded, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange; // physics
	ignores eventTakeDamage, eventTookDamage, ShotFiredNotification, SetTestMoveTarget; // other

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

	event BeginState()
	{
		Super.BeginState();
		ClearHoldSpots();
	}
}

//-----------------------------------------------------------------------------
// Used when NPC's head is in a waterzone & he needs to get to the surface to
// breathe.

//mdf-tbd: nothing uses this currently, used to be handled through PainTimer in UT436 code
state @ FindAirState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, NotifyBump;

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

	event bool NotifyHeadVolumeChange(PhysicsVolume NewHeadVolume)
	{
		Global.NotifyHeadVolumeChange(newHeadVolume);
		if ( !newHeadVolume.bWaterVolume )
			GotoState( AttackingState );
		return false;
	}

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

	event bool NotifyHitWall( vector HitNormal, actor Wall )
	{
		// change direction
		Destination = 200 * (Normal(Destination - Pawn.Location) + HitNormal);
		return false;
	}

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

	function SharedTimerEvent()
	{
		bReadyToAttack = true;
		SetSharedTimer( 0.5, false );
	}

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

	function eventEnemyNotVisible()
	{
		////log("enemy not visible");
		bReadyToAttack = false;
	}

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

	function PickDestination()
	{
		Destination = VRand();
		Destination.Z = 1;
		Destination = Pawn.Location + 200 * Destination;				
	}

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

	event BeginState()
	{
		bAdjustFromWalls = false;
	}

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

	event EndState()
	{
		bAdjustFromWalls = true;
	}

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

@ BeginLabel:
	PickDestination();

@ MoveActiveLabel:	
	if( ControllerEnemy == None )
		MoveToPoint( Destination );
	else
		MoveToPoint( Destination, , ControllerEnemy );
	GotoState( AttackingState );

@ TakeHitLabel:
	Goto( MoveActiveLabel );
} // FindAirState

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

state @ FallingState
{
	ignores NotifyBump, NotifyHitWall, ShotFiredNotification;

/* FIXME
	//-------------------------------------------------------------------------

	singular event BaseChange()
	{
		local Actor HitActor;
		local vector HitNormal, HitLocation;

		if( Pawn.Base != None && Mover(Pawn.Base) != None )
			&& ((MoveTarget == Pawn.Base) 
				|| ((MoveTarget != None) && (MoveTarget == Mover(Pawn.Base).myMarker))) )
		{
			MoveTimer = -1.0;
			MoveTarget = None;
			StopMovement( true, false );
		}
		else
			Super.BaseChange();
	}
*/

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

	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		Global.NotifyPhysicsVolumeChange(NewVolume);
		if ( NewVolume.bWaterVolume )
			GotoLabel( SplashLabel );
		return false;
	}
	
	//-------------------------------------------------------------------------
	//choose a jump velocity

	function AdjustJump()
	{
		// mdf-tbr:
		local float velZ;
		local vector FullVel;
		local float JumpDownSlope;

		#debug DMAIM( "AdjustJump MoveTarget= " $ MoveTarget $ " Destination= " $ Destination );

		if( Pawn.bCanFly )
		{
			Pawn.SetPhysics( PHYS_Flying );
		}			
		else if( Pawn.bBlockAdjustJump ) // this is set in the engine and is more or less equivalent to the check done below
		{
			//DM( "no jump -- velocity: " $ Pawn.Velocity );
			Pawn.bBlockAdjustJump = false;
		}
		else
		{
			StopMovement( true, false );
			//DM( "velocity prior to calling EAdjustJump: " $ Pawn.Velocity );
			Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
			//DM( "velocity after calling EAdjustJump: " $ Pawn.Velocity );
		}

		// play jumping sounds etc.
		Pawn.HandleJumpSound();

		/*
    	mdf-tbd: approach changed in UW & its pbly best to go that way now
		this means figuring out how to incorporate my slope checks into 
		the engine code that sets bBlockAdjustJump. Steve seems to have 
		replaced much of the falling state approach for this and instead
		puts the above code directly into SetFall.

		#debug DMAIM( "AdjustJump MoveTarget= " $ MoveTarget $ " Destination= " $ Destination );

		// mdf -- this is useless now one way or another
		// mdf-tbd: fix for NPCs jumping down to location that can be reached with air control
		// this isn't perfect -- if slope test fails, NPCs can still get stuck in some cases
		// -- ideally we'd be able to detect them getting stuck and/or determine that the
		// jump won't help in order to disable the jump
		#debug DMAIM( "AdjustJump jump delta Z is " $ Pawn.Location.Z - Destination.Z );

		if( Pawn.Location.Z > Destination.Z )
		{
			JumpDownSlope = (Pawn.Location.Z - Destination.Z) / VSize2D(Pawn.Location - Destination);
			#debug DMAIM( "AdjustJump jump down slope is " $ JumpDownSlope );
		}

		// mdf-tbd: this and/or code in EAdjustJump is borked for jumping down
		// I suppose that in some cases NPCs can try to jump down towards their destination
		// but if NPC is flagged as !bCanJumpDown (tbd) or if selected jump will cause
		// NPC to land above destination, just have NPC walk off the ledge
		velZ = Pawn.Velocity.Z;
		FullVel = Normal( Pawn.Velocity ) * Pawn.GroundSpeed;
		StopMovement( true, false );

		if( (Pawn.Location.Z > Destination.Z + Pawn.CollisionHeight + 2*Pawn.MaxStepHeight) || JumpDownSlope > 1.0 )
		{
			Pawn.Velocity = FullVel;
			Pawn.Velocity.Z = velZ;
			Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
    		Pawn.Velocity.Z = 0;
			if( VSize( Pawn.Velocity ) < 0.9*Pawn.GroundSpeed || JumpDownSlope > 1.0 )
			{
				#debug DMAIM( "Not jumping" );
				Pawn.Velocity.Z = velZ;
				return;
			}
		}

		if( Pawn.bCanFly )
		{
			Pawn.SetPhysics( PHYS_Flying );
		}			
		else if( Pawn.bBlockAdjustJump ) // this is set in the engine and is more or less equivalent to the check done below
		{
			Pawn.bBlockAdjustJump = false;
		}
		else
		{
			#debug DMAIM( "Jumping" );
	
			Pawn.Velocity = FullVel;
			Pawn.Velocity.Z = Pawn.default.JumpZ + velZ;
			DM( "Velocity prior to calling EAdjustJump: " $ Pawn.Velocity );
			Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
			DM( "Velocity after calling EAdjustJump: " $ Pawn.Velocity );
			Pawn.HandleJumpSound();
		}
		*/
	}

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

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		Global.DamageAttitudeTo( Other, Damage, DamageType );

		if( ControllerEnemy != None )
		{
			NextState = AttackingState; 
			NextLabel = BeginLabel;
		}
		if( ControllerEnemy != None && Other == ControllerEnemy )
		{
			EnemyDetected( ControllerEnemy.Location );
		}
		if( NextState == TakeHitState )
		{
			NextState = AttackingState; 
			NextLabel = BeginLabel;
			GotoState( TakeHitState ); 
		}
	}

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

	function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )
	{
		local bool bResult;
		bResult = false;
		if( Global.MaybeSetEnemy( NewEnemy, bAlertingOthers ) )
		{
			bResult = true;
			NextState = AttackingState; 
			NextLabel = BeginLabel;
		}
		return bResult;
	} 

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

	function SharedTimerEvent()
	{
		if( ControllerEnemy != None )
		{
			bReadyToAttack = true;
			if( CanFire( false ) )
				GotoLabel( FireWhileFallingLabel );
		}
	}

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

	event bool NotifyLanded( vector HitNormal )
	{
		local vector Vel2D;

		if( MoveTarget != None )
		{
			Vel2D = Pawn.Velocity;
			Vel2D.Z = 0;
			if( ( Vel2D dot ( MoveTarget.Location - Pawn.Location ) ) < 0 )
				StopMovement( true, false );
		}
		//Note - physics changes type to PHYS_Walking by default for landed pawns
		//Pawn.TakeFallingDamage();
		if ( Pawn != None )
		{
			/*if( LPawn.IsHardLanding( Pawn.Velocity.Z ) )
			{
				GS( LandedHardState );
			}
			else*/ if (Pawn.Velocity.Z < -1.4 * Pawn.JumpZ)
			{
				if ( Pawn.Health > 0 )
					GotoLabel( LandedLabel );
			}
			else 
				GotoLabel( DoneLabel );
		}

		// mdf-tbd: return false so Pawn.Landed() called (handles landed sounds, damage, hard landings etc.)
		return false;
	}
	
	//-------------------------------------------------------------------------

	function eventSeeEnemy( Pawn Seen )
	{
		Global.eventSeeEnemy( Seen );
		#debug DMAI( "DisableSenses(false) in FallingState.eventSeeEnemy" );
		DisableSenses( false );
	}

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

	function eventEnemyNotVisible()
	{
		#debug DMAI( "EnableSenses(false) in FallingState.eventSeeEnemy" );
		EnableSenses( false );
	}

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

	function SetFall()
	{
		if( !Pawn.bUpAndOut )
			GotoState( FallingState );
	}
	
	//-------------------------------------------------------------------------

	function EnemyAcquired()
	{
		NextState = AcquisitionState;
		NextLabel = BeginLabel;
	}

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

	function FindNewJumpDest()
	{
		local NavigationPoint N, Best;
		local float BestRating, Rating;
		local vector Dist;

		// look for pathnode below current location and visible
		BestRating = 1;
		for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
			if( N.Location.Z + 100 < Pawn.Location.Z )
			{
				Dist = Pawn.Location - N.Location;
				Rating = Dist.Z * Dist.Z/( Dist.X * Dist.X + Dist.Y * Dist.Y ); 
				if( ( Rating > BestRating ) && Pawn.FastTrace( N.Location, Pawn.Location ) )
				{
					BestRating = Rating;
					Best = N;
				}
			}
				

		if( Best != None )
			Destination = Best.Location;
	}

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

	event BeginState()
	{
		if( ControllerEnemy == None )
			Disable( 'EnemyNotVisible' );
		else
		{
			#debug DMAI( "DisableSenses(falses) in FallingState.BeginState #2" );
			DisableSenses( false );
		}
		if( (bFire + bAltFire > 0) || GetSkill() == 1.0 )
			SetSharedTimer( 0.01, false );
	}

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

	event EndState()
	{
		//log( Self$" left falling state " );
		if( Pawn == None )
			return;
		Pawn.bUpAndOut = false;
		bSpecialJump = false;
		bBigJump = false;
		if( ( MoveTarget != None ) && ( MoveTarget.Location.Z - Pawn.Location.Z > 256 ) )
			MoveTarget = None;
	}

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

@ FireWhileFallingLabel:
	#debug DMAI( "DisableSenses(false) in FallingState #3" );
	DisableSenses( false );
	if( Pawn.Physics != PHYS_Falling )
		Goto( DoneLabel );
	if( ControllerEnemy == None )
		Goto( FallLongLabel );
	Focus = ControllerEnemy;
	FinishRotation( DefaultRotationThreshold );
	if( CanFire( false ) )
		FireAt( ControllerEnemy );
	if ( Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z )
	{
		if ( (Pawn.Velocity.Z < 0) && (Destination.Z > Pawn.Location.Z + Pawn.MaxStepHeight + Pawn.CollisionHeight) )
			FindNewJumpDest();			
		MoveToPoint( Destination, , ControllerEnemy );
	}
	else
		Sleep( 0.5 + 0.2 * FRand() );
	if( LineOfSightTo( ControllerEnemy ) )
		Goto( FireWhileFallingLabel );
 			
@ FallLongLabel:
	if ( (Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z)
		&& (Pawn.Velocity.Z < 0) && (Destination.Z > Pawn.Location.Z + Pawn.MaxStepHeight + Pawn.CollisionHeight) )
	{
		FindNewJumpDest();
		MoveToPoint( Destination );
	}			
	if( Pawn.bCanFly )
	{
		Pawn.SetPhysics( PHYS_Flying );
		Goto( DoneLabel );
	}
	Sleep( 0.7 );
	if( ControllerEnemy != None )
	{
		Focus = ControllerEnemy;
		FinishRotation( DefaultRotationThreshold );
		if( CanFire( false ) )
			DoRangedAttack();
	}

	if ( (Pawn.Velocity.Z > -150) && (Pawn.PhysicsVolume.Gravity.Z <= Pawn.PhysicsVolume.default.Gravity.Z) ) //stuck
	{
		Pawn.SetPhysics( PHYS_Falling );
		if( ControllerEnemy != None )
			Pawn.Velocity = Pawn.groundspeed * normal( ControllerEnemy.Location - Pawn.Location );
		else
			Pawn.Velocity = Pawn.groundspeed * VRand();

		Pawn.Velocity.Z = FMax( Pawn.JumpZ, 250 );
	}
	Goto( FallLongLabel );

@ LandedLabel:
@ DoneLabel:
@ SplashLabel:
	//log( "After fall"@NextState@NextLabel );
	Pawn.bUpAndOut = false;
	if( NextState != NoState && NextState != FallingState )
		GotoState( NextState, NextLabel );
	else 
		GotoState( AttackingState );

@ BeginLabel:
	#debug DMAIL( BeginLabel );

	if( ControllerEnemy == None )
		Disable( 'EnemyNotVisible' );
	else
	{
		#debug DMAI( "DisableSenses(false) in FallingState #4" );
		DisableSenses( false );
	}
	if( !Pawn.bUpAndOut ) // not water jump
	{	
		if( Pawn.PhysicsVolume.bWaterVolume )
		{
			Pawn.SetPhysics( PHYS_Swimming );
			GotoState( NextState, NextLabel );
		}	
		if( !bSpecialJump )
		{
			AdjustJump();
			#debug DMAIM( "Physics after AdjustJump: " $ class'Util'.static.GetPhysicsString( Pawn ) );
		}
 		if( ( Pawn.Velocity.Z > 300 ) && ( MoveTarget != None )
 			&& ((FRand() < 0.13) || ((Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z) && (FRand() < 0.2)))
 			&& ( VSize( Destination - Pawn.Location ) > 160 )
 			&& ( ( vector( Pawn.Rotation ) dot ( Destination - Pawn.Location ) ) > 0 ) )
		{
 			U2PBase.PlayDodge( DCLICK_Forward );
		}
	}
	if( Pawn.Physics != PHYS_Falling )
		Goto( DoneLabel );

	if ( (GetSkill() >= 0.5) && (ControllerEnemy != None) && (Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z) )
	{
		Pawn.Acceleration = Pawn.AccelRate * Normal( Destination - Pawn.Location );
		Goto( FireWhileFallingLabel );
	}

	if( bSpecialJump )
	{
		if( bBigJump )
		{
			while( bBigJump )
			{
				Sleep( 0.25 );
				Pawn.Acceleration = Pawn.AccelRate * Normal( Destination - Pawn.Location );
			}
		}
		else
		{
			Sleep( 0.2 );
			while ( ( Abs( Pawn.Velocity.X ) < 60 ) && ( Abs( Pawn.Velocity.Y ) < 60 ) )
				Sleep( 0.1 );
			StopMovement( true, false );
			Sleep( 1.5 );
		}
		bBigJump = false;
		bSpecialJump = false;
	}
	else
		Sleep( 2 );

	Goto( FallLongLabel );

@ DuckingLabel:
	if( Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z )
	{
		Pawn.Acceleration = Pawn.AccelRate * Normal( Destination - Pawn.Location );
		if( GetSkill() < 0.5 )
			Sleep( 0.4 );
		if( ControllerEnemy != None )
			Goto( FireWhileFallingLabel );
	}
} // FallingState

//-----------------------------------------------------------------------------
// Can't move, can't shoot, can't rotate, not moved by damage.

state @ FrozenState
{
	//-------------------------------------------------------------------------

	function bool IsFrozen()			{ return true; }
	function bool IsMobile()			{ return false; }
	function bool CanFire( bool bTest )	{ return false; }

	//-------------------------------------------------------------------------
	// Allow enemy to be acquired but nothing else?

	function eventBumpEnemy( Pawn Other )
	{
		MaybeSetEnemy( Other );
	}

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

	function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
	{
		if( ValidEnemy( Other )	)
			MaybeSetEnemy( Other );

		//NextState = FrozenState; 
		//NextLabel = BeginLabel;

		//GS( TakeHitState ); 
	}

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

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

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

	function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		Global.eventTakeDamage( Damage, Instigator, HitLocation, vect(0,0,0), DamageType );
	}

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

	event BeginState()
	{
		Focus = None;
	}

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

@ BeginLabel:
	WaitForLanding();
	StopMovement( true, true );
	Stop;
}

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

state @ GameEndedState
{
	//-------------------------------------------------------------------------
	// 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 );
}

//-----------------------------------------------------------------------------
// 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 )
	{
		Destination = Pawn.Location + 120 * Normal( Pawn.Location - aSpot.Location ); 
		GotoState( WanderingState, MoveActiveLabel );
	}
	
	//-------------------------------------------------------------------------

	function PickDestination()
	{
		//local vector DestinationDelta;

		if( HoldSpot(OrdersObject) == None )
		{
			#debug DMAI( "PickDestination -- OrdersObject isn't a HoldSpot -- might go freelancing???" );
			#debug DMAI( "SetOrders " $ GetContext() );
			SetOrders( OrdersNone );
			GotoState( DefaultState );
		} 
		else if( AtDestinationActor( OrdersObject ) )
		{
			#debug DMAI( "PickDestination -- close to OrdersObject go to HoldingState" );
			SendMessageInPosition( 45.0 );

			if( !bInitLifeMessage )
				bInitLifeMessage = true;
			GotoState( HoldingState, WavingLabel );
		}
		else
		{
			#debug DMAI( "PickDestination -- finding a path to OrdersObject" );
			FindPathToActor( OrdersObject, MoveTarget );
			if( MoveTarget == None ) 
			{
				#debug DMAI( "SetOrders " $ GetContext() );
				SetOrders( OrdersNone );
				GotoState( DefaultState );
			} 
		}
	}

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

@ 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
{
	//-------------------------------------------------------------------------

	function SharedTimerEvent()
	{
		Enable( Event_NotifyBump );
	}
	
	//-------------------------------------------------------------------------

	function EnemyAcquired()
	{
		#debug DMAIA( "EnemyAcquired!" );
		GotoState( AcquisitionState, PlayOutLabel );
	}
	
	//-------------------------------------------------------------------------

	event bool NotifyLanded( vector HitNormal )
	{
		SetPhysics( PHYS_None );
		return true;
	}

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

	event BeginState()
	{
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		StopMovement( true, false );
		RestoreAlertness();
	}

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

	event EndState()
	{
		if( HoldSpot(OrdersObject) != None )
			HoldSpot(OrdersObject).Holder = None;
	}

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

@ BeginLabel:
	//if( HoldSpot(OrdersObject) == None )
	if( OrdersObject == None )
	{
		#debug DMAI( "give up hold" );
		#debug DMAI( "SetOrders " $ GetContext() );
		SetOrders( OrdersNone );
		GotoState( DefaultState );
	} 
	else if( HoldSpot(OrdersObject) != None )
	{
		HoldSpot(OrdersObject).Holder = Pawn;
	}

@ WavingLabel:
	#debug DMAIL( WavingLabel );
	bReadyToAttack = false;

	// mdf-tbd:
	if( bStationary && LPawn.GetStance() != StationaryStance )
	{
		#debug DMAIM( "Setting stance to:" $ StationaryStance );
		LPawn.SetStance( StationaryStance );
	}

	//if( Orders == OrdersHold )
	//{
		// 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?
		Focus = None;
		MoveTarget = None;
		FocalPoint = OrdersObject.Location + 1000 * vector(OrdersObject.Rotation);
		//AddArrow( Pawn.Location, FocalPoint, ColorMagenta() );
		Sleep( 2.5 );
	//}

	if( IsMobile() )	
		GotoState( DefaultState );

	#debug DMAI( "Stop!" );
	Stop;	
} // HoldingState

//-----------------------------------------------------------------------------
// Used when NPC lands "hard". When this occurs a landed animation is played
// (rather than tweening to a landed frame) and the NPC can't move briefly.

state @ LandedHardState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, EnemyNotVisible, BeginFalling, NotifyLanded, HearNoise, NotifyBump, NotifyHitWall, ShotFiredNotification, Trigger, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange;

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

	function LandedHardDone()
	{
		if( NextState != NoState && NextState != FallingState )
		{
			GotoState( NextState, NextLabel );
		}
		else
		{
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
		}
	}

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

	event BeginState()
	{
		Super.BeginState();

		// keep NPC from moving or changing rotation until hard landing ends
		// mdf-tbd: disable aiming?
		StopMovement( true, true );
		SetRotation( Pawn.Rotation );
		FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
		Focus = None;
	}
} // LandedHardState

//-----------------------------------------------------------------------------
// Move to a specific destination in the level, e.g. to pick up inventory or to
// carry out orders. NPC will not be in this state if there is an enemy.

// mdf-tbd: there's a strong case to be made for moving this into the Advanced
// Controller as almost all of the behavior in here implies advanced 
// intelligence.

state @ RoamingState
{
	ignores EnemyNotVisible;

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

	/*!!mdf-tbd: -- maybe just wait for new code -- ideally should use wandering to move away from friendly pawn
	function eventBumpFriend( Pawn Other )
	{
		GS( GetStateName(), 'SleepABit' );
	}
	*/

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

	function SetRoamTarget( Actor NewRoamTarget )
	{
		RoamTarget = NewRoamTarget;
	}

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

	function FearThisSpot( Actor aSpot )
	{
		Destination = Pawn.Location + 120 * Normal( Pawn.Location - aSpot.Location ); 
		GotoState( WanderingState, MoveActiveLabel );
	}

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

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

		#debug DMAI( "SetOrders " $ GetContext() );
		bResult = Global.SetOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver, bAcknowledge );
		if( bCamping && (Orders == OrdersHold || Orders == OrdersFollow) )
			GotoLabel( PreBeginLabel );
		return bResult;
	}

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

	event MayFall()
	{
		Pawn.bCanJump = TestCanJump();
	}
	
	//-------------------------------------------------------------------------
	// Return true to indicate special attraction destination set.

	function bool PickSpecialDestination()
	{
		return false;
	}

	//-------------------------------------------------------------------------
	// Return true to indicate that orders related destination set.

	function bool PickOrdersDestination()
	{
		local bool bTriedToPickFar;		// flag whether we tried for far (600 unit?) local inventory so we don't do it a 2nd time later
		local bool bNearPoint;
		local Pawn Leader;
		local bool bReadyForOrders;

		#debug DMAIM( "PickOrdersDestination #1  Orders: " $ Orders );

		//DMTNS( "PickOrdersDestination #1  Orders: " $ Orders );
		bReadyForOrders = ReadyForOrders();

		if( bStationary )
		{
			#debug DMAIM( "PickOrdersDestination -- NPC is stationary -- going to HoldState" );
			GotoState( HoldState );
			return true;
		}

		if( Orders == OrdersFollow )
		{
			#debug DMAIM( "PickOrdersDestination #2 -- OrdersFollow" );
			if( Controller(OrdersObject) == None )
			{
				#debug DMAI( "SetOrders " $ GetContext() );
				SetOrders( OrdersNone );
			}
			else
			{
				Leader = Controller(OrdersObject).Pawn;
				if( Leader != None )
				{
					bNearPoint = IsCloseToDynamicGoal( Leader );
					if( !bNearPoint )
					{
						if( !bReadyForOrders )
						{
							// not ready -- pick inventory if possible
							bTriedToPickFar = true;
							//!!mdf advanced+ only
							if( PickLocalInventoryDestination( 600, 0.0 ) )
								return true;

							if( PlayerController(OrdersObject) != None )
							{
								if( FindBestInventoryPath( MoveTarget, 0.0, (GetSkill() >= 0.75) ) > 0.0 )
									return true;
							}
						}

						FindPathToActor( Leader, MoveTarget );

						if( AtDestinationActor( MoveTarget ) )
							return true;

						if( VSize( Leader.Location - Pawn.Location ) < 1600 && LineOfSightTo( Leader ) )
							bNearPoint = true;
						#debug DMAIM( " found no Path to " $ Leader );
					}
					else 
						SendMessageNearPoint( Leader, 10.0 );
				}
			}
		}

		#debug DMAIM( "PickOrdersDestination #3" );

		if( Orders == OrdersDefend && bReadyForOrders )
		{
			#debug DMAIM( "PickOrdersDestination #4 -- OrdersDefend" );

			//!!mdf advanced+ only
			if( PickLocalInventoryDestination( 300, 0.55 ) )
				return true;


			if( AmbushFindSpot() ) 
				return true;
			if( !LineOfSightTo( OrdersObject ) )
			{
				FindPathToActor( OrdersObject, MoveTarget );
				if( MoveTarget != None )
					return true;
			}
			else
				SendMessageInPosition( 10.0 );
		}

		#debug DMAIM( "PickOrdersDestination #5" );

		if( Orders == OrdersHold && bReadyForOrders && !LineOfSightTo( OrdersObject ) )
		{
			#debug DMAIM( "PickOrdersDestination #6" );
			#debug DMAI( "No LOS to OrdersObject -- going to HoldState" );
			GotoState( HoldState );
			return true;
		}

		#debug DMAIM( "PickOrdersDestination #7" );
		//!!mdf advanced+ only
		if( !bTriedToPickFar && PickLocalInventoryDestination( 600, 0.0 ) )
			return true;

		#debug DMAIM( "PickOrdersDestination #8" );
		if( Orders == OrdersHold && bReadyForOrders )
		{
			#debug DMAIM( "PickOrdersDestination #9" );
			if( VSize( Pawn.Location - OrdersObject.Location ) < 20 )
			{
				#debug DMAI( "going to HoldingState" );
				GotoState( HoldingState );
			}
			else
				GotoState( HoldState );
			return true;
		}

		#debug DMAIM( "PickOrdersDestination #10" );
		if( (Orders == OrdersFollow && bNearPoint) || 
			(Orders == OrdersDefend && bReadyForOrders && LineOfSightTo( OrdersObject )) )
		{
			#debug DMAIM( "PickOrdersDestination #11" );
			if( FRand() < 0.35 )
				GotoState( WanderingState );
			else
			{
				CampTime = 0.8;
				GotoLabel( CampLabel );
			}
			return true;
		}

		#debug DMAIM( "PickOrdersDestination #12 -- return false" );
		return false;
	}

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

	function bool HandleDecorationStuff()
	{
		local Decoration TargetDecoration;

		// if none found, check for decorations with inventory
		if( !bNoShootDecor )
		{
			//!!mdf-tbd: VCA seems to be really slow -- should it be avoided/fixed?
			foreach VisibleCollidingActors( class'Decoration', TargetDecoration, 500, Pawn.Location, true )
			{
				if( TargetDecoration.Contents != None )
				{
					bNoShootDecor = true;
					#debug   SetControllerTarget( TargetDecoration, GetContext() );
					#release SetControllerTarget( TargetDecoration );
					GotoLabel( ShootDecorationLabel );
					return true;
				}
			}
		}

		return false;
	}

	//-------------------------------------------------------------------------
	// Decide whether to hunt player. This isn't the same as going into the 
	// hunting state -- this function is used in the Roaming state to send the
	// NPC to the location of one of the players in the level and only really
	// applies to freelancing bots in dm. The hunting state on the other hand
	// is used to try to locate a current enemy which is no longer visible.

	function bool PickHuntDestination()
	{
		return false;
	}

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

	function bool PickFarInventoryDestination()
	{
		return false;
	}

	//-------------------------------------------------------------------------
	// mdf-tbd: this was a complete mess -- its a bit better now but still 
	// needs work.

	function PickDestination()
	{
		#debug DMAIM( "PickDestination #1 Orders: " $ Orders $ " Pawn Physics: " $ EnumStr( enum'EPhysics', Pawn.Physics ) );
		if( Pawn == None )
			return;

		// check for a special destination
		if( PickSpecialDestination() )
			return;

		#debug DMAIM( "PickDestination #2" );
		// check for destination due to orders
		if( PickOrdersDestination() )
			return;

		if( OrdersObject != None && AmbushPoint(OrdersObject) == None )
			bWantsToCamp = false;
		else if( Pawn.Weapon != None && Pawn.Weapon.AIRating > 0.5 && Pawn.Health > 90 && !Pawn.PhysicsVolume.bWaterVolume )
		{
			bWantsToCamp = (bWantsToCamp || (FRand() < U2PBasic.CampingRate * FMin( 1.0, Level.TimeSeconds - LastCampCheck )));
			LastCampCheck = Level.TimeSeconds;
		}
		else 
			bWantsToCamp = false;

		if( bWantsToCamp && AmbushFindSpot() )
			return;

		#debug DMAIM( "PickDestination #3" );

		// shoot decoration to get stuff?
		if( HandleDecorationStuff() )
			return;

		if( PickFarInventoryDestination() )
			return;

		// nothing around - maybe just wait a little
		if( ( FRand() < 0.35 ) && ( GetSkill() < 0.5 ) 
			&& ( Level.Game.NumPlayers + Level.Game.NumBots > 2 )  )
		{
			CampTime = 3.5 + FRand() - 8*GetSkill();
			GotoLabel( CampLabel );
		}

		// if roamed to ambush point, stay there maybe
		if( (AmbushPoint( RoamTarget ) != None) && 
			(VSize( Pawn.Location - RoamTarget.Location ) < 2*Pawn.CollisionRadius) && 
			(FRand() < 0.4) )
		{
			CampTime = 4.0;
			GotoLabel( CampLongLabel );
			return;
		}

		// maybe pick a player to hunt?
		if( PickHuntDestination() )
			return;
    	
		// look for ambush spot if didn't already try
		if( !bWantsToCamp && AmbushFindSpot() )
		{
			RoamTarget = AmbushSpot;
			return;
		}
		
		#debug DMAIM( "PickDestination #5 RoamTarget=" $ RoamTarget );

		// find a roamtarget
		if( RoamTarget == None )
			RoamTarget = SelectInventorySpotDestination();
			
		if( RoamTarget != None  )
		{
			// roam around
			if( RoamTarget != None )
			{
				#debug DMAIM( "PickDestination #7 -- calling FindPathToActor " $ RoamTarget );
				FindPathToActor( RoamTarget, MoveTarget );
				#debug DMAIM( "PickDestination #7 -- done Path= " $ MoveTarget );
				if( MoveTarget != None )
				{
					return;
				}
				else
				{
					//DMTNS( "Can't build path from current location to " $ RoamTarget );
					//AddActor( Pawn, ColorCyan() );
					//AddArrow( Pawn.Location, RoamTarget.Location, ColorWhite() );
					//AddActorAt( Pawn, RoamTarget.Location, ColorRed() );
					RoamTarget = None;
				}
			}
		}
													
		// wander or camp
		if( FRand() < 0.35 )
		{
			#debug DMAIM( "PickDestination #8" );
			GotoState( WanderingState );
		}
		else
		{
			CampTime = 3.5 + FRand() - 4 * GetSkill();
			GotoLabel( CampLabel );
		}

		#debug DMAIM( "PickDestination End: " $ MoveTarget );
	}

	//-------------------------------------------------------------------------
	/* mdf-tbd - use a timer (was going of of end of animation)
	 
	function SomeTimer() 
	{
 		if( bCamping )
 			SetPeripheralVision();
	}
	*/

	//-------------------------------------------------------------------------
	
	function bool ShouldRecamp()
	{
		return false;
	}

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

	function ModifyMoveTarget();
						 
	//-------------------------------------------------------------------------

	event BeginState()
	{
		#debug DMAIM( "BeginState" );
		bCamping = false;
	}

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

	event EndState()
	{
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
		SetPeripheralVision();
		if( !bSniping && ( AmbushSpot != None ) )
		{
			AmbushSpot.Taken = false;
			AmbushSpot = None;
		}
		bCamping = false;
	}

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

@ CampLongLabel:
	bCamping = true;
	StopMovement( true, false );
	Focus = None;
	FocalPoint = Pawn.Location + Ambushspot.LookDir;
	Sleep( CampTime );
	Goto( PreBeginLabel );

@ GiveWayLabel:
	//log( "sharing" );	
	bCamping = true;
	StopMovement( true, false );
	if( ViewObstructed( 200 ) )
		FinishRotation( DefaultRotationThreshold );
	Sleep( CampTime );
	Goto( PreBeginLabel );

@ CampLabel:
	#debug DMAIL( CampLabel );
	bCamping = true;
	StopMovement( true, false );

@ CampAgainLabel:
	if( ViewObstructed( 200 ) )
		FinishRotation( DefaultRotationThreshold );
	#debug DMAI( "Sleeping for CampTime=" $ CampTime );
	Sleep( CampTime );
	#debug DMAI( "Done sleeping" );

	if( bLeading || bCampOnlyOnce )
	{
		#debug DMAI( "goto PreBegin" );
		bCampOnlyOnce = false;
		Goto( PreBeginLabel );
	}
	#debug DMAI( "checking recamp" );
	if( ShouldReCamp() )
	{
		#debug DMAI( "camp again" );
		Goto( CampAgainLabel );
	}
	#debug DMAI( "done checking recamp" );

@ PreBeginLabel:
	SetPeripheralVision();
	bCamping = false;

@ BeginLabel:
@ MovePickDestLabel:
	WaitForLanding();
	OldMoveTarget = MoveTarget; // hack because refactoring PickDestination would be painful
	PickDestination();
	ModifyMoveTarget();
	if( MoveTarget != OldMoveTarget )
		NumMoveAttempts = 0;

@ MoveSpecialLabel:
@ MoveActiveLabel:
	#debug DMAIM( "MoveTarget: " $ MoveTarget );

	if( MoveTarget == None )
	{
		#debug DMAIM( "MoveTarget is None" );
		StopMovement( true, false );
		Sleep( 0.0 );
		Goto( MovePickDestLabel );
	}

	bCamping = false;
	#debug DMAIM( "Calling MoveToActor  MoveTarget: " $ MoveTarget $ "  NumMoveAttempts: " $ NumMoveAttempts );
	MoveToActor( MoveTarget, TMT_None );
	NumMoveAttempts++;
	#debug DMAIM( "Called MoveToActor  MoveTarget: " $ MoveTarget $ "  MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );
	
	//!!mdf-tbd: hack fix for bots getting stuck against obstacles in some cases
	//see task list / email -- I don't know why this is happening at this point.
	if( MoveResult != MR_DestinationReached && NumMoveAttempts > MaxMoveToActorAttemptsRoaming )
	{
		NumMoveAttempts = 0;
		GotoState( WanderingState );
	}
		
	Goto( MovePickDestLabel );

@ ShootDecorationLabel:
	Focus = ControllerTarget;
	FinishRotation( DefaultRotationThreshold );
	if( ControllerTarget != None )
	{
		FireAt( ControllerTarget );
		bAltFire = 0;
		bFire = 0;
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
	}
	Goto( MovePickDestLabel );

	/*!!mdf-tbd: -- maybe just wait for new code -- ideally should use wandering to move away from friendly pawn
SleepABit:
	StopMovement( true, true );
	Sleep( 2.0 );
	Goto( MovePickDestLabel );
*/
} // RoamingState

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

state @ ScriptedState extends @ MoveToGoalBaseState
{
	event final AnimEnd( int Channel ) 
		{ ScriptController.eventSCAnimEnd( Self, Channel ); }

	event final FinishedRotation()
		{ ScriptController.eventSCFinishedRotation( Self ); }
	
	//-------------------------------------------------------------------------

	function bool AllowFriendlyBumpStateChanges()
	{
		return false;
	}

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

	function EnableProbeEvent( name EventName, bool bVal )
	{
		if( bVal )
			Enable( EventName );
		else
			Disable( EventName );
	}

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

	event bool NotifyLanded( vector HitNormal )
	{
		ScriptedLanding();
		return false;
	}

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

	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 StateTransition( name DestinationState, optional name DestinationLabel )
	{
		// tell script we want to go autonomous -- if script eats the event, we'll stay scripted
		AutoBegin( DestinationState, DestinationLabel );
	}

	//-------------------------------------------------------------------------
	// Script is allowing us to go autonomous.

	function eventAutoBegin( name DestinationState, name DestinationLabel )
	{
		ClearScriptTarget();
    	GotoState( DestinationState, DestinationLabel );
	}

	//-------------------------------------------------------------------------
	// If bLock is true, target not cleared so NPC will periodically turn 
	// towards target.

	function TurnToActor( Actor A, optional bool bLock )
	{
		#debug DMAIA( "TurnToActor: " $ A $ " bLock: " $ bLock );
		#debug   SetControllerTarget( A, GetContext() );
		#release SetControllerTarget( A );
		bScriptLockedTarget = bLock;
		GotoLabel( TurnLabel );
	}

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

	function Actor GetTarget()
	{
		// special target takes priority when under script control
		if( ControllerTarget != None )
			return ControllerTarget;
		else
			return ControllerEnemy;
	}

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

	function bool IsRepeatFire( bool bPrimary )
	{
		return ( GetSpecifiedFireRate( bPrimary ) <= U2Weapon.MaxRapidFireRate );
	}

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

	function MaybeFire( byte bUseAltMode )
	{
		bScriptPendingFire = false;
		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: 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( "Pawn.Weapon.bMeleeWeapon: " $ Pawn.Weapon.bMeleeWeapon );
			#debug DMAIA( "Pawn.Weapon.CanFire(): " $ Pawn.Weapon.CanFire() );
			#debug DMAIA( "Pawn.Weapon.HasEnoughAmmo(1): " $ Pawn.Weapon.HasEnoughAmmo(1) );
		}
	}

	//-------------------------------------------------------------------------
	// If firing in Scripted state, must be doing so under script control so
	// let the script end it.

	// mdf-tbd: but what if weapon is telling NPC to stop firing because out
	// of ammo or reloading?
	//function StopFiring( float SuggestedFireAgainDelay, EStopFiringInfo SFInfo );

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

	function bool AdjustAim( class<Projectile> ProjectileClass, float ProjSpeed, vector ProjStart, float WeaponFireSpread, bool bLeadTarget, bool bWarnTarget, bool bTossed, bool bTrySplash )
	{
		#debug DMAIA( "AdjustAim: " $ ControllerTarget );
		if( ControllerTarget != None )
			return Global.AdjustAim( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, bLeadTarget, bWarnTarget, bTossed, bTrySplash );
		else		
			return true; // use current rotation
	}

	//-------------------------------------------------------------------------
	// mdf-tbd: how to handle blocking destinations like other Pawns etc.
	// If we Bump the final destination generate a "destinationreached" event?

	function eventBumpAll( Actor Other )
	{
		Super.eventBumpAll( Other );
		
		if( SpecialGoal != None && Other == SpecialGoal )
		{
			#debug DMAIM( GetStateName() $ ": eventNotifyBump bumped SpecialGoal -- jumping to ReachedDestination label: " $ Other );
			GotoLabel( ReachedDestinationLabel );
		}
	}

	//-------------------------------------------------------------------------
	
	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		TookDamageBase( Damage, Instigator, HitLocation, Momentum, DamageType );
	}

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

	function EnemyAcquired()
	{
		StateTransition( AcquisitionState, NoLabel );
	}

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

	function SetSpecialGoal( Actor NewSpecialGoal, optional float NewSpecialGoalDistance, optional bool bFaceSpecialGoalNew )
	{
		#debug DMAIE( "SetSpecialGoal: " $ NewSpecialGoal );
		Super.SetSpecialGoal( NewSpecialGoal, NewSpecialGoalDistance, bFaceSpecialGoalNew );
		GotoLabel( BeginLabel );
	}

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

	function HandleDestinationReached()
	{
		Super.HandleDestinationReached();
		SetSpecialGoal( None );
		DestinationReached();
	}
	
	//-------------------------------------------------------------------------

	function SetFall()
	{
		NextState = ScriptedState; 
		NextLabel = ResumePatrolLabel;
		GotoState( FallingState ); 
	}

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

	function float GetMoveSpeed( optional vector TargetLocation )
	{
		return GetScriptedMoveSpeed();
	}

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

	function UseActor( Actor A )	
	{
		class'U2UseManager'.static.UseTarget( U2PBase, A );
	}

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

	function UnuseActor( optional Actor A )
	{
		class'U2UseManager'.static.UnuseTarget( U2PBase );
	}				

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

	function NotifyUnuse( Actor A )
	{
		// trigger myself with UnuseEvent so that script controller can react to this
		Trigger( A, Pawn, UnuseEvent );
	}

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

	event BeginState()
	{
		#debug DMAI( "BeginState: " $ ScriptController );

		// hack:
		if( !bDidStartup )
		{
			DisableSenses( true );
			bDidStartup = true;
		}

		if( U2Pawn(ScriptedFocus) != None && !ValidPawn( Pawn(ScriptedFocus) ) )
			ScriptedFocus = None;

		// let script controller know to make sure EC is enabled so it starts doing its thing (only done once)
		AutoEnd();

		//mdf-ENE
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
	}

	//-------------------------------------------------------------------------
	
	event EndState()
	{
		// if scripted to use something -- can no longer be using it
		UnuseActor();
		EnableSenses( true );
	}

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

@ AdjustFromWallLabel:
	#debug DMAIL( AdjustFromWallLabel );
	MoveToPoint( Destination, , Focus ); 
	Destination = Focus.Location; 
	MoveToPoint( Destination, , None, GetMoveSpeed() );
	Goto( MovePickDestLabel );

@ BeginLabel:
	//DM( "BeginLabel" );
	if( !bInitializedForScripting )
		Goto( StartupDelayLabel );

	#debug DMAIL( BeginLabel );

	// See comment in SetMoveTarget. I believe this should be cleared here also.
	ClearMoveAttempts();

	if( SpecialGoal == None && Orders != OrdersFollow )
	{
  		#debug DMAIM( "No current SpecialGoal -- going idle" );
		Goto( IdleLabel );
	}

@ ResumePatrolLabel:
@ MovePickDestLabel:
	#debug DMAIL( MovePickDestLabel );
	WaitForLanding();
	
	// mdf-tbd: 01/09/23 -- handle destination being cleared at any time
	// mdf-tbd: check if the goal (or ordersobject) is falling and wait for it to land?
	if( SpecialGoal == None && Orders != OrdersFollow )
		Goto( IdleLabel );

	// figure out where to go
	#debug DMAIM( "Calling SetMoveTarget SpecialGoal=" $ SpecialGoal );

	// mdf-tbd: if previous move simply timed out could probably just reuse old destination
	GMoveType = SetMoveTarget( GetSpecialGoal(), GetSpecialGoalDistance() ); 
	if( GMoveType <= MT_None )
	{
  		#debug DMAIM( "!SetMoveTarget -- Abort" );
		Goto( ErrorLabel );
	}

	if( GMoveType == MT_Near || GMoveType == MT_Wait )
	{
  		#debug DMAIM( "SetMoveTarget -- at/near destination" );
		Goto( ReachedDestinationLabel );
	}

@ MoveActiveLabel:
	#debug DMAIM( "MoveToActor BEGIN MoveTarget=" $ MoveTarget $ " SpecialGoal=" $ SpecialGoal $ " SpecialGoalDistance=" $ SpecialGoalDistance $ " ScriptedFocus=" $ ScriptedFocus );
	#debug DMAIM( " (GroundSpeed=" $ Pawn.GroundSpeed $ " DesiredSpeed=" $ Pawn.DesiredSpeed $ " MoveSpeed=" $ GetMoveSpeed() $ ")" );
	//DM( "MoveToActor BEGIN MoveTarget=" $ MoveTarget $ " SpecialGoal=" $ SpecialGoal $ " SpecialGoalDistance=" $ SpecialGoalDistance $ " ScriptedFocus=" $ ScriptedFocus );
	//DM( " (GroundSpeed=" $ Pawn.GroundSpeed $ " DesiredSpeed=" $ Pawn.DesiredSpeed $ " MoveSpeed=" $ GetMoveSpeed() $ ")" );
	MoveToActor( MoveTarget, TMT_None, SpecialGoal, SpecialGoalDistance, ScriptedFocus, GetMoveSpeed() );
	#debug DMAIM( "MoveToActor END " $ MoveTarget $ " returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );
	//DM( "MoveToActor END " $ MoveTarget $ " returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );

	// at this point we may or may not have reached the MoveTarget
	// loop back up to try again (see if final destination now
	// directly reachable, otherwise build a Path which can possibly
	// return the NP that we were just moving to if we haven't 
	// reached it yet (but if we have reached it, then it better
	// not be used again?).

	if( MoveResult != MR_DestinationReachedFinal )
	{
		// mdf-tbd: if not a timeout -- give up immediately (blocked?)
		// after more than N tries give up
	 	if( NumMoveAttempts++ < MaxMoveToActorAttempts )
		{
			Goto( MovePickDestLabel );
	 	}
		else
	 	{
			#debug DMAIM( "Goto GiveUpLabel!" ) ;
			SpecialGoalDistance = default.SpecialGoalDistance;
			Goto( GiveUpLabel );
	 	}
	}

@ ReachedDestinationLabel:
	#debug DMAIL( ReachedDestinationLabel );

	SpecialGoalDistance = default.SpecialGoalDistance;
	if( bDirectionalPatrol && SpecialGoal.bDirectional )
	{
		#debug DMAI( "executing bDirectionalPatrol code" );

		FocalPoint = SpecialGoal.Location + 200*vector(SpecialGoal.Rotation);
		if( NeedToTurn( FocalPoint, NeedToTurnAngleCos ) )
		{	
			Focus = None;
			FinishRotation( DefaultRotationThreshold );
		}
	}
	else
	{
		if( ScriptedFocus == None )
			Focus = None; // clear NPC looking at goal?
		SetRotation( Pawn.Rotation );
		FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
	}

	// tell script controller that we made it (mdf-tbd: is it redundent to pass back the final destination -- where else could we be?)
	HandleDestinationReached();

	#debug DMAIM( "reached destination!" );
	Goto( IdleLabel );

@ IdleLabel:
	#debug DMAI( "IdleLabel: " $ bScriptedIdleAnims );
	// NPC isn't moving -- play idle animations
	Pawn.StopMovement( true, false );				// make sure NPC not moving

@ TurnLabel:
	#debug DMAI( "TurnLabel -- ControllerTarget: " $ ControllerTarget );
	// script has given us a target to rotate towards
	if( ControllerTarget != None )
	{
		if( NeedToTurn( ControllerTarget.Location, NeedToTurnAngleCos ) )
		{	
			#debug DMAI( "Need to turn towards target: " $ ControllerTarget );
	
			// need to rotate towards it
			Focus = None;
			FocalPoint = ControllerTarget.Location;
			FinishRotation( DefaultRotationThreshold );
			#debug DMAI( "Sending FinishedRotation" );
		}

		// let script controller know rotation is complete
		FinishedRotation();
	}

	if( !bScriptLockedTarget )
	{
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
	}
	
@ 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(SpecialGoal) != None )
	{
		Sleep( 1.5 );
		Goto( BeginLabel );
	}

	Stop;

@ StartupDelayLabel:
	#debug DMAssert( !bInitializedForScripting , GetContext() );
	#debug DMAIL( "StartupDelayLabel" );
	// Wait until Pawn/Controller initialized then initialize script controller (which
	// could immediately start controlling the NPC so NPC better be ready).
	#debug DMAI( "DisableSenses" );
	DisableSenses( true );
	Sleep( 0.2 );
	bInitializedForScripting = true;
	EnableSenses( true ); // have to do before call to Initialize -- might never get to line after that
	ScriptController.InitializeScriptController( Self );
	Goto( BeginLabel );
} // ScriptedState

//-----------------------------------------------------------------------------
// NOTE: seems this has to go after the state that is being extended?

state @ ScriptedDialogState extends @ ScriptedState
{
	function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		// take damage = conversation over
		TookDamageBase( Damage, Instigator, HitLocation, Momentum, DamageType );
	}

	//-------------------------------------------------------------------------
	
	function EnemyAcquired()
	{
		GotoState( AcquisitionState, PlayOutLabel );
	}

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

	function DialogSetFocus( Actor FocusActor )
	{
		DialogFocus = FocusActor;
		if( FocusActor != None )
			GotoLabel( DialogFocusSetLabel );
		else
			GotoLabel( DialogFocusRestoreLabel );
	}
	
	//-------------------------------------------------------------------------

	function bool IsDialogPaused() 
	{
		return bIsPaused;
	}

	//-------------------------------------------------------------------------
	
	function DialogPause()
	{
		bIsPaused = true;
		StopMovement( true, true );
		// shouldn't need to inform script (if any) next latent call will
		// complete but resumption of execution will be prevented
	}

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

	function DialogUnPause()
	{
		bIsPaused = false;
		// notify the script that we're unpausing it.
		ScriptController.eventSCDialogUnPause( Self );
	}
		
	//-------------------------------------------------------------------------

	event DialogEnd()
	{
		GotoLabel( DialogEndLabel );
	}

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

	event BeginState()
	{
		SetAlertness( 0.5 );
		OldFocus = Focus;
		OldFocalPoint = FocalPoint;
		DialogPause();
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		RestoreAlertness();
		DialogUnPause();
	}

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

@ DialogBeginLabel:
	// Turn to dialog focus
	if( DialogFocus != None )
		Goto( DialogFocusSetLabel );
	Stop;

@ DialogEndLabel:

	// Restore Focus
	DialogFocus = None;
	if( OldFocus != None )
	{
		Focus = OldFocus;
		FocalPoint = OldFocus.Location;
		if( NeedToTurn( Focus.Location, NeedToTurnAngleCos ) )
			FinishRotation( DefaultRotationThreshold );
	}

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

@ DialogFocusSetLabel:
	if( NeedToTurn( DialogFocus.Location, NeedToTurnDialogAngleCos ) )
	{
		Focus = DialogFocus;
		FocalPoint = DialogFocus.Location;
		if( U2Pawn(DialogFocus) != None )
			FocalPoint += vect(0,0,1)* U2Pawn(DialogFocus).BaseEyeHeight;
		FinishRotation( DefaultRotationThreshold );
		Focus = None;
		FocalPoint = Pawn.Location +256*vector(Pawn.Rotation);
    	Sleep( 1.0 );
    }
	else
	{
		Sleep( 1.0 );
	}
	Goto( DialogFocusSetLabel );

@ DialogFocusRestoreLabel:
	Focus = OldFocus;
	FocalPoint = OldFocus.Location;
	if( NeedToTurn( Focus.Location, NeedToTurnAngleCos ) )
		FinishRotation( DefaultRotationThreshold );
	Stop;

} // ScriptedDialogState

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

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

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

	event bool NotifyLanded( vector HitNormal )
	{
		if( Pawn.Velocity.Z < -1.4 * Pawn.JumpZ )
			Pawn.MakeNoise( -0.5 * Pawn.Velocity.Z/( FMax( Pawn.JumpZ, 150.0 ) ) );
		Pawn.bJustLanded = true;
		return true;
	}

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

	function SharedTimerEvent()
	{
		//DMTNS( "SharedTimerEvent" );
		bReadyToAttack = true;
	}

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

	event BeginState()
	{
		Pawn.LastPainAnimTime = Level.TimeSeconds;
		LastPainAnim = Pawn.AnimSequence;
		if( ( NextState == AttackTacticalMoveState ) && ( Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z ) )
			Destination = Pawn.Location;
	}
		
	//-------------------------------------------------------------------------

@ BeginLabel:
	if( bFireFalling )
	{
		bFireFalling = false;
		GotoState( FallingState, DuckingLabel );
	}
	if( GetSkill() < 0.75 )
		Sleep( 0.05 );
	if ( (Pawn.Physics == PHYS_Falling) && !Pawn.PhysicsVolume.bWaterVolume )
		GotoState( FallingState, DuckingLabel );
	else if( NextState != NoState )
		GotoState( NextState, NextLabel );
	else
		GotoState( AttackingState );
} // TakeHitState

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

state @ TestMoveState extends @ MoveToGoalBaseState
{
	ignores EnemyNotVisible;

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

/*
@ CampLabel:
	StopMovement( true, false );
	Stop;

@ PreBeginLabel:
	bCamping = false;
*/
	
@ BeginLabel:
@ MovePickDestLabel:
	#debug DMAIL( MovePickDestLabel );
	WaitForLanding();
	
	// figure out where to go
	#debug DMAIM( "Calling SetMoveTarget" $ TestMoveTarget );
	if( SetMoveTarget( TestMoveTarget ) <= MT_None )
	{
		#debug DMAIM( "Error calling SetMoveTarget" );
		Goto( ErrorLabel );
	}

@ MoveActiveLabel:
	#debug DMAIL( MoveActiveLabel );

	#debug DMAIM( "MoveToActor BEGIN MoveTarget=" $ MoveTarget $ " NumMoveAttempts=" $ NumMoveAttempts );
	#debug DMAIM( " (GroundSpeed=" $ Pawn.GroundSpeed $ " DesiredSpeed=" $ Pawn.DesiredSpeed );
	MoveToActor( MoveTarget, TMT_None, TestMoveTarget );
	#debug DMAIM( "MoveToActor END " $ MoveTarget $ " returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );

	if( MoveResult != MR_DestinationReachedFinal )
	{
		// after more than N tries give up
	 	if( NumMoveAttempts++ < MaxMoveToActorAttempts )
			Goto( MovePickDestLabel );
		else
	 		Goto( GiveUpLabel );
	}

@ ReachedDestinationLabel:
	#debug DMAI( ReachedDestinationLabel );

	// made it
	Focus = None; // clear NPC looking at goal?
	MoveTarget = None;
	SetRotation( Pawn.Rotation );
	FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
	StopMovement( true, false );
	if( HasScript() )
		GotoState( ScriptedState ); // return to scripted state
	Stop;
} // TestMoveState

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

state @ UsingState
{
	//-------------------------------------------------------------------------

	function UseActor( Actor A )
	{
		// sanity check
		DMAssert( false, GetContext() );
	}				

	//-------------------------------------------------------------------------
	
	function UnuseActor( optional Actor A )
	{
		class'U2UseManager'.static.UnuseTarget( U2PBase );
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}				

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

	function NotifyUnuse( Actor A )
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}

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

	event EndState()
	{
		UnuseActor();
	}
} // UsingState

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

state @ VictoryDanceState extends @ EnemyKilledState
{
	ignores EnemyNotVisible; 

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

	event EndState()
	{
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
	}

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

@ BeginLabel:
	StopMovement( true, false );
	Focus = ControllerTarget;
	FinishRotation( DefaultRotationThreshold );
	Focus = None;
	FocalPoint.Z = Pawn.Location.Z;
	U2P.AnimationController.SpecialAnimationVictoryDance();
	FinishAnim();
	#debug   WhatToDoNext( GetContext() );
	#release WhatToDoNext();
} // VictoryDanceState

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

state @ WanderingState
{
	ignores EnemyNotVisible;

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

	/*!!mdf-tbd: -- maybe just wait for new code -- ideally should use wandering to move away from friendly pawn
	function eventBumpFriend( Pawn Other )
	{
		GotoLabel( 'SleepABit' );
	}
	*/

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

	function bool DeferTo( Controller Other )
	{
		if( Pawn.Acceleration == vect(0,0,0) )
			return Global.DeferTo( Other );

		return false;
	}

/* FIXME
	//-------------------------------------------------------------------------

	singular event BaseChange()
	{
		if( ( Pawn.Base != None ) && Mover(Pawn.Base) != None )
			Destination = Pawn.Location - 300 * Normal( Pawn.Velocity );
		else
			Super.BaseChange();
	}
*/

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

	function SharedTimerEvent()
	{
		//DMTNS( "SharedTimerEvent" );
		Enable( Event_NotifyBump );
	}

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

	function SetFall()
	{
		NextState = WanderingState; 
		NextLabel = ContinueWanderLabel;
		GotoState( FallingState ); 
	}

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

	function bool TestDirection( vector Dir, out vector Pick )
	{	
		local vector HitLocation, HitNormal, Dist;
		local float MinDist;
		local Actor HitActor;

		#debug DMAIM( "TestDirection -- begin" );
		MinDist = FMin( 150.0, 4*Pawn.CollisionRadius );
		if( ( Orders == OrdersFollow ) && ( VSize( Pawn.Location - Controller( OrdersObject ).Pawn.Location ) < 500 ) )
			Pick = Dir * ( MinDist + ( 200 + 6*Pawn.CollisionRadius ) * FRand() );
		else
			Pick = Dir * ( MinDist + ( 450 + 12*Pawn.CollisionRadius ) * FRand() );

		HitActor = Pawn.Trace( HitLocation, HitNormal, Pawn.Location + Pick + 1.5 * Pawn.CollisionRadius * Dir , Pawn.Location, false );
		if( HitActor != None )
		{
			Pick = HitLocation + ( HitNormal - Dir ) * 2 * Pawn.CollisionRadius;
			if( !Pawn.FastTrace( Pick, Pawn.Location ) )
			{
				#debug DMAIM( "TestDirection -- end #1" );
				return false;
			}
		}
		else
			Pick = Pawn.Location + Pick;
		 
		Dist = Pick - Pawn.Location;
		if( Pawn.Physics == PHYS_Walking )
			Dist.Z = 0;
		
		#debug DMAIM( "TestDirection -- end #2" );
		return ( VSize( Dist ) > MinDist ); 
	}
			
	//-------------------------------------------------------------------------

	function PickDestination()
	{
		local vector Pick, PickDir;
		local bool bSuccess, bMustWander;
		local float XY;

		#debug DMAIM( "PickDestination -- begin" );

		//Favor XY alignment
		XY = FRand();
		if( WanderDirectionExternal != vect(0,0,0) )
		{
			PickDir = WanderDirectionExternal;
			XY = 1;
			bMustWander = true;
		}
		else if( XY < 0.3 )
		{
			PickDir.X = 1;
			PickDir.Y = 0;
		}
		else if( XY < 0.6 )
		{
			PickDir.X = 0;
			PickDir.Y = 1;
		}
		else
		{
			PickDir.X = 2 * FRand() - 1;
			PickDir.Y = 2 * FRand() - 1;
		}
		if( Pawn.Physics != PHYS_Walking )
		{
			PickDir.Z = 2 * FRand() - 1;
			PickDir = Normal( PickDir );
		}
		else
		{
			PickDir.Z = 0;
			if( XY >= 0.6 )
				PickDir = Normal( PickDir );
		}	

		bSuccess = TestDirection( PickDir, Pick );
		if( !bSuccess )
			bSuccess = TestDirection( -1 * PickDir, Pick );
		
		if( bSuccess )	
			Destination = Pick;
		else if( bMustWander )
		{
			WanderDirectionExternal = Normal( WanderDirectionExternal + VRand() );
			WanderDirectionExternal.Z = 0;
			Destination = Pawn.Location + 100 * WanderDirectionExternal;
		}
		else
			GotoLabel( TurnLabel );

		WanderDirectionExternal = vect(0,0,0);

		#debug DMAIM( "PickDestination -- end: " $ WanderDirectionExternal*100 );
	}

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

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

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

	event BeginState()
	{
		#debug DMAIM( "BeginState" );
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		SetAlertness( 0.2 );
		bReadyToAttack = false;
		MinHitWall += 0.15;
		if( Pawn != None )
		{
			Pawn.bCanJump = false;
			Pawn.bAvoidLedges = true;
			Pawn.bStopAtLedges = true;
			Pawn.bCanWalkOffLedges = U2PBase.bCanWanderOffLedges;
		}
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		MinHitWall -= 0.15;
		RestoreAlertness();
		if( Pawn != None )
		{
			Pawn.bStopAtLedges = Pawn.default.bStopAtLedges;
			Pawn.bAvoidLedges = Pawn.default.bAvoidLedges;
			Pawn.bCanJump = (Pawn.JumpZ > 0);
			Pawn.bCanWalkOffLedges = Pawn.default.bCanWalkOffLedges;
		}
	}

@ BeginLabel:
@ MovePickDestLabel:
	#debug DMAIM( "MovePickDestLabel" );
	WaitForLanding();
	PickDestination();
	
@ MoveActiveLabel:
	#debug DMAIM( "calling MoveToPoint -- begin" );
	MoveToPoint( Destination, , None, Pawn.WalkingPct );
	#debug DMAIM( "calling MoveToPoint -- end" );

@ PausingLabel:
	if( Level.Game.bTeamGame && (bLeading || (Orders == OrdersFollow && !IsCloseToDynamicGoal( Controller(OrdersObject).Pawn ))) )
		GotoState( RoamingState );
	StopMovement( true, false );
	if( ViewObstructed( 200 ) )
	{
		#debug DMAIM( "ViewObstructed -- calling FinishRotation #1 -- begin" );
		FinishRotation( DefaultRotationThreshold );
		#debug DMAIM( "calling FinishRotation #1 -- end" );
	}
	Sleep( 1.0 );

	GotoState( RoamingState );

@ ContinueWanderLabel:
	if( FRand() < 0.2 )
		Goto( TurnLabel );
	Goto( MovePickDestLabel );

@ TurnLabel:
	StopMovement( true, false );
	Focus = None;
	FocalPoint = Pawn.Location + 20 * VRand();
	#debug DMAIM( "calling FinishRotation #2 -- begin" );
	FinishRotation( DefaultRotationThreshold );
	#debug DMAIM( "calling FinishRotation #2 -- end" );
	Goto( PausingLabel );

/*!!mdf-tbd: -- maybe just wait for new code -- ideally should use wandering to move away from friendly pawn
SleepABit:
	StopMovement( true, true );
	Sleep( 2.0 );
	Goto( MovePickDestLabel );
*/
} // WanderingState

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

defaultproperties
{
	DefaultMeleeAttackState='AttackMelee'
	MaxHuntTime=30.000000
	MaxMoveToActorAttemptsRoaming=2
	Aggressiveness=0.300000
	AttackNonRangedCheckRate=1.000000
	AttackNonRangedFailedRate=1.000000
	AttackReadyToAttackOdds=0.150000
	TimeBetweenAttacks=0.600000
	DefaultState='Roaming'
	DefaultScriptControllerClass=Class'U2AI.ScriptControllerInterf'
	ScriptedScriptControllerClass=Class'U2AI.ScriptControllerBase'
	CrouchingMoveSpeedMultiplier=1.000000
	ProneMoveSpeedMultiplier=1.000000
	StandingMoveSpeedMultiplier=1.000000
	FovAngle=85.000000
	PlayerReplicationInfoClass=None
	RemoteRole=ROLE_None
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}