U2AI.U2NPCControllerBase

//=============================================================================
// U2NPCControllerBase.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 1/06/03 2:59p $
// $Revision: 183 $
//=============================================================================

class U2NPCControllerBase extends U2NPCControllerShared
	config(User);

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

This is the AI Controller class for "base" NPCs. These are generally "ambient"
NPCs which mainly just wander around and won't react to seeing/hearing enemies
etc., although they can be scripted and can engage in "dialog" (e.g. to
support "orders").

The overhead for "base" NPCs should be much lower than that for "basic" or 
"advanced" NPCs. Rendering issues aside, you should be able to have dozens,
perhaps 100+ "base" NPCs in a level without seriously degrading the framerate.

In general, if an NPC is going to be "less than ambient" it will use a "basic"
(NPC doesn't use weapons) or "advanced" (NPC uses weapons) controller so that
it can leverage the "standard" code for handling enemies and attacks etc. But,
in some cases, e.g. for NPCs with very special attacks, "base" can be used and
the input/attack handling code can be implemented in a special controller for
that NPC. 

e.g. the killer sprout and spores are "base" NPCs which have special
attacks handled through their own controllers (the killer sprout grabs enemies
which pass within reach of its tentacles and the sporers simply move towards
enemies, exploding when they bump them and the usual "basic" controller isn't
applicable in these cases.

As another example, it would also be overkill to use a basic+ AI controller to 
simply have a base NPC react to seeing the player -- support for this will
either be added to "base" or a special controller can be used to handle seeing
and reacting (e.g. fly away) to various inputs.

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

MISC NOTES:

==> 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
	+used to not use R_PLAYERONLY paths (obsolete now?)
	+have lower net priority (ok?)
	+can't be outside of the game world in some cases (ok?)

==> misc

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.

==> todo

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?

=== Thoughts ===

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

+base controller supports dialog so pretty much any NPCs (e.g. the seagoat) can
use the dialog system, e.g. for "orders".
*/

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

/* standard ignores events list (for cutting and pasting !!mdf -tbr)
	ignores EnemyNotVisible, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend; // sensory input
	ignores BeginFalling, NotifyLanded, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange; // physics
	ignores KilledBy, ShotFiredNotification, TakeDamage, Trigger; // other

Notes:

Hmm, ignores being used to override global functions in many cases -- I guess
this makes sense...

The following should never have to use ignores with this -- if its implemented
globabally or in some state it will be enabled for that state (I can't imagine
why we'd want to ignore it in these cases -- if we don't want the global
behavior -- its pbly clearer to override it). In some cases we might want to use 
disable/enable to turn these off/on.

	AnimEnd
	Tick
	Timer
	Trigger
*/

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

const HoldReachedDistance2D				=  16.0;
const HoldReachedDistanceSquared2D		= 256.0;
const AvoidedBumpWaitTime				=   1.0;
const AdjustAgainDelay					=   1.0;

const RandomSoundTimerName				= 'RandomSoundTimer'; // used by some NPCs for random idle/attack sounds

//-----------------------------------------------------------------------------
									
// AI flags
var bool bIsPaused;				// is the script paused? (i.e. by dialog)

// AI internal
var name LastPainAnim;
//mdf-tbe: moved to "shared" for now var	float	LastAcquireTime;
var vector WanderDirection;		// most recently selected wander direction
var float WanderMoveSpeed;		// move speed to use with next call to MoveToPoint when wandering

var name BaseAcquisitionState;	// base controllers which might acquire / attack enemies can set this as needed
var name BaseAcquisitionLabel;	// base controllers which might acquire / attack enemies can set this as needed

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

var float NextAdjustPositionTime;
var float NextScriptedMoveTime;

var bool bSavedWanderingParameters;
var float WanderMinAdjustedSizeSaved;
var bool bDistressedWanderingSaved;
var float WanderPauseOddsSaved;
var float WanderSpeedMaxSaved;
var float WanderSpeedMinSaved;
var float WanderTurnToDestinationOddsSaved;
var float WanderSpreadAngleSaved;
//!!mdf-tbd: pbly a bad idea to let panicked NPCs wander off ledges
//var bool bCanWanderOffLedgesSaved;
var float WalkingPctSaved;

var bool bWanderFixed;
var int MaxWanderAttempts;
var int MaxWanderFallbackTypes;

var vector PotentialFocalPoint;

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

var float TimeSinceBeginState;				// used with some states to track how long NPC in that state

// random idle/attack sounds
var float LastRandomSoundTime;

// probes
//var bool bProbeAnimEnd;
var bool bProbeEnemyNotVisible;
var bool bProbeHearNoise;
var bool bProbeNotifyBump;
var bool bProbeEnemyInvalid;
var bool bProbeEnemyInLeapRange;
var bool bProbeEnemyInMeleeRange;
var bool bProbeEnemyNotInMeleeRange;
var bool bProbeEnemyRangeTransition;
var bool bProbeSeeAlertFriend;
var bool bProbeSeeEnemy;
var bool bProbeSeeFriend;
var bool bProbeSeeOther;
var bool bProbeActorRangeTransition;
//var bool bProbeTick;
//var bool bProbeTimer;
//var bool bProbeTrigger;

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

// Implemented in some states if they can be re-initialized when reselecting
// the state without changing to it from a different state (no call to BeginState)

function InitializeState();

/*-----------------------------------------------------------------------------
Master "what should I do now?" function. Performs basic evaluation of the NPC's 
current situation and determines the best course of action. Can be overridden 
to add subclass-specific tests, destination states etc.

Situations where this function is typically called include at startup and when
the NPC's enemy is killed or becomes invalid.
*/

#debug   function WhatToDoNext( string ContextStr )
#release function WhatToDoNext()
{
	#debug DMAI( "U2NPCControllerBase.WTDN (" $ ContextStr $ ") ScriptController=" $ ScriptController $ " Enemy=" $ ControllerEnemy );

	UpdateEnemy();

	if( HasScript() )
	{
		if( GetStateName() != ScriptedState )
		{
			#debug DMAI( "WTDN (Base) selecting " $ ScriptedState $ " (default label)" );
			if( IsInState( ScriptedDialogState ) )
				GotoState( ScriptedState ); //GS-OK
			else
				GotoState( ScriptedState, AutoEndLabel ); //GS-OK
		}
	}
	else if( !IsInState( DefaultState ) )
	{
		#debug DMAI( "WTDN (Base) selecting " $ DefaultState $ " (default label)" );
		GotoState( DefaultState ); //GS-OK
	}

  #debug DMAI( "WTDN keeping current state" );
} // WhatToDoNext

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

function Freeze()
{
	GotoState( CantMoveState ); //GS-OK
}

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

function HandlePanic()
{
	GotoState( WanderingPanicState );
}

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

function EndPanic()
{
	#debug   WhatToDoNext( GetContext() );
	#release WhatToDoNext();
}

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

function SaveWanderingParameters()
{
	if( !bSavedWanderingParameters )
	{
		bDistressedWanderingSaved = U2PBase.bDistressedWandering;
		WanderMinAdjustedSizeSaved = U2PBase.WanderMinAdustedSize;
		WanderPauseOddsSaved = U2PBase.WanderPauseOdds;
		WanderSpeedMaxSaved = U2PBase.WanderSpeedMax;
		WanderSpeedMinSaved = U2PBase.WanderSpeedMin;
		WanderTurnToDestinationOddsSaved = U2PBase.WanderTurnToDestinationOdds;
		WanderSpreadAngleSaved = U2PBase.WanderSpreadAngle;
		//bCanWanderOffLedgesSaved = U2PBase.bCanWanderOffLedges;
		WalkingPctSaved = U2PBase.WalkingPct;
		
		bSavedWanderingParameters = true;
	}
}

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

function SetWanderingPanicParameters()
{
	U2PBase.bDistressedWandering = true;
	U2PBase.WanderMinAdustedSize = 0.0;
	U2PBase.WanderDistMax = FMin( Pawn.CollisionRadius * 3.0, 512.0 );
	U2PBase.WanderDistMin = FMin( Pawn.CollisionRadius * 1.0, 256.0 );
	U2PBase.WanderPauseOdds = 0.0;
	U2PBase.WanderSpeedMax = 1.0;
	U2PBase.WanderSpeedMin = 1.0;
	U2PBase.WanderTurnToDestinationOdds = 0.1;
	U2PBase.WanderSpreadAngle = 90.0;
	//U2PBase.bCanWanderOffLedges = true;
	U2PBase.WalkingPct = 1.0;
}

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

function RestoreWanderingParameters()
{
	U2PBase.bDistressedWandering = bDistressedWanderingSaved;
	U2PBase.WanderMinAdustedSize = WanderMinAdjustedSizeSaved;
 	U2PBase.WanderPauseOdds = WanderPauseOddsSaved;
	U2PBase.WanderSpeedMax = WanderSpeedMaxSaved;
	U2PBase.WanderSpeedMin = WanderSpeedMinSaved;
	U2PBase.WanderTurnToDestinationOdds = WanderTurnToDestinationOddsSaved;
	U2PBase.WanderSpreadAngle = WanderSpreadAngleSaved;
	//U2PBase.bCanWanderOffLedges = bCanWanderOffLedgesSaved;
	U2PBase.WalkingPct = WalkingPctSaved;
	bSavedWanderingParameters = false;
}

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

function RestoreCanStrafe()
{
	Pawn.bCanStrafe = Pawn.default.bCanStrafe;
}
	
//-----------------------------------------------------------------------------

static function float GetRecentAutoEndTime( Pawn SourcePawn )
{
	local Controller C;
	local float ReturnedTime;
	
	//Log.DMTNS( "GetSquadInfo for " $ SourcePawn );
	for( C=SourcePawn.Level.ControllerList; C!=None; C=C.NextController )
	{
		if( class'Pawn'.static.ValidPawn( C.Pawn ) && C.Pawn.SameTeam( SourcePawn ) )
			ReturnedTime = FMax( ReturnedTime, U2NPCControllerBase(C).LastAutoEndTime );
	}
	
	return ReturnedTime;
}

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

function float GetNextRandomSoundTime()
{
	local Controller C;
	local int NumBuddies;
	local float MinTime, MaxTime;

	// determine when next to play an idle sound based on number of active 
	// NPCs of the same class in the area
	for( C=Level.ControllerList; C!=None; C=C.NextController )
		if( !C.bStasis &&
			ValidPawn( C.Pawn ) && 
			C.Pawn.IsA( Pawn.Class.Name ) && 
			VSize( Pawn.Location - C.Pawn.Location ) < 4096.0 )
		{
			NumBuddies++;
		}

	MinTime = FMax( LastRandomSoundTime - Level.TimeSeconds + U2P.MinRandomSoundTime, 0.5 );
	MaxTime = U2P.MaxRandomSoundTime + 2.0*NumBuddies;
	
	//DMTNS( "NumBuddies: " $ NumBuddies );
	//DMTNS( "MinTime:     " $ MinTime );
	//DMTNS( "MaxTime:     " $ MaxTime );
	
	return RandRange( MinTime, MaxTime );
}

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

function SetRandomSoundTimer()
{
	local float NextRandomSoundTime;
	
	if( ValidPawn( Pawn ) )
	{
		NextRandomSoundTime = GetNextRandomSoundTime();
		//DMTNS( "RandomSoundTimer set to " $ NextRandomSoundTime );
		AddTimer( RandomSoundTimerName, NextRandomSoundTime, false );
	}
}

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

function PlayRandomSound()
{
	if( (Level.TimeSeconds - LastRandomSoundTime) <= U2P.MinTimeBetweenRandomSounds )
		return;
		
	if( ControllerEnemy != None )
	{
		//DMTNS( "  calling HandleRandomAttackSound" );
		U2P.HandleRandomAttackSound();
	}
	else
	{
		//DMTNS( "  calling HandleRandomIdleSound" );
		U2P.HandleRandomIdleSound();
	}
		
	LastRandomSoundTime = Level.TimeSeconds;
}

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

function HandleRandomSoundTimer()
{
	if( !ValidPawn( Pawn ) )
		return;

	//NOTE (mdf) currently idle sounds will spam leaping sounds (which we don't
	//want) since all SoundTable sounds are going through SLOT_Talk.
	if( !bStasis )
		PlayRandomSound();
		
	SetRandomSoundTimer();
}

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

function RandomSoundTimer()
{
	HandleRandomSoundTimer();
}

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

function DoPanicSounds()
{
	if( Pawn.SameTeam( U2P.PanicDamageInstigator ) )
		StartFriendlyPanicSound();
	else
		StartPanicSound();
}

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

function StartFriendlyPanicSound()
{
	local float SoundDuration;
	local sound PlayedSound;

	PlayedSound = U2PBase.AssetsHelperClass.static.HandleFriendlyPanicSound( U2PBase );
	if( PlayedSound != None )
	{
		SoundDuration = GetSoundDuration( PlayedSound );
		if( SoundDuration > 0 )
			AddTimer( 'StartPanicSound', SoundDuration );
		U2PBase.CurPanicSound = PlayedSound;	// used to stop sound when panic time is up
	}
}

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

function StartPanicSound()
{
	local float SoundDuration;
	local sound PlayedSound;

	PlayedSound = U2PBase.AssetsHelperClass.static.HandlePanicSound( U2PBase, U2PBase.PanicDamageType );
	if( PlayedSound != None )
	{
		SoundDuration = GetSoundDuration( PlayedSound );
		if( SoundDuration > 0 )
			AddTimer( 'StartPanicSound', SoundDuration + U2PBase.PanicSoundPauseSeconds );
		U2PBase.CurPanicSound = PlayedSound;	// used to stop sound when panic time is up
	}
}

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

function EndPanicSound()
{
	if( U2PBase.CurPanicSound != None )
	U2PBase.StopSound( U2PBase.CurPanicSound, 0.5 );
	U2PBase.AssetsHelperClass.static.HandlePanicSoundEnding( U2PBase, U2PBase.PanicDamageType );
}

/*-----------------------------------------------------------------------------
Sets global (non-state) probe status for various events. Note that 
enable/disable apply on a per-state basis so this will have no effect within 
any states. Does that make doing this pretty much useless?

Note:

event PrepareForMove:

	Called from execMoveToward if/when target reachspec is too small for NPC
	(and that reachspec would only be used if the path-finding code determined
	previously that the NPC is capable of using it -- i.e. can crouch etc. to
	fit within reachspec). Also called if destination navigation point has
	special move requirements (bSpecialMove)

event BreathTimer:

	Only called if BreathTime > 0.0.

function Trigger: 

	Not really an event but is a probe function.

Note: 
*/

function SetEvents()
{
	// shouldn't these all be enabled by default at this point?
	// mdf-tbd: yes, if functions are implemented, but for performance
	// reasons, we pbly don't want any of these enabled by default
	// (let subclasses enable these as needed or add flags to control
	// whether to leave these enabled here)?

	//SetProbing( Event_AnimEnd,		bProbeAnimEnd );
	SetProbing( Event_EnemyNotVisible,		bProbeEnemyNotVisible );
	SetProbing( Event_HearNoise,			bProbeHearNoise );
	SetProbing( Event_NotifyBump,			bProbeNotifyBump );
	SetProbing( Event_SeeEnemy,			bProbeSeeEnemy );
	//SetProbing( Event_SeeAlertFriend, 	bProbeSeeAlertFriend );
	//SetProbing( Event_SeeFriend, 		bProbeSeeFriend );
	//SetProbing( Event_SeeOther,			bProbeSeeOther );
	//SetProbing( Event_Tick,				bProbeTick );
	//SetProbing( Event_Timer,				bProbeTimer );
	//SetProbing( Event_Trigger,			bProbeTrigger );

}

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

function InitializeEvents()
{
	SetEvents();

#debugbegin
	//DMAssert( bProbeAnimEnd			|| !IsProbing( Event_AnimEnd ), GetContext() );
	DMAssert( bProbeEnemyNotVisible	|| !IsProbing( Event_EnemyNotVisible ), GetContext() );
	DMAssert( bProbeHearNoise			|| !IsProbing( Event_HearNoise ), GetContext() );
	DMAssert( bProbeNotifyBump		|| !IsProbing( Event_NotifyBump ), GetContext() );
	DMAssert( bProbeSeeEnemy			|| !IsProbing( Event_SeeEnemy ), GetContext() );
	//DMAssert( bProbeTick				|| !IsProbing( Event_Tick ), GetContext() );
	//DMAssert( bProbeTimer				|| !IsProbing( Event_Timer ), GetContext() );
	//DMAssert( bProbeTrigger			|| !IsProbing( Event_Trigger ), GetContext() );

	//!!mdf-tbd: currently is being handled globally...
	//DMAssert( !IsProbing( Event_AnimEnd ), GetContext() );

	//DumpAIEvents();
#debugend	
}

//-----------------------------------------------------------------------------
// mdf-tbr: testing...

function DumpAIEvents()
{
	DMTNS( "DumpAIEvents -- begin Pawn: " $ Pawn );
	ID();

	DM( "AnimEnd               " $ byte(IsProbing( Event_AnimEnd ))				$ " (X)" );
	DM( "EnemyNotVisible       " $ byte(IsProbing( Event_EnemyNotVisible ))		$ " (" $ byte(bProbeEnemyNotVisible)		$ ")" );
	DM( "HearNoise             " $ byte(IsProbing( Event_HearNoise ))				$ " (" $ byte(bProbeHearNoise)				$ ")" );
	DM( "NotifyBump            " $ byte(IsProbing( Event_NotifyBump ))				$ " (" $ byte(bProbeNotifyBump)				$ ")" );
	DM( "EnemyInvalid	       " $ byte(IsProbing( Event_EnemyInvalid ))           $ " (" $ byte(bProbeEnemyInvalid)           $ ")" );	
	DM( "EnemyInLeapRange      " $ byte(IsProbing( Event_EnemyInLeapRange ))       $ " (" $ byte(bProbeEnemyInLeapRange)       $ ")" );
	DM( "EnemyInMeleeRange     " $ byte(IsProbing( Event_EnemyInMeleeRange ))      $ " (" $ byte(bProbeEnemyInMeleeRange)      $ ")" );
	DM( "EnemyNotInMeleeRange  " $ byte(IsProbing( Event_EnemyNotInMeleeRange ))   $ " (" $ byte(bProbeEnemyNotInMeleeRange)   $ ")" );
	DM( "EnemyRangeTransition  " $ byte(IsProbing( Event_EnemyRangeTransition ))   $ " (" $ byte(bProbeEnemyRangeTransition)   $ ")" );
	DM( "SeeEnemy              " $ byte(IsProbing( Event_SeeEnemy ))				$ " (" $ byte(bProbeSeeEnemy)				$ ")" );
	DM( "SeeFriend             " $ byte(IsProbing( Event_SeeFriend ))				$ " (" $ byte(bProbeSeeFriend)				$ ")" );
	DM( "SeeAlertFriend        " $ byte(IsProbing( Event_SeeAlertFriend ))			$ " (" $ byte(bProbeSeeAlertFriend)			$ ")" );
	DM( "SeeOther              " $ byte(IsProbing( Event_SeeOther ))				$ " (" $ byte(bProbeSeeOther)				$ ")" );
	DM( "ActorRangeTransition  " $ byte(IsProbing( Event_ActorRangeTransition ))	$ " (" $ byte(bProbeActorRangeTransition)   $ ")" );
	DM( "Tick                  " $ byte(IsProbing( Event_Tick ))					$ " (X)" );
	DM( "Timer                 " $ byte(IsProbing( Event_Timer ))					$ " (X)" );
	DM( "Trigger               " $ byte(IsProbing( Event_Trigger ))				$ " (X)" );

	//DM( "All Probes:" );
	//DumpProbes();
	OD();
	DMTNS( "DumpAIEvents -- end Pawn: " $ Pawn );
}

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

event float Desireability( Pickup P )
{
	// mdf-tbr: make sure only called for bots!
	DMAssert( false, GetContext() );
	return 0.0;
}

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

function ETacticalMoveType GetTacticalMoveType()
{
	if( LPawn.GetAlert() )
		return Pawn.TacticalMoveType;
	else
		return Super.GetTacticalMoveType();
}
	
//-----------------------------------------------------------------------------

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

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

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

	Super.Possess( P );

	Pawn.SetMovementPhysics( true ); 

	SetPeripheralVision();

	// mdf-tbr in 829 (SteveP added this to AIController.uc)
	// preserve Pawn's rotation initially for placed Pawns
	FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);

	InitializeEvents();

	PossessStartup();
}

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

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

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

/* not enough room for both state and script...
function string GetStateInfoString()
{
	if( HasScript() )
		return Super.GetStateInfoString() $ "/" $ ScriptController.GetCommandFile();
	else
		return Super.GetStateInfoString();
}
*/

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

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

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

	// NOTE: actual damage might be filtered out 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
	{
		// not called if NPC is dead
		TookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
	}
}

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

function DamageAttitudeTo( Pawn Other, float Damage, class<DamageType> DamageType )
{
	#debug DMAIA( "DamageAttitudeTo  Other: " $ Other $ " Damage: " $ Damage $ " DamageType: " $ DamageType );

	if( Pawn != None && Pawn.Health > 0 )
	{
		#debug DMAIA( "DamageAttitudeTo: " $ ControllerEnemy $ " ValidEnemy(Other): " $ ValidEnemy( Other ) );

		if( ValidEnemy( Other ) )
		{
			#debug DMAI( "DamageAttitudeTo -- calling MaybeSetEnemy" );
			MaybeSetEnemy( Other );
		}
	
		//NOTE (mdf) - don't necessarily have LOS to enemy...
		if( ControllerEnemy != None && ControllerEnemy == Other )
			EnemyDetected( ControllerEnemy.Location );
	}
}

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

function eventTookDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
{
	// mdf: don't react if dead (was resurrecting dead NPCs...)
	Super.eventTookDamage( Damage, Instigator, HitLocation, Momentum, DamageType );

	// let some NPCs become aggressive when they take damage (attack next enemy, not damage instigator)
	// do this before checking if dead because we might want to alert nearby NPCs
	//DMTNS( "eventTookDamage" );
	if( U2PBase.bAmbientCreature && (float(U2PBase.Health) / float(U2PBase.InitialHealth)) < U2PBase.BecomeAggressiveHealthRatio )
	{
		//DMTNS( "becoming aggressive" );
		U2PBase.bAmbientCreature = false;
	}
	
	if( Pawn.Health > 0 )
	{
		// maybe set Instigator as enemy -- in some states (e.g. attacktactical, instigator is ignored)
		DamageAttitudeTo( Instigator, Damage, DamageType );

		#debug DMAI( "eventTookDamage -- Pawn is valid (set and alive)");
	}
}

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

function NotifyInvalidLanding( CheckResult Hit )
{
	GotoState( HandleInvalidLandingState );
}

/*-----------------------------------------------------------------------------
MinZ support: save NPCs who cross the MinZ threshold iff:

A: NPC is friendly to the player and has a script (could be autonomous)

OR

B: NPC isn' t friendly to the player but is currently executing a script

The idea is that friendly NPCs with a script are often critical to the 
continuation of the game so that we need to save them. Non-friendly NPCs which 
are autonomous (even if the have a script to go back to) should never be
essential to the game -- the fact that they are autonomous means they are 
fighting and could die from that, let alone from falling out of the world.
*/

event FellOutOfWorld()
{
	local U2NPCControllerBase U2NPCB;
	local EAttitude AttitudeToPlayer;
	local Pawn PlayerPawn;

	if( Level.PlayerControllerList != None )
		PlayerPawn = Level.PlayerControllerList.Pawn;
	
	if( PlayerPawn != None )
		AttitudeToPlayer = GetAttitudeTo( PlayerPawn );
		
	if( (AttitudeToPlayer == ATTITUDE_Friend && HasScript()) ||
	    (AttitudeToPlayer != ATTITUDE_Friend && UnderScriptControl()) )
	{
		// save NPC
		#debug DMAIM( "FellOutOfWorld trying to save NPC" );
		NavigationError( ET_MinZ, "FellOutOfWorld" );
		
		if( !U2P.bDisableErrorColors )
			AddActor( Pawn, ColorCyan() );
			
		StopMovement( true, true );
		MoveTimer = -1.0;

		if( RecoverFromMinZError() && !U2P.bDisableErrorColors )
			AddCylinder( Pawn.Location, 4, 4, ColorCyan() );
	}
	else
	{
		// default handling
		Pawn.HandleFellOutOfWorld();
	}
}

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

function UpdateEnemy( optional bool bTryRadiusCheck )
{
	if( !ValidEnemy( ControllerEnemy ) )
	{
		#debug DMAI( "UpdateEnemy clearing enemy" );
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
	}
}

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

function EReaction GetReactionToEnemy( Pawn EnemyPawn )
{
	return REACTION_Fear;
}

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

function bool DeferTo( Controller Other )
{
	return false;
}

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

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

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

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

// 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( MoveFailedLabel );
	
@ ErrorLabel:
	#debug DMAIL( ErrorLabel );
	NavigationError( ET_InternalPath, "at move error label" );
	Goto( MoveFailedLabel );

@ MoveFailedLabel:
	StopMovement( true, true );
	Stop;

@ MoveFallingLabel:
	WaitForLanding();
	Goto( MovePickDestLabel );
	Stop;
} // MoveToGoalBaseState

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

//-----------------------------------------------------------------------------
// Pawn can't move or rotate but can still aim and shoot. Not moved by damage.

state @ CantMoveState
{
	//-------------------------------------------------------------------------

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

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

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

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

	function UnFreeze()
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}

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

	event BeginState()
	{
		Super.BeginState();
		StopMovement( true, true );
	}
	
@ BeginLabel:
	Stop;
} // CantMoveState

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

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

	function PlayRandomSound();

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

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

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

	function PlayRandomSound();

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

	event bool NotifyHeadVolumeChange( PhysicsVolume NewHeadVolume )
	{
		Global.NotifyHeadVolumeChange( NewHeadVolume );
		if ( !NewHeadVolume.bWaterVolume )
		{
			#debug   WhatToDoNext( GetContext() );
			#release WhatToDoNext();
		}
		return false;
	}

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

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

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

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

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

	event BeginState()
	{
		bAdjustFromWalls = false;
	}

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

	event EndState()
	{
		bAdjustFromWalls = true;
	}

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

@ BeginLabel:
@ MovePickDestLabel:
	PickDestination();
	
@ MoveActiveLabel:	
	if( ControllerEnemy == None )
		MoveToPoint( Destination );
	else
		MoveToPoint( Destination, , ControllerEnemy );
		
	#debug   WhatToDoNext( GetContext() );
	#release WhatToDoNext();
	
	Goto( MovePickDestLabel );
} // FindAirState

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

state @ FrozenState extends @ CantMoveState
{
	ignores SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, HearNoise, EnemyInLeapRange, EnemyInMeleeRange;
	
@ BeginLabel:
	StopMovement( true, true );
	Stop;
} // FrozenState

//-----------------------------------------------------------------------------
// NPC landed on a railing or something where it shouldn't be (mainly happens
// during leaps).

state @ HandleInvalidLandingState extends @ MoveToGoalBaseState
{
	ignores EnemyNotVisible, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend; // sensory input
	ignores BeginFalling, NotifyLanded, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange; // physics
	ignores ShotFiredNotification;
	ignores DamageAttitudeTo, EnemyInLeapRange, EnemyInMeleeRange;

	//-------------------------------------------------------------------------
	
	function NotifyInvalidLanding( CheckResult Hit );
	function EnemyAcquired();
	function HandlePanic();
	function bool CanDodge( optional bool bIgnoreFalling ) { return false; }

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

	function HandledInvalidLanding()
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
	
	//-------------------------------------------------------------------------

	function NotifyValidLanding( CheckResult Hit )
	{
		HandledInvalidLanding();
	}

	//-------------------------------------------------------------------------
	
	function Actor GetStepDownDestination( bool bForward )
	{
		local NavigationPoint Nav, BestNav;
		local vector NavVector;
		local float Distance, ClosestDistance;
		local float UnNormalizedCos;
		
		ClosestDistance = 999999.9;
		for( Nav=Level.NavigationPointList; Nav!=None; Nav=Nav.NextNavigationPoint )
		{
			NavVector = Nav.Location - Pawn.Location;
			UnNormalizedCos = NavVector dot vector(Pawn.Rotation);
			
			if( (bForward && UnNormalizedCos > 0.0 ) ||
				(!bForward && UnNormalizedCos <= 0.0 ) )
			{
				Distance = VSize( NavVector );
				if( Distance < 1200 && 
					Distance < ClosestDistance && 
					ActorReachable( Nav ) )
				{
					ClosestDistance = Distance;
					BestNav = Nav;
				}
			}
		}
		
		return BestNav;
	}
	
	//-------------------------------------------------------------------------
	// Try to pick a destination that will correct the problem asap.
	
	function bool PickDestination()
	{
		// find  the closest reachable navigation point within 1200 units and
		// in front of the NPC (pbly looks better and helps to avoid cycling
		// issues due to hitting something while moving forward, landing on it,
		// backing up, repeat)
		MoveTarget = GetStepDownDestination( true );

		if( MoveTarget == None )
		{
			// try again, but this time look for points behind the NPC
			MoveTarget = GetStepDownDestination( false);
		}

		//if( MoveTarget != None )
		//	AddActor( MoveTarget, ColorGreen() );
		
		//DMTNS( "MoveTarget: " $ MoveTarget );
		return ( MoveTarget !=  None );
	}

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

	event BeginState()
	{
		//DMTNS( "BeginState" );
		Super.BeginState();
		U2P.bCanKnockDown = false;
		U2P.bSpecialHardLandings = false;
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		//DMTNS( "EndState" );
		Super.EndState();
		if( U2P != None )
		{
			U2P.bCanKnockDown = U2P.default.bCanKnockDown;
			U2P.bSpecialHardLandings = U2P.default.bSpecialHardLandings;
		}
	}
	
	//-------------------------------------------------------------------------
	
@ BeginLabel:

@ MovePickDestLabel:
	WaitForLanding();
	
	if( !PickDestination() )
	{
		//DMTNS( "HandleInvalidLanding can't find a valid destination" );
		HandledInvalidLanding(); // can't find a suitable destination?!
	}
	
@ MoveActiveLabel:
	MoveToActor( MoveTarget, TMT_None, , , ControllerEnemy );
	if( MoveResult != MR_DestinationReached )
	{
		if( ++NumMoveAttempts <= 8 )
			Goto( MovePickDestLabel );
		//else
		//	DMTNS( "HandleInvalidLanding timed-out" );
	}

	HandledInvalidLanding();		
} // HandleInvalidLandingState

//-----------------------------------------------------------------------------
// 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
{
	//!!mdf allow NPC to acquire enemy without moving until state ends?
	ignores EnemyNotVisible, HearNoise, NotifyBump, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend; // sensory input
	ignores BeginFalling, NotifyLanded, NotifyHitWall, NotifyHeadVolumeChange, NotifyPhysicsVolumeChange; // physics
	ignores ShotFiredNotification; // other

	function PlayRandomSound();

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

	function LandedHardDone()
	{
		#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

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

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

	event final SeeAlertFriend( Pawn Seen )
		{ ScriptController.eventSCSeeAlertFriend( Self, Seen ); }

	event final SeeFriend( Pawn Seen )
		{ ScriptController.eventSCSeeFriend( Self, Seen ); }

	/* tbd	
	event final SeeOther( Actor Seen )
		{ ScriptController.eventSCSeeOther( Self, Seen ); }
	*/

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

	function string GetStateInfoString()
	{
		return ScriptController.GetCommandFile();
	}
	
	//-------------------------------------------------------------------------

	event final ActorRangeTransition( bool bInRange )
	{
		if( bInRange )
			ActorInRange();
		else
			ActorOutOfRange();	
	}

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

	function bool AllowFriendlyBumpStateChanges()
	{
		return false;
	}

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

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

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

	function HandleFinishedRotation()
	{
		FinishedRotation();
	}

	//-------------------------------------------------------------------------
	// NOTE: NPCs which use a base AI controller NPCs don't usually have 
	// attacks but this provides limited support for handling an acquired enemy 
	// while in the scripted state.
	
	function EnemyAcquired()
	{
		if( BaseAcquisitionState != '' )
		{
			// script might block reacting to enemy...
			AutoBegin( BaseAcquisitionState, BaseAcquisitionLabel );
		}
	}

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

	function bool AvoidFriendlyBump( Pawn Other )
	{
		if( !U2PBase.bAvoidFriendlyBumps )
			return false;
			
		if( Level.TimeSeconds < NextAdjustPositionTime )
		{
			//if( NextAdjustPositionTime - Level.TimeSeconds > 0.5 )
			//	DMTNS( "AvoidFriendlyBump " $ Other $ " still handling previous bump" );
			return false;
		}
		
		//!!mdf-tbd: only use with players?
		if( !Other.bIsRealPlayer )
		{
			//DMTNS( "AvoidFriendlyBump " $ Other $ " not a player" );
			return false;
		}
		
		//!!mdf-tbd:
		if( Pawn.Physics != PHYS_Walking )
		{
			//DMTNS( "AvoidFriendlyBump " $ Other $ " Physics: " $ Pawn.Physics );
			return false;
		}
			
		//!!mdf-tbd:
		//if( VSize( Pawn.Velocity ) > 0.0 )
		//	return false;

		//DMTNS( "AvoidFriendlyBump " $ Other $ "!" );
		return true;
	}

	//-------------------------------------------------------------------------
	
	function bool SetDestination( vector Direction, float Distance )
	{
		local vector TargetLocation;
		
		Direction.Z = 0; // assume walking
		TargetLocation = Pawn.Location + Distance * Direction;
		
		//AddCylinder( TargetLocation, 2, 2, ColorWhite() );
		
		class'UtilGame'.static.AdjustDestinationForPhysics( Pawn, TargetLocation );
		//AddCylinder( TargetLocation, 4, 4, ColorYellow() );
		//AddArrow( Pawn.Location, TargetLocation, ColorOrange() );
		
		if( Pawn.FitActorAt( TargetLocation ) == 0 )
		{
			//DMTNS( "!FitActorAt" );
			//AddActorAt( Pawn, TargetLocation, ColorPink() );
			return false;
		}

		if( !PointReachable( TargetLocation ) )
		{
			//DMTNS( "!PointReachable" );
			//AddActorAt( Pawn, TargetLocation, ColorOrange() );
			return false;
		}
		
		//DMTNS( "success" );
		Destination = TargetLocation;
		return true;
	}
	
	//-------------------------------------------------------------------------

	function MaybeAvoidFriendlyBump	( Pawn Other )
	{
		local bool bFoundAdjustedLocation;
		local vector AvoidVector2D, CheckVector2D;
		local vector TargetLocation;
		local float ShiftDistance;
		local CheckResult Hit;
		
		Global.MaybeAvoidFriendlyBump( Other );
		
		//!!mdf-tbd: use this in other states too?
		if( IsMobile() && AvoidFriendlyBump( Other ) )
		{
			ShiftDistance = 2.0 * FMax( Pawn.CollisionRadius, Other.CollisionRadius );

			// try to move right/left then back if necessary
			
			// try right/left
			AvoidVector2D = Normal( (Other.Location - Pawn.Location) cross vect(0,0,1) );
			if( (AvoidVector2D dot Other.Velocity) > 0 )
				AvoidVector2D *= -1.0;
			
			//!!mdf-tbd: try 8 compass pts? Seems to work well as-is
			//DMTNS( "try + 2 x ShiftDistance");
			bFoundAdjustedLocation = SetDestination( AvoidVector2D, 2*ShiftDistance );
			if( !bFoundAdjustedLocation )
			{
				//DMTNS( "try - 2 x ShiftDistance");
				bFoundAdjustedLocation = SetDestination( -AvoidVector2D, 2*ShiftDistance );
			}
			if( !bFoundAdjustedLocation )
			{
				//DMTNS( "try + 1 x ShiftDistance");
				bFoundAdjustedLocation = SetDestination( AvoidVector2D, ShiftDistance );
			}
			if( !bFoundAdjustedLocation )
			{
				//DMTNS( "try - 1 x ShiftDistance");
				bFoundAdjustedLocation = SetDestination( -AvoidVector2D, ShiftDistance );
			}

			if( !bFoundAdjustedLocation )
			{
				// if room for both Pawns, try left/right smaller amounts
				TargetLocation = Pawn.Location;
				if( Pawn.FitActorAt( TargetLocation, Pawn.CollisionHeight, Pawn.CollisionRadius + Other.CollisionRadius + 1.0 ) != 0 )
				{
					//DMTNS( "try + 0.5 x ShiftDistance");
					bFoundAdjustedLocation = SetDestination( AvoidVector2D, 0.5*ShiftDistance );
					
					if( !bFoundAdjustedLocation )
					{
						//DMTNS( "try - 0.5 x ShiftDistance");
						bFoundAdjustedLocation = SetDestination( -AvoidVector2D, 0.5*ShiftDistance );
					}
				}
				//else
				//{
				//	AddCylinder( TargetLocation, Pawn.CollisionHeight, Pawn.CollisionRadius + Other.CollisionRadius + 2.0, ColorMagenta() );
				//}
			}
			
			if( !bFoundAdjustedLocation )
			{
				// try back
				//DMTNS( "try back 2 x ShiftDistance");
				AvoidVector2D = Pawn.Location - Other.Location;
				AvoidVector2D.Z = 0;
				AvoidVector2D = Normal( AvoidVector2D );

				//AddArrow( Pawn.Location, Pawn.Location + 2*ShiftDistance*AvoidVector2D, ColorOrange() );				
				bFoundAdjustedLocation = SetDestination( AvoidVector2D, 2*ShiftDistance );
				if( !bFoundAdjustedLocation )
				{
					//AddArrow( Pawn.Location, Pawn.Location + ShiftDistance*AvoidVector2D, ColorOrange() );
					//DMTNS( "try back 1 x ShiftDistance");
					bFoundAdjustedLocation = SetDestination( AvoidVector2D, ShiftDistance );
				}
			}

			if( !bFoundAdjustedLocation )
			{
				// check for tight corridor (wall close to NPC on at least 1 
				// side) and use wall's hit normal to send the NPC directly 
				// back along the wall relative to other's location

				CheckVector2D = Normal( (Other.Location - Pawn.Location) cross vect(0,0,1) );

				if( !Pawn.SingleLineCheck( Hit, Pawn, Pawn.Location + 2*Pawn.CollisionRadius*CheckVector2D, Pawn.Location, TRACE_AllBlocking ) )
				{
					AvoidVector2D = Hit.Normal cross vect(0,0,1);
					if( (AvoidVector2D dot Normal( Other.Location - Pawn.Location )) > 0 )
						AvoidVector2D *= -1.0;
						
					//DMTNS( "try special back 2 x ShiftDistance");
					//AddArrow( Pawn.Location, Pawn.Location + 2*ShiftDistance*AvoidVector2D, ColorPink() );				
					bFoundAdjustedLocation = SetDestination( AvoidVector2D, 2*ShiftDistance );
					if( !bFoundAdjustedLocation )
					{
						//AddArrow( Pawn.Location, Pawn.Location + ShiftDistance*AvoidVector2D, ColorPink() );
						//DMTNS( "try back 1 x ShiftDistance");
						bFoundAdjustedLocation = SetDestination( AvoidVector2D, ShiftDistance );
					}
				}
			}

			if( bFoundAdjustedLocation )
			{
				//DMTNS( "will adjust position" );
				Focus = Other;
				NextAdjustPositionTime = Level.TimeSeconds + AdjustAgainDelay;
				NextScriptedMoveTime = Level.TimeSeconds + AvoidedBumpWaitTime; // make sure script doesn't move NPC during adjust
				MoveTimer = -1.0f; // kill off any existing MoveToPoint/Actor
				GotoLabel( AdjustPositionLabel );
			}
			else
			{
				// if NPC was unable to get out of the way, filter additional 
				// bumps for a bit to avoid trying to handle too many bumps?
				NextAdjustPositionTime = Level.TimeSeconds + 0.50;
			}
		}
	}

	//-------------------------------------------------------------------------
	// If above call to AutoBegin is reflected back to this function then the
	// script is allowing the NPC to go autonomous.

	function eventAutoBegin( name DestinationState, name DestinationLabel )
	{
		ClearScriptTarget();
    	GotoState( DestinationState, DestinationLabel ); //GS-OK
	}

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

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

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

	function SetSpecialGoal( Actor NewSpecialGoal, optional float NewSpecialGoalDistance, optional bool bFaceSpecialGoalNew )
	{
		#debug DMAIE( "SetSpecialGoal: " $ NewSpecialGoal );
		Super.SetSpecialGoal( NewSpecialGoal, NewSpecialGoalDistance, bFaceSpecialGoalNew );
		
		//DMTNS( "SetSpecialGoal time until ok to move: " $ NextScriptedMoveTime - Level.TimeSeconds );
		
		if( NewSpecialGoal != None )
		{
			//!!mdf-tbd: assume that with non-Pawn destinations, we don't ever need
			// to enable "get out of way" behavior since a) scripted NPCs can walk
			// through the player (enemies will attack him) and b) we should never
			// send an NPC to a location in which the player could be trapped unless
			// the NPC will move shortly. Otherwise the script can/should enable
			// bump handling for the NPC or the destination should be moved.
			if( Pawn(NewSpecialGoal) == None )
				U2PBase.bAvoidFriendlyBumps = false;
			else
				U2PBase.bAvoidFriendlyBumps = U2PBase.default.bAvoidFriendlyBumps;
		}
		
		// postpone move if doing a special move (e.g. avoid bump) -- that 
		// code will ensure that this move eventually happens
		if( Level.TimeSeconds >= NextScriptedMoveTime )
			GotoLabel( MovePickDestLabel );
	}

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

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

	//-------------------------------------------------------------------------
	// 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 ETacticalMoveType GetTacticalMoveType()
	{
		return ScriptedTacticalMoveType;
	}

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

	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();
			bDidStartup = true;
		}

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

		//mdf-ENE
		#debug   SetControllerEnemy( None, GetContext() );
		#release SetControllerEnemy( None );
		// SetAlertness( 0.0 );
		// DMN( GetStateName() $ " -- BeginState" );

		if( !U2PBase.bLookForAlertFriends )
			Disable( Event_SeeAlertFriend );

		// set even if not friendly to player in case this changes (e.g. via the script)
		Pawn.bCanEncroachPlayer = true;
		
		//!!mdf-tbd: this makes sense in theory (so that scripted Pawns will always
		//face along their direction of movement) but it may be messing with existing
		//behavior (causing NPCs to be oriented in slightly different ways).
		Pawn.bCanStrafe = U2PBase.bCanStrafeScripted;

		// this only gets enabled during / after "gotoactor somepawn"
		U2PBase.bAvoidFriendlyBumps = false;
	}

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

	event EndState()
	{
		if( Pawn != None )
		{
			Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
			Pawn.bCanEncroachPlayer = false;
			RestoreCanStrafe();
			U2PBase.bAvoidFriendlyBumps = U2PBase.default.bAvoidFriendlyBumps;
		}
		
		// if scripted to use something -- can no longer be using it
		UnuseActor();

		//!!mdf: this might be enabling senses which aren't needed for some NPCs 
		// should respect bProbeSeeMonster etc.
		#debug DMAI( "EnableSenses in EndState" );
		EnableSenses();
	}

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

@ 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();
	Sleep( 0.2 );
	bInitializedForScripting = true;
	EnableSenses(); // have to do before call to Initialize -- might never get to line after that
	ScriptController.InitializeScriptController( Self );
	Goto( BeginLabel );

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

@ AdjustPositionLabel:
	//DMTNS( "adjusting position" );
	#debug DMAIA( "adjusting position" );
	//AddActorAt( Pawn, Destination, ColorGreen() );
	//AddArrow( Pawn.Location, Destination, ColorGreen() );
	ClearMoveAttempts();
	
@ AdjustPositionAgainLabel:
	//DMTNS( "AdjustPositionAgainLabel" );
	FocalPoint = Focus.Location;
	
	//DMTNS( "MoveToPoint BEGIN  Destination: " $ Destination $ " Distance: " $ VSize( Pawn.Location - Destination ) );
	// allow strafing in this situation (if NPC supports it)
	Pawn.bCanStrafe = Pawn.default.bCanStrafe;
	//!!mdf-tbd: is using a threshold of 2.0 going to hold up under low framerates?
	MoveToPoint( Destination, 2.0, Focus, 2*Pawn.WalkingPct );
	//DMTNS( "MoveToPoint END returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );
	Pawn.bCanStrafe = U2PBase.bCanStrafeScripted;
	
	if( MoveResult != MR_DestinationReached && MoveResult != MR_DestinationReachedFinal )
	{
		// NPC isn't using full speed for this move so allow for a few timeouts
	 	if( NumMoveAttempts++ < 3 )
			Goto( AdjustPositionAgainLabel );
	}

	StopMovement( true, true );	
	NextAdjustPositionTime = 0.0; // re-enable bump handling?
	NextScriptedMoveTime = Level.TimeSeconds + AvoidedBumpWaitTime; // make sure script doesn't move NPC during adjust
	//DMTNS( "made it" );
	
@ AdjustRotationLabel:
	#debug DMAIA( "adjusting rotation" );
	//DMTNS( "adjusting rotation" );
	FocalPoint = Focus.Location;
	FinishRotation( DefaultRotationThreshold );
	Sleep( AvoidedBumpWaitTime );
	Goto( MovePickDestLabel );

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

	#debug DMAIL( BeginLabel );

@ MovePickDestLabel:
	//DMTNS( "MovePickDestLabel" );
	ClearMoveAttempts();
	
@ MovePickDestLoopLabel:
	//DMTNS( "calling WaitForLanding  Focus: " $ Focus );
	WaitForLanding();
	//DMTNS( "called WaitForLanding  Focus: " $ Focus );
	Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
	#debug DMAIL( MovePickDestLabel );

	// figure out where to go
	#debug DMAI( "Calling SetMoveTarget Goal=" $ GetSpecialGoal() );
	//DMTNS( "Calling SetMoveTarget Goal=" $ GetSpecialGoal() $ " Distance=" $ GetSpecialGoalDistance() $ " Focus: " $ Focus );

	// mdf-tbd: if previous move simply timed out could probably just reuse old destination
	GMoveType = SetMoveTarget( GetSpecialGoal(), GetSpecialGoalDistance() );

@ MoveCheckLabel:
	//DMTNS( "MoveCheckLabel GMoveType: " $ EnumStr( enum'EMoveType', GMoveType ) $ " Focus: " $ Focus );
	if( GMoveType == MT_Error )
	{
  		#debug DMAIM( "!SetMoveTarget -- Abort" );
		Goto( ErrorLabel );
	}

	if( GMoveType == MT_None )
	{
  		//#debug DMAIM( "no scripted destination -- going idle" );
  		//DMTNS( "no scripted destination -- going idle" );
		Goto( IdleLabel );
	}

	if( GMoveType == MT_Wait )
	{
  		#debug DMAIM( "SetMoveTarget -- waiting..." );
  		//DMTNS( "SetMoveTarget -- waiting..." );
  		StopMovement( true, true );
		if( Pawn(GetSpecialGoal()) != None )
		{
			// always face Pawn goal?
			//DMTNS( "facing Pawn goal" );
			Focus = GetSpecialGoal();
			FocalPoint = Focus.Location;
			if( NeedToTurn( FocalPoint, NeedToTurnAngleCos ) )
				FinishRotation( ScriptedRotationThreshold );
			SetRotation( Pawn.Rotation );
		}
  		Sleep( 0.5 ); //!! mdf-tbd: track distance to goal actor and break out of sleep if distance becomes > x?
		Goto( MovePickDestLoopLabel );
	}

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

@ MoveActiveLabel:
	//DMTNS( "MoveActiveLabel" );
	//DMTNS( "MoveToActor BEGIN MoveTarget:" $ MoveTarget $ " FinalTarget:" $ GetSpecialGoal() $ " FinalDistance:" $ SpecialGoalDistance $ " Focus:" $ ScriptedFocus );
	//DMTNS( " (GroundSpeed:" $ Pawn.GroundSpeed $ " DesiredSpeed:" $ Pawn.DesiredSpeed $ " MoveSpeed:" $ GetMoveSpeed() $ ")" );
	MoveToActor( MoveTarget, GetTacticalMoveType(), GetSpecialGoal(), GetSpecialGoalDistance(), ScriptedFocus, GetMoveSpeed() );
	//DMTNS( "MoveToActor END returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );

	if( MoveResult != MR_DestinationReachedFinal || U2P.bCauseScriptedNavError )
	{
		if( U2P.bCauseScriptedNavError )
		{
			#debug DMAIM( "testing navigation error recovery -- forcing a bad move result" );
			//DMTNS( "testing navigation error recovery -- forcing a bad move result" );
			StopMovement( true, true );
			NumMoveAttempts = MaxMoveToActorAttempts;
			NumMoveRecoverAttempts = MaxMoveRecoverAttempts;
		}

		// mdf-tbd: if not a timeout -- give up immediately (blocked?)
		// after more than N tries give up
	 	if( NumMoveAttempts++ < MaxMoveToActorAttempts )
		{
			Goto( MovePickDestLoopLabel );
	 	}
		else if( NumMoveRecoverAttempts++ < MaxMoveRecoverAttempts )
	 	{
			#debug DMAIM( "sleep, try moving again in a bit" ) ;
			//DMTNS( "sleep, try moving again in a bit" ) ;
	 		StopMovement( true, true );
			Sleep( 1.0 );
			NumMoveAttempts = 0;
			Goto( MovePickDestLoopLabel );
	 	}
		else
		{
			#debug DMAIM( "Trying to teleport to move target / nearby pathnode" );
			NavigationError( ET_Move, "scripted move to " $ GetSpecialGoal() $ " SpecialGoalDistance: " $ GetSpecialGoalDistance() );
			U2P.MakeErrorObvious( ET_Move );
			if( !U2P.bDisableErrorColors )
			{
				AddActor( Pawn, ColorMagenta() );
				AddActorAt( Pawn, GetSpecialGoal().Location, ColorMagenta() );
				AddArrow( Pawn.Location, GetSpecialGoal().Location, ColorMagenta() );
			}
			
@ MoveTestLabel:

			GMoveType = RecoverFromNavigationError( GetSpecialGoal(), GetSpecialGoalDistance(), true );
			
			if( GMoveType == MT_Success || GMoveType == MT_Near )
			{
				#debug DMAIM("Teleport succeeded");
				if( !U2P.bDisableErrorColors )
					AddCylinder( Pawn.Location, 4, 4, ColorMagenta() );
				U2P.bCauseScriptedNavError = false;
				ClearMoveAttempts();
				Goto( MoveCheckLabel );
			}
			else
			{
				#debug DMAIM("Teleport failed");
				//DMTNS("Teleport failed");
				Sleep( 1.0 );
				if( U2P.bCauseScriptedNavError )
					Goto( MoveTestLabel );
				else
					Goto( MovePickDestLoopLabel );
			}
		}
	}

@ ReachedDestinationLabel:
	#debug DMAIL( ReachedDestinationLabel );
	//DMTNS( ReachedDestinationLabel );

	//2002.11.23 !!mdf-tbd: if a specific distance was given make sure we stop?
	if( SpecialGoalDistance >= 0.0 )
		StopMovement( true, true );
		
	SpecialGoalDistance = default.SpecialGoalDistance;
	if( bDirectionalPatrol && GetSpecialGoal().bDirectional )
	{
		StopMovement( true, true );

		#debug DMAI( "executing bDirectionalPatrol code" );
		//DMTNS( "executing bDirectionalPatrol code Focus: " $ Focus );
		
		//AddArrow( Pawn.Location, Pawn.Location + 1024.0*vector(Pawn.Rotation), ColorPink() );
		PotentialFocalPoint = GetSpecialGoal().Location + 200*vector(GetSpecialGoal().Rotation);
		//AddCylinder( PotentialFocalPoint, 4, 4, ColorPink() );
		//DMTNS( "Calling NeedToTurn  Focus: " $ Focus );
		if( NeedToTurn( PotentialFocalPoint, NeedToTurnAngleCos ) )
		{	
			//DMTNS( "turning  Focus: " $ Focus );
			Focus = None;
			FocalPoint = PotentialFocalPoint;
			FinishRotation( ScriptedRotationThreshold );
		}
		else
		{
			//DMTNS( "not turning  Focus: " $ Focus );
			Focus = None;
			FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
		}
		
		//AddArrow( Pawn.Location, Pawn.Location + 1024.0*vector(Pawn.Rotation), ColorGreen() );
		SetRotation( Pawn.Rotation );
	}
	else if( Pawn(GetSpecialGoal()) != None )
	{
		// always face Pawn goal?
		//DMTNS( "facing Pawn goal" );
		Focus = GetSpecialGoal();
		FocalPoint = Focus.Location;
		if( NeedToTurn( FocalPoint, NeedToTurnAngleCos ) )
			FinishRotation( ScriptedRotationThreshold );
		SetRotation( Pawn.Rotation );
	}
	else
	{
		//DMTNS( "looking straight ahead" );
		if( ScriptedFocus == None )
			Focus = None; // clear NPC looking at goal?
		FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
		SetRotation( Pawn.Rotation );
	}

	Sleep( 0.01 ); // sleep for 1 tick to allow any locked animations to be cleared at this point

	#debug DMAIM( "reached destination -- calling HandleDestinationReached!" );
	//DMTNS( "reached destination -- calling HandleDestinationReached!" );
	HandleDestinationReached();

	//DMTNS( "after HandleDestinationReached" );
	// this line might not be executed if HandleDestinationReached causes script
	// to execute a command which changes the state / state code location
	
@ IdleLabel:
	#debug DMAI( "IdleLabel: " $ bScriptedIdleAnims );
	//DMTNS( "IdleLabel: " $ bScriptedIdleAnims );
	// NPC isn't moving -- play idle animations
@ TurnLabel:
	StopMovement( true, false );	// make sure NPC stops moving
	#debug DMAI( "TurnLabel -- ControllerTarget: " $ ControllerTarget );
	// script has given us a target to rotate towards
	if( ControllerTarget != None )
	{
		//DMTNS( "turn towards target: " $ ControllerTarget );
		if( NeedToTurn( ControllerTarget.Location, NeedToTurnAngleCos ) )
		{	
			#debug DMAI( "Need to turn towards target: " $ ControllerTarget );
	
			// need to rotate towards it
			StopMovement( true, true );
			Focus = None;
			FocalPoint = ControllerTarget.Location;
			Pawn.RotationRate.Yaw = U2PBase.RotationRateYawScripted;
			FinishRotation( ScriptedRotationThreshold );
			Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
		}
		SetRotation( Pawn.Rotation );

		// let script controller know rotation is complete
		#debug DMAI( "Sending FinishedRotation" );
		HandleFinishedRotation();
	}

	if( !bScriptLockedTarget )
	{
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
	}
	Stop;
	
@ AutoEndLabel:
	// let script controller know to make sure EC is enabled so it starts doing its thing (only done once)
	if( MaxScriptedAutoEndDelay > 0.0 && (Level.TimeSeconds - GetRecentAutoEndTime( Pawn )) < MaxScriptedAutoEndDelay )
		Sleep( RandRange( 0.0, MaxScriptedAutoEndDelay ) );
	AutoEnd();
	LastAutoEndTime = Level.TimeSeconds;
	Goto( BeginLabel );
} // ScriptedState

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

state @ ScriptedDialogState extends @ ScriptedState
{
	function PlayRandomSound();

	//-------------------------------------------------------------------------
	
	function eventTakeDamage( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType )
	{
		local float OldHealth;
		if( Pawn? ) OldHealth = Pawn.Health;
		Super.eventTakeDamage( Damage, Instigator, HitLocation, Momentum, DamageType );
		if( Pawn? && Pawn.Health < OldHealth )
			class'DialogEngine'.static.NotifyDialogSpeakerTookDamage( Pawn );
	}

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

	function bool AvoidFriendlyBump( Pawn Other )
	{
		// otherwise most dialogs could get hosed?
		return false;
	}
	
	//-------------------------------------------------------------------------

	function DialogSetFocus( Actor FocusActor )
	{
		//DMTNS( "DialogSetFocus -- Focus Actor Parameter:" @ FocusActor @ "Current Focus:" @ Focus @ "MoveTarget:" @ MoveTarget @ "Old Focus:" @ OldFocus );

		// cache the old focus
		if( OldFocus == None )
		{
			if( MoveTarget != None )
				OldFocus = MoveTarget;
			else
				OldFocus = Focus;
			OldFocalPoint = FocalPoint;
		}

		DialogFocus = FocusActor;

		if( FocusActor == None )
		{
			// look straight ahead
			Focus = None;
			FocalPoint = Pawn.Location + 256*vector(Pawn.Rotation);
		}

		//NEW
		// 2003.01.06 (mdf) fix for Meyer falling off ledges -- previous test was bogus?
		//if( bIsPaused || GetSpecialGoal() == None )
		if( bIsPaused && (GetSpecialGoal() == None || !IsHandlingLatentMove()) )
		{
			// not moving -- can rotate towards focus
			Focus = None; // CDH: without this, it's possible for NeedToTurn to continuously fail, due to physics handling the turning to an old focus (turret people)
			GotoLabel( DialogFocusSetLabel ); // otherwise just keep doing movement while turning to new focus??
		}
		else if( FocusActor != None )
		{
			// moving -- change focus for move without interrupting the latent move
			ScriptedFocus = FocusActor;
			FocalPoint = FocusActor.Location;
		}
		/* OLD
		GotoLabel( DialogFocusSetLabel );
		*/
	}

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

	function DialogSetEndingFocus( Actor FocusActor )
	{
		// stomp on cached focus actor
		OldFocus = FocusActor;
	}

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

	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()
	{
		U2P.bHeadtrackingEnabled = bScriptedHeadTrackingEnabled;   //!!Fix (mw): this is an ugly place for this
		GotoLabel( DialogEndLabel );
	}

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

	function bool PreparedForDialog() 
	{
		if( NeedToTurn( DialogFocus.Location, NeedToTurnAngleCos ) )
		{
			GotoLabel( TurnLabel );
			return false;
		}
		else
		{
			return true;
		}
	}

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

	event BeginState()
	{
		SetAlertness( 0.5 );
		DialogFocus = None;
		DialogPause();
		
		// set even if not friendly to player in case this changes (e.g. via the script)
		Pawn.bCanEncroachPlayer = true;
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		DialogUnPause();
		RestoreAlertness();
		Focus = None; // CDH: benign according to MDF, and should stop occasional stuck-focus problem caused by state yanking
		OldFocus = None;
		OldFocalPoint = vect(0,0,0);
		if( Pawn != None )
		{
			Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
			Pawn.bCanEncroachPlayer = false;
		}
	}

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

@ DialogBeginLabel:
	Stop;

@ DialogEndLabel:
	// Restore Focus
	if( OldFocus != None && ControllerTarget == None )
	{
		Focus = OldFocus;
		FocalPoint = OldFocus.Location;
		if( U2Pawn(OldFocus) != None )
			FocalPoint += vect(0,0,1)* U2Pawn(OldFocus).BaseEyeHeight;

		if( NeedToTurn( Focus.Location, 1.0 ) )
		{
			Pawn.RotationRate.Yaw = U2PBase.RotationRateYawScriptedDialog;
			FinishRotation( ScriptedRotationThreshold );
			Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
		}
	}

	//DMTNS("DialogEndLabel - End: Focus:" @ Focus @ "MoveTarget:" @ MoveTarget );
	#debug   WhatToDoNext( GetContext() );
	#release WhatToDoNext();
	Stop;

@ DialogFocusSetLabel:
	if( DialogFocus != None && NeedToTurn( DialogFocus.Location, NeedToTurnDialogAngleCos ) )
	{
		Focus = DialogFocus;
		FocalPoint = DialogFocus.Location;
		if( U2Pawn(DialogFocus) != None )
			FocalPoint += vect(0,0,1)* U2Pawn(DialogFocus).BaseEyeHeight;
		Pawn.RotationRate.Yaw = U2PBase.RotationRateYawScriptedDialog;
		FinishRotation( ScriptedRotationThreshold );
		Pawn.RotationRate.Yaw = Pawn.default.RotationRate.Yaw;
		Focus = None;
		FocalPoint = Pawn.Location + 256*vector(Pawn.Rotation);
    }
	Sleep( 1.0 );
	Goto( DialogFocusSetLabel );
	
@ DialogFocusRestoreLabel:
	Stop;
} // ScriptedDialogState

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

state @ TestMoveState extends @ MoveToGoalBaseState
{
	ignores EnemyNotVisible;

	//-------------------------------------------------------------------------
	
@ BeginLabel:
	#debug DMAIL( "BeginLabel" );
	ClearMoveAttempts();
	
@ MovePickDestLabel:
	#debug DMAIL( MovePickDestLabel @ TestMoveTarget);
	WaitForLanding();
	
	// figure out where to go
	#debug DMAIM( "Calling SetMoveTarget" );
	if( SetMoveTarget( TestMoveTarget ) <= MT_None )
	{
		#debug DMAIM( "Error calling SetMoveTarget" );
		Goto( ErrorLabel );
	}

@ MoveActiveLabel:
	#debug DMAIL( MoveActiveLabel );

	//DMTNS( "MoveToActor BEGIN MoveTarget:" $ MoveTarget $ " FinalTarget:" $ TestMoveTarget $ " NumMoveAttempts=" $ NumMoveAttempts );
	//DMTNS( " (GroundSpeed:" $ Pawn.GroundSpeed $ " DesiredSpeed:" $ Pawn.DesiredSpeed $ " MoveSpeed:" $ TestMoveSpeed $ ")" );
	MoveToActor( MoveTarget, TestTacticalMoveType, TestMoveTarget, , , TestMoveSpeed );
	//DMTNS( "MoveToActor END 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  //GS-OK
	Stop;
} // TestMoveState

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

state @ UsingState
{
	//-------------------------------------------------------------------------

	function UseActor( Actor A )
	{
		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 @ WanderingState
{
	ignores EnemyNotVisible;

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

	event final SeeAlertFriend( Pawn Seen )
		{ ScriptController.eventSCSeeAlertFriend( Self, Seen ); }

	/* tbd:	
	event final SeeFriend( Pawn Seen )
		{ ScriptController.eventSCSeeFriend( Self, Seen ); }

	event final SeeOther( Actor Seen )
		{ ScriptController.eventSCSeeOther( Self, Seen ); }
	*/

	/* mdf-tbd (stevep: FIXME)
	//-------------------------------------------------------------------------

	singular event BaseChange()
	{
		if( ( Pawn.Base != None ) && Mover(Pawn.Base) != None )
			Destination = Pawn.Location - 300 * Normal( Pawn.Velocity );
		else
			Super.BaseChange();
	}
	*/

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

	event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
	{
		//DMTNS( "NotifyPhysicsVolumeChange: " $ NewVolume.bWaterVolume );

		if( Pawn.default.Physics == PHYS_Swimming && NewVolume.bWaterVolume && Pawn.bCanSwim && !Pawn.bCanFly ) // dive if left water or if entered water?
		{
			//DMTNS( "Setting WanderDirectionExternal" );
			WanderDirectionExternal = Pawn.CollisionRadius*4.0*vect(0,0,-1); // dive
		}
		
		return Global.NotifyPhysicSVolumeChange( NewVolume );
	}

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

	function bool DeferTo( Controller Other )
	{
		if( Pawn.Acceleration == vect(0,0,0) )
			return Global.DeferTo( Other );

		return false;
	}

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

	function float GetExtraWanderDistance()
	{
		return( U2PBase.WanderDistMax - U2PBase.WanderDistMin );
	}

	//-------------------------------------------------------------------------
	// Subclasses can implement walking-specific directions if they want.

	function vector GetWanderDirectionWalking( int FallbackType )
	{
		local vector ReturnedDirection;

		/*
		// show all possible fallback vectors:
    	ReturnedDirection = vector(Pawn.Rotation);
		ReturnedDirection.Z = 0.0;
		AddArrow( Pawn.Location, Pawn.Location + 256.0*vector(Pawn.Rotation), ColorMagenta() ); 
		AddArrow( Pawn.Location, Pawn.Location + 256.0*RotateAngleAxis( vector(Pawn.Rotation), vect(0,0,1),  0.5*U2PBase.WanderSpreadAngle*DegreesToRotationUnits ), ColorMagenta() ); 
		AddArrow( Pawn.Location, Pawn.Location + 256.0*RotateAngleAxis( vector(Pawn.Rotation), vect(0,0,1), -0.5*U2PBase.WanderSpreadAngle*DegreesToRotationUnits ), ColorMagenta() ); 
		AddArrow( Pawn.Location, Pawn.Location + 256.0*RotateAngleAxis( vector(Pawn.Rotation), vect(0,0,1),  U2PBase.WanderSpreadAngle*DegreesToRotationUnits ), ColorMagenta() ); 
		AddArrow( Pawn.Location, Pawn.Location + 256.0*RotateAngleAxis( vector(Pawn.Rotation), vect(0,0,1), -U2PBase.WanderSpreadAngle*DegreesToRotationUnits ), ColorMagenta() ); 
		*/
		
		if( WanderDirection == vect(0,0,0) )
	    	ReturnedDirection = vector(Pawn.Rotation);
		else if( FallbackType == 0 )
	    	ReturnedDirection = vector(rotator(WanderDirection) + rotator(RandomSpreadVector( U2PBase.WanderSpreadAngle )) );
		else
	    	ReturnedDirection = vector(Pawn.Rotation); // fallback directions wrt current rotation

		// eliminate Z component (if any)	    	
		ReturnedDirection.Z = 0.0;

		if( FallbackType == 2 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1), 0.5*U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
		else if( FallbackType == 3 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1), -0.5*U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
		else if( FallbackType == 4 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1), U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
		else if( FallbackType == 5 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1), -U2PBase.WanderSpreadAngle*DegreesToRotationUnits );

		return Normal( ReturnedDirection );
	}

	//-------------------------------------------------------------------------
	// Subclasses can implement swimming-specific directions if they want.

	function vector GetWanderDirectionSwimming( int FallbackType )
	{
		local vector ReturnedDirection;

		if( WanderDirection == vect(0,0,0) )
	    	ReturnedDirection = vector(Pawn.Rotation);
		else if( FallbackType == 0 )
			ReturnedDirection = vector(rotator(WanderDirection) + rotator(RandomSpreadVector( U2PBase.WanderSpreadAngle )) );
		else
	    	ReturnedDirection = vector(Pawn.Rotation); // fallback directions wrt current rotation

		if( Pawn.default.Physics != PHYS_Swimming && Pawn.default.Physics != PHYS_Flying )
			ReturnedDirection.Z = 0;
			
		// NOTE: this could be improved (try vectors above and below as well as left/right)
		if( FallbackType == 2 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1),  0.5*U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
		else if( FallbackType == 3 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1), -0.5*U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
		else if( FallbackType == 4 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1),  U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
		else if( FallbackType == 5 )
			ReturnedDirection = RotateAngleAxis( ReturnedDirection, vect(0,0,1), -U2PBase.WanderSpreadAngle*DegreesToRotationUnits );
			
		ReturnedDirection = ClampVerticalComponent( Normal( ReturnedDirection ) );

		// pathological case?		
		if( ReturnedDirection == vect(0,0,0) )
	    	ReturnedDirection = vector(Pawn.Rotation);
		
		return Normal( ReturnedDirection );
	}

	//-------------------------------------------------------------------------
	// Subclasses can implement flying-specific directions if they want.
	// mdf-tbi: support circling birds etc.

	function vector GetWanderDirectionFlying( int FallbackType )
	{
		return GetWanderDirectionSwimming( FallbackType );
	}

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

	function vector GetWanderDirection( int FallbackType )
	{
		if( Pawn.Physics == PHYS_Walking )
			return GetWanderDirectionWalking( FallbackType );
		else if( Pawn.Physics == PHYS_Swimming )
			return GetWanderDirectionSwimming( FallbackType );
		else if( Pawn.Physics == PHYS_Flying )
			return GetWanderDirectionFlying( FallbackType );
		else
			return vect( 0,0,0 );
	}

	//-------------------------------------------------------------------------
	// Tend to wander shorter distances before selecting a new direction when 
	// hurt and/or alert?

	function float GetWanderDistanceModifier()
	{
		local float ReturnedMultiplier;

		ReturnedMultiplier = 1.0;

		if( U2PBase.bDistressedWandering )
		{
			if( LPawn.GetAlert() )
				ReturnedMultiplier *= 0.5;
			if( LPawn.GetHurt() )
				ReturnedMultiplier *= 0.5;
		}

		return ReturnedMultiplier;
	}

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

	function float GetModifiedMoveSpeed()
	{
		if( U2PBase.bDistressedWandering )
		{
			if( LPawn.GetHurt() )
				return RandRange( U2PBase.WanderSpeedMin, 1.5*U2PBase.WanderSpeedMax );		// move very erratically
			if( LPawn.GetAlert() )
				return RandRange( 0.5*U2PBase.WanderSpeedMax, 1.5*U2PBase.WanderSpeedMax ); // move quickly, changing speeds suddenly
		}
		
		return -1.0; // not hurt/alert
	}

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

	function float GetWalkingMoveSpeed()
	{
		return Pawn.WalkingPct; 
	}

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

	function float GetSwimmingMoveSpeed()
	{
		local float ReturnedSpeed;

		// smoothly increase/decrease speed between min and max
		ReturnedSpeed = WanderMoveSpeed;
		if( ReturnedSpeed > U2PBase.WanderSpeedMax - 0.10 )
			ReturnedSpeed -= FRand()*0.10;
		else if( ReturnedSpeed > U2PBase.WanderSpeedMin + 0.10 )
			ReturnedSpeed += FRand()*0.20 - 0.10;
		else
			ReturnedSpeed += FRand()*0.10;

		ReturnedSpeed = FClamp( ReturnedSpeed, U2PBase.WanderSpeedMin, U2PBase.WanderSpeedMax );

		return ReturnedSpeed;
	}

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

	function float GetFlyingMoveSpeed()
	{
		return GetSwimmingMoveSpeed();
	}

	//-------------------------------------------------------------------------
	// Simply returns the speed to use with the call to MoveToPoint when wandering,
	// e.g. a non-hurt/non-alert critter might wander around using his 
	// WalkingPct of 0.15 or so (the number scales the Ground/Air/WaterSpeed
	// in the engine implementation of MoveToPoint.

	function SetWanderMoveSpeed()
	{
		local float NewSpeed;

		NewSpeed = GetModifiedMoveSpeed();
		if( NewSpeed < 0.0 )
		{
			// not hurt/alert
			if( Pawn.Physics == PHYS_Walking )
				NewSpeed = GetWalkingMoveSpeed();
			else if( Pawn.Physics == PHYS_Swimming )
				NewSpeed = GetSwimmingMoveSpeed();
			else if( Pawn.Physics == PHYS_Flying )
				NewSpeed = GetFlyingMoveSpeed();
			else // probably shouldn't happen but is currently in water volumes...
				NewSpeed = FClamp( WanderMoveSpeed, U2PBase.WanderSpeedMin, U2PBase.WanderSpeedMax );
		}

		//DM( "GetWanderMoveSpeed: " $ NewSpeed );
		WanderMoveSpeed = NewSpeed;
	}

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

	function bool ShouldWanderPause()
	{
		return ( U2PBase.WanderPauseMax > 0.0 && FDecision( U2PBase.WanderPauseOdds ) );
	}

	//-------------------------------------------------------------------------
	// various hooks...

	function WanderDidMoveSpecialHandling();
	function WanderPauseSpecialHandling();
	function bool WanderPauseSpecialAnimation() { return false; }

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

	function vector ClampVerticalComponent( vector V )	
	{ 
		if( U2PBase.WanderMaxZComponent < 1.0 )
		{
			if( Abs(V.Z) > U2PBase.WanderMaxZComponent )
			{
				if( V.Z > 0 )
					V.Z =  U2PBase.WanderMaxZComponent;
				else
					V.Z = -U2PBase.WanderMaxZComponent;

				V = Normal( V );
			}
		}

		return V;
	}

	//-------------------------------------------------------------------------
	// Checks whether NPC can actually move in the given direction. Returns the
	// result vector in DestinationLocation and returns true/false to indicate
	// whether a result vector was obtained.

	function bool GetDestinationVector( vector Direction, float DesiredDistance, bool bRecovering, out vector DestinationLocation )
	{
		local Actor HitActor;
		local vector TraceExtents;
		local float SelectedDistance, DestinationDistance;
		local Color DrawColor;
		local float MaxJumpDownDistanceOld;
		local bool bResult;
		local CheckResult Hit;
		
		//AddCylinder( Pawn.Location, 8, 8, ColorPink() );
		//DMTNS( "GetDestinationVector" );
		
		#debug DMAIM( "  trying to move " $ DesiredDistance $ " units along " $ class'Util'.static.GetVectorString( Direction ) );
		//DMTNS( "  trying to move " $ DesiredDistance $ " units along " $ class'Util'.static.GetVectorString( Direction ) );

		if( VSize(Direction) ~= 0.0 )
		{
			DestinationLocation = Pawn.Location;
			return true;
		}
		
		#debug DMAssert( VSize(Direction) ~= 1.0, "Direction not normalized?  Direction: " $ Direction $ " Size: " $ VSize(Direction) $ " Physics: " $ Pawn.Physics );

		SelectedDistance = DesiredDistance;
		#debug DMAIM( "Initial SelectedDistance: " $ SelectedDistance );

		//---------------------------------------------------------------------
		// If any Pawns are in the way reduce the DesiredDistance 
		// (PointReachable won't detect actors in the way).
		//---------------------------------------------------------------------

		// slower check to avoid stepping over / hitting other pawns (could pbly make this stuff native if necessary)
		TraceExtents.X = Pawn.CollisionRadius;
		TraceExtents.Y = Pawn.CollisionRadius;
		TraceExtents.Z = 0.0;

		// anything blocking this move at ground level (allow for WanderMaxAvoidDistance)?
		DestinationDistance = (SelectedDistance + U2PBase.WanderMaxAvoidDistance);
		DestinationLocation = Pawn.Location + DestinationDistance*Direction;
		class'UtilGame'.static.AdjustDestinationForPhysics( Pawn, DestinationLocation );
		
		if( !Pawn.SingleLineCheck( Hit, Pawn, DestinationLocation, Pawn.Location, TRACE_AllBlocking, TraceExtents ) )
		{
			HitActor = Hit.Actor;
			
			if( Pawn(HitActor) != None )
			{
				// hit a pawn -- back off to respect NPC's "comfort zone"
				//SelectedDistance = VSize2D( Pawn.Location - HitActor.Location ) - Pawn.CollisionRadius - HitActor.CollisionRadius - 1.0;
				//SelectedDistance = VSize2D( Pawn.Location - HitActor.Location ) - HitActor.CollisionRadius - 1.0;
				SelectedDistance = class'Util'.static.GetDistanceBetweenActors( Pawn, HitActor ) - 1.0;
				if( ClassIsChildOf( HitActor.Class, Pawn.Class ) )
				{
					//DMTNS( "using same class pawn avoid distance" );
					SelectedDistance -= U2PBase.WanderAvoidPawnSameDistance;
				}
				else
				{
					//DMTNS( "using diff class pawn avoid distance" );
					SelectedDistance -= U2PBase.WanderAvoidPawnDiffDistance;
				}
			}			
			else
			{
				// hit geometry -- do nothing for now since this doesn't mean we can't 
				// reach that location -- the only way to be sure is with a call to
				// PointReachable which is done below.
				// !!mdf-tbd: if really blocked (can't reach) try again with a shorted
				// distance so that NPC walks up to blocking geometry (within some
				// MinAvoidGeometry distance).
				// SelectedDistance = Hit.Time * VSize( Pawn.Location - DestinationLocation );
			}
			
			#debug DMAIM( "==> Extent trace Hit " $ HitActor $ "  SelectedDistance reduced to: " $ SelectedDistance $ " Hit.Time: " $ Hit.Time );
			//DMTNS( "==> Extent trace Hit " $ HitActor $ "  SelectedDistance reduced to: " $ SelectedDistance $ " Hit.Time: " $ Hit.Time );
		}
		
		//---------------------------------------------------------------------
		// Now do the reachability check using the possibly adjusted 
		// DesiredDistance.
		// NOTE: even if we hit geometry above, the NPC may be able to step
		// over it (in PHYS_Walking/Swimming/Flying) and PointReachable should
		// take this into account (as well as the simulated physics can handle
		// this...).
		//---------------------------------------------------------------------
		
		if( SelectedDistance >= U2PBase.WanderMinAdustedSize )
		{
			DestinationLocation = Pawn.Location + SelectedDistance*Direction;
			class'UtilGame'.static.AdjustDestinationForPhysics( Pawn, DestinationLocation );
	
			MaxJumpDownDistanceOld = Pawn.MaxJumpDownDistance;
			if( Pawn.Physics == PHYS_Walking )
			{
				// limit height that wandering NPCs can jump down
			
				Pawn.MaxJumpDownDistance = Pawn.MaxStepHeight + Pawn.CollisionHeight*2.0;
				//Pawn.MaxJumpDownDistance = Pawn.MaxStepHeight; // otherwise we risk not being able to get back from where we jumped down to?
			}
			
			// should do FitActorAt first since this can change the destination location?
			if( Pawn.FitActorAt( DestinationLocation ) != 0 )
			{
				//DMTNS( "pawn fits at destination" );
				
				if( PointReachable( DestinationLocation ) )
				{
					//DMTNS( "destination is reachable" );
					bResult = true;
				}
				else
				{
					//DMTNS( "destination is not reachable" );
					//AddArrow( Pawn.Location, DestinationLocation, ColorRed() ); 
					//AddActor( Pawn, ColorCyan() );
					//AddActorAt( Pawn, DestinationLocation, ColorRed() );
				}
			}
			else
			{
				//DMTNS( "pawn does not fit at destination" );
			}

			Pawn.MaxJumpDownDistance = MaxJumpDownDistanceOld;
		}
/*		
#debugbegin
		if( bResult )
		{
			#debug DMAIM( "    SUCCESS: " $ DestinationLocation );
			if( bRecovering )
				DrawColor = ColorBlue();
			else
				DrawColor = ColorGreen();
			
			AddArrow( Pawn.Location, DestinationLocation, DrawColor ); 
			//AddActorAt( Pawn, DestinationLocation, DrawColor );
		}
		else
		{
			#debug DMAIM( "    FAILED: obstructed by " $ HitActor );
			if( bRecovering )
				DrawColor = ColorMagenta();
			else
				DrawColor = ColorRed();
			AddArrow( Pawn.Location, DestinationLocation, DrawColor ); 
			
			if( bVisibleAI )
				AddActorAt( Pawn, DestinationLocation, DrawColor );
		}
#debugend
		//AddCylinder( Pawn.Location, 4, 4, ColorOrange() );
*/		
		return bResult;
	}

	//-------------------------------------------------------------------------
	// Note that WanderDirectionExternal is global. In most cases it is only 
	// set/used in the wandering state PickDestination code but it can be set 
	// externally in order to have one NPC move out of the way of another.
	//
	// mdf-tbd: swimming/flying creatures should tend to maintain the same
	// rotation compared to walking creatures? Make this tweakable and also add
	// a "home" location + MaxWanderDistance to possibly encourage NPCs to stay
	// in that area. Should PawnFactories have optional property name + value
	// pairs for stuff like this so that Pawns can be spawned with any properties
	// set as desired by flipping these in the Pawn/Controller?
	//
	// mdf-tbd: code for determining the distance moved is a bit icky currently
	// but this is a combination of the minimum distance plus some additional
	// distance which can vary from 0.0 up to GetExtraWanderDistance depending
	// on the value of WanderDistanceModifier (which is normally 1.0 but is
	// less if the NPC is hurt and/or alert so as to cause the NPC to reevaluate
	// his direction more frequently).

	function bool PickDestination()
	{
		local int ii;
		local bool bResult;
		local vector SelectedDirection;
		local float DesiredDistance;

		//DMTNS( "PickDestination!" );

		// sanity check -- should never happen with current NPCs
    	if( WanderDirectionExternal != vect(0,0,0) )
		{
			//#debug DMAIM( "Wandering -- using WanderDirectionExternal" );
			//DMTNS( "Wandering -- using WanderDirectionExternal" );
			SelectedDirection = Normal( WanderDirectionExternal );

			// don't zero out Z if not walking
			if( Pawn.Physics == PHYS_Walking )
				SelectedDirection.Z = 0;
			Destination = Pawn.Location + SelectedDirection; // mdf-tbd: code that sets WanderDirectionExternal should use appropriate distance?
			WanderDirectionExternal = vect(0,0,0);
			bResult = true; // assume direction is ok?
		}
		else
		{
			DesiredDistance = U2PBase.WanderDistMin + GetWanderDistanceModifier() * GetExtraWanderDistance() * FRand();
			SelectedDirection = GetWanderDirection( 0 );

			#debug DMAIM( "BEGIN calling GetDestinationVector" );
			//DMTNS( "BEGIN calling GetDestinationVector" );
			bResult = GetDestinationVector( SelectedDirection, DesiredDistance, false, Destination );
			#debug DMAIM( "END calling GetDestinationVector" );
			//DMTNS( "END calling GetDestinationVector" );

			for( ii=1; !bResult && ii<=MaxWanderFallbackTypes; ii++ )
			{
				// try to resolve the problem within the desired spread angle
				// !!mdf-tbd: spread this out over several ticks?
				SelectedDirection = GetWanderDirection( ii );
				#debug DMAIM( "BEGIN calling GetDestinationVector" );
				bResult = GetDestinationVector( SelectedDirection, DesiredDistance, true, Destination );
				#debug DMAIM( "END calling GetDestinationVector" );
			}
			
			if( !bResult && FDecision( U2PBase.WanderAvoidObstructionOdds ) )
			{
				// try alternate directions in order to resolve the problem
				// !!mdf-tbd: spread this out over several ticks?
				
				// dumber NPCs will probably just sleep for a while then try again, maybe
				// butting up against the wall for a while, smarter NPCs should turn away
				
				// go with min distance when trying to deal with an obstruction
				DesiredDistance = U2PBase.WanderDistMin;

				// try left/right instead of forward		
				SelectedDirection = Normal( vector(Pawn.Rotation) cross vect(0,0,1) );
				if( FRand() < 0.5 )
					SelectedDirection *= -1;

				// !!mdf-tbd: try N/NW/NE/W/E/SW/SE/S (8 directions instead of 4)?
				if( GetDestinationVector( SelectedDirection, DesiredDistance, true, Destination ) ) // try right/left
				{
					bResult = true;
				}
				else if( GetDestinationVector( -SelectedDirection, DesiredDistance, true, Destination ) ) // try left/right
				{
					bResult = true;
				}
				else if( Pawn.Physics != PHYS_Walking )
				{
					// for flying/swimming creatures also try up/down
	    			SelectedDirection = Normal( vector(Pawn.Rotation) cross SelectedDirection );
					if( FRand() < 0.5 )
						SelectedDirection *= -1;

					if( GetDestinationVector( SelectedDirection, DesiredDistance, true, Destination ) ) // try up/down
					{
						bResult = true;
					}
					else if( GetDestinationVector( -SelectedDirection, DesiredDistance, true, Destination ) ) // try down/up
					{
						bResult = true;
					}
				}
				if( !bResult && GetDestinationVector( -vector(Pawn.Rotation), DesiredDistance, true, Destination ) ) // try back
				{
					bResult = true;
				}
				if( !bResult && GetDestinationVector(  RotateAngleAxis( -vector(Pawn.Rotation), vect(0,0,1), 45*DegreesToRotationUnits ), DesiredDistance, true, Destination ) ) // back-right
				{
					bResult = true;
				}
				if( !bResult && GetDestinationVector(  RotateAngleAxis( -vector(Pawn.Rotation), vect(0,0,1), -45*DegreesToRotationUnits ), DesiredDistance, true, Destination ) ) // back-left
				{
					bResult = true;
				}
				if( !bResult && GetDestinationVector(  RotateAngleAxis( vector(Pawn.Rotation), vect(0,0,1), 45*DegreesToRotationUnits ), DesiredDistance, true, Destination ) ) // forward-right
				{
					bResult = true;
				}
				if( !bResult && GetDestinationVector(  RotateAngleAxis( vector(Pawn.Rotation), vect(0,0,1), -45*DegreesToRotationUnits ), DesiredDistance, true, Destination ) ) // forward-left
				{
					bResult = true;
				}
			}
	
			if( !bResult )
			{
				// if blocked by and walking stop moving so won't step onto Pawn
				StopMovement( true, Pawn.Physics == PHYS_Walking ); 
				Destination = Pawn.Location;
			}
		}

		WanderDirection = Normal( Destination - Pawn.Location );

	    // mdf-tbr:
		#debugbegin
		if( bVisibleAI )
			AddArrow( Pawn.Location, Destination, ColorYellow() );
		#debugend
		return bResult;
	}

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

	function bool CanKillIfStuck() 
	{ 
		// 2002.12.09 (mdf) let most NPCs destroy themselves if stuck wandering
		// and fix fish in tanks in M01D so they don't do this by setting
		// bWanderCanKillIfStuck=false.
		return U2PBase.bWanderCanKillIfStuck;
		/*OLD
		if( U2PBase.Physics == PHYS_Swimming || U2PBase.Physics == PHYS_Flying )
			return false;
		
		return U2PBase.bWanderCanKillIfStuck;
		*/
	}
	
	//-------------------------------------------------------------------------

	function bool CanTeleportIfStuck() 
	{ 
		// 2002.12.09 (mdf) let most NPCs teleport themselves if stuck wandering
		// and fix fish in tanks in M01D so they don't do this by setting
		// bWanderCanTeleportIfStuck=false.
		return U2PBase.bWanderCanTeleportIfStuck;
		
		/*OLD
		if( U2PBase.Physics == PHYS_Swimming || U2PBase.Physics == PHYS_Flying )
			return false;
			
		return U2PBase.bWanderCanTeleportIfStuck; 
		*/
	}
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		//DM( "Wandering -- begin state" );
		//!!mdf: if we are entering this state to deal with an enemy (e.g. spores) 
		// we don't want to clear enemy -- assume that caller won't use this state
		// with a valid enemy unless this is intentional (states that deal with 
		// enemies should handle cleaning up that enemy).
		// SetControllerEnemy( None, GetContext() );
		SetAlertness( 0.2 );
		MinHitWall += 0.15;
		if( Pawn != None )
		{
			Pawn.bCanTeleport = false;
			Pawn.bCanWalkOffLedges = U2PBase.bCanWanderOffLedges;
			Pawn.RotationRate = Pawn.default.RotationRate;
		}

		WanderDirection = vect(0,0,0);
		SetEvents();

		if( !U2PBase.bLookForAlertFriends )
			Disable( Event_SeeAlertFriend );
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		//DM( "Wandering -- end state" );
		RestoreAlertness();
		MinHitWall -= 0.15;
		if( Pawn != None )
		{
			Pawn.bCanTeleport = Pawn.default.bCanTeleport;
			Pawn.bCanWalkOffLedges = Pawn.default.bCanWalkOffLedges;
			if( U2PBase.bWanderEndRotation )
				Pawn.RotationRate = U2PBase.WanderEndRotationRate;
		}
	}

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

@ BeginLabel:
	//Sleep( 9999 );
@ MovePickDestLabel:
	WaitForLanding( 2.0 );	// NOTE: check every time through because NPCs could be falling after MoveToPoint
	if( Pawn.Physics == PHYS_Falling )   // seeing NPCs get stuck permanently falling against static meshes...
	{
		//DMTNS( "Gave up falling bWaterVolume: " $ Pawn.PhysicsVolume.bWaterVolume );
		if( Pawn.PhysicsVolume.bWaterVolume )
			Pawn.SetPhysics( PHYS_Swimming );
		else
			Pawn.SetPhysics( PHYS_Walking );
	}
	
	// ==> SELECT NEXT DESTINATION
	//#debug DMAIM( "Wandering -- selecting destination" );
	if( !PickDestination() )
	{
		// ==> FAILED (DUE TO OBSTRUCTION) -- wait and try again
		//#debug DMAIM( "cant move -- sleeping for " $ U2PBase.WanderCantMoveWaitTime $ " seconds" );
		//DMTNS( Pawn $ ": PickDestination failed  NumMoveAttempts: " $ NumMoveAttempts );
		StopMovement( true, true );
	
		// who cares if the player is looking -- the NPC is stuck and looks lame anyway...
	 	//if( TryToFixWandering() && NumMoveAttempts++ > MaxWanderAttempts && !Pawn.PlayerCanSeeMe() )
	 	bWanderFixed = false;
	 	NumMoveAttempts++;
	 	if( NumMoveAttempts > MaxWanderAttempts )
	 	{
			if( !U2P.bDisableErrorMessages )
				DMTNS( "  " $ Pawn $ " can't move at " $ Pawn.Location );
			 		
			if( !U2P.bDisableErrorColors )
			{
	 			AddActor( Pawn, ColorWhite() );
	 			AddArrow( vect(0,0,0), Pawn.Location, ColorWhite() );
	 			if( !CanTeleportIfStuck() && !CanKillIfStuck() )
		 			U2P.bDisableErrorColors = true; // only track the first problem (or slows down build horribly)
	 		}
	 		
	 		NumMoveRecoverAttempts++;
	 		if( NumMoveRecoverAttempts <= MaxMoveRecoverAttempts && CanTeleportIfStuck() )
	 		{
	 			if( !Pawn.PlayerCanSeeMe() )
	 			{
					// try to teleport to a nearby pathnode
					bWanderFixed = RecoverFromStuckError();
					if( bWanderFixed && !U2P.bDisableErrorColors )
					{
						AddCylinder( Pawn.Location, 4, 4, ColorWhite() );
			 			U2P.bDisableErrorColors = true; // only track the first problem (or slows down build horribly)
					}
				}
	 		}
			else if( CanKillIfStuck() )	 		
	 		{
				if( !U2P.bDisableErrorMessages )
					DMTNS( "  " $ Pawn $ " killing self" );
					
				//!!mdf-tbd: kill 'em off -- too much overhead					
				Pawn.Died( None, class'Suicided', Pawn.Location, vect(0,0,0) );
				bWanderFixed = true;
			}
		}
		
		if( !bWanderFixed )
		{
			//DMTNS( "  sleeping for " $ U2PBase.WanderCantMoveWaitTime $ " seconds" );
			Sleep( U2PBase.WanderCantMoveWaitTime );
		}
	}
	else
	{
		// ==> SUCCESS -- MAYBE ROTATE
		ClearMoveAttempts();
		
		if( FDecision( U2PBase.WanderTurnToDestinationOdds ) )
		{
			//#debug DMAIM( "turning to destination" );

			// NOTE (mdf): For most NPCs we will want to do this otherwise the
			// NPC will be rotating towards his destination as he moves toward
			// it. This might be ok for "hovering" creatures (small, mobile
			// fish or birds) but for most larger and/or walking NPCs, this
			// would probably look bad/wrong, especially if the NPC doesn't 
			// have anything but forward moving animations.
			Focus = None;
			FocalPoint = Destination;
			FinishRotation( DefaultRotationThreshold );
	
			// after call to FinishRotation, NPC can end up changing height slightly but
			// when walking the destination should always be at the same height as the pawn
			// (once I fix APawn::ReachedDestination to have more height diff tolerance for
			// non-actor destinations, this shouldn't make much difference.
			if( Pawn.Physics == PHYS_Walking )
				Destination.Z = Pawn.Location.Z;
		}
	
		// ==> MOVE TOWARD DESTINATION (!!mdf-tbd: doesn't currently necessarily reach destination -- do we care?)
		SetWanderMoveSpeed();
		//#debug DMAIM( "MoveToPoint BEGIN -- moving with speed: " $ WanderMoveSpeed );
		//#debug DMAIM( "Location.Z = " $ Pawn.Location.Z $ " Destination.Z = " $ Destination.Z );

		if( Pawn.Physics != PHYS_Walking )
		{
			// needed for fish & birds or they can fly way past their destination as the new acceleration is "blended" in
			StopMovement( true, false );
			Pawn.Velocity = VSize(Pawn.Velocity) * WanderDirection; 
		}

@ MoveActiveLabel:
		if( U2PBase.bWanderLookAtDestination )
			MoveToPoint( Destination, , , WanderMoveSpeed ); // will look at destination
		else
			MoveToPoint( Destination, , Pawn, WanderMoveSpeed );

		#debug DMAIM( "MoveToPoint END -- " $ MoveTarget $ " returned MoveResult: " $ EnumStr( enum'EMoveResult', MoveResult ) );
	
		// make sure we don't rotate 180 degrees to look at destination if we overshot it a bit
		if( MoveResult == MR_DestinationReached )
		{
			Focus = None;
			FocalPoint = Pawn.Location + 512*vector(Pawn.Rotation);
			//AddActor( Pawn, ColorCyan() );
		}
		else
		{
		 	if( NumMoveAttempts++ < MaxMoveToPointAttempts )
				Goto( MoveActiveLabel ); // failure is ok -- will just try another dest
		}
			
		// ==> MAYBE ROTATE AWAY FROM VIEW OBSTRUCTION
		if( FDecision( U2PBase.WanderViewBlockedTurnOdds ) && ViewObstructed( U2PBase.WanderViewBlockedDistance ) )
		{
			//#debug DMAIM( "Wandering -- rotating away from wall" );
			FinishRotation( DefaultRotationThreshold );
		}

		// ==> MAYBE PAUSE AFTER MOVE
		// optionally pause for a bit at each wander destination
		if( ShouldWanderPause() )
		{
			//#debug DMAIM( "pausing for " $ U2PBase.WanderPauseMin $ ".." $ U2PBase.WanderPauseMax $ " seconds" );
			StopMovement( true, false );
			WanderPauseSpecialHandling(); // hook so subclasses can play special pause animations (override animation controller)
			Sleep( RandRange( U2PBase.WanderPauseMin, U2PBase.WanderPauseMax ) );
			if( WanderPauseSpecialAnimation() ) // make sure special pause anim finishes
				FinishAnim();
		}
	}

	WanderDidMoveSpecialHandling(); // hook to maybe break away from wandering after last wander move/pause (e.g. bots go roaming here)
	Goto( MovePickDestLabel );
} // WanderingState

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

state @ WanderingPanicState extends @ WanderingState
{
	ignores BeginFalling, SeeEnemy, SeeFriend, SeeAlertFriend, SeeOther, NotifyBump, HearNoise, EnemyNotVisible; 
	ignores NotifyLanded, EnemyInLeapRange, EnemyInMeleeRange, NotifyHitWall;
	
	//-------------------------------------------------------------------------

	event Tick( float DeltaTime )
	{
		Super.Tick( DeltaTime );
		if( Level.TimeSeconds >= U2PBase.StopPanicTime )
			EndPanic();
	}
	
	//-------------------------------------------------------------------------

	function bool AllowHitSounds() { return false; }
	
	//!!mdf-tbd: would be cool to allow shooting while panicked if shot went out 
	// of weapon bone but as-is shots simply don't match up with the animation 
	// enough to allow them for now.
	function bool CanFire( bool bTest ) { return false; }
	function bool CanDodge( optional bool bIgnoreFalling ) { return false; }
	function HandlePanic();

	function bool CanKillIfStuck() { return false; }
	function bool CanTeleportIfStuck() { return false; }
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		if( Pawn != None )
		{
			Pawn.MeshAgentSetInputCurValue('Mood', 'Panic');
			Pawn.MeshAgentSetInputLock('Mood', true);
			Pawn.MeshAgentSetInputCurValue('Speed', 'Run');
			Pawn.MeshAgentSetInputLock('Speed', true);
		}
				
		//set panicked properties
		SetAlert( true );
		SaveWanderingParameters();
		SetWanderingPanicParameters();
		DoPanicSounds();
		
		Super.BeginState();
		
		Pawn.RotationRate = 2*Pawn.default.RotationRate;
	}
	
	//-------------------------------------------------------------------------

	event EndState()
	{
		Super.EndState();

		if( Pawn != None )
		{
			Pawn.MeshAgentSetInputLock('Mood', false);
			Pawn.MeshAgentSetInputCurValue('Mood', 'Normal');
			Pawn.MeshAgentSetInputLock('Speed', false);
			if( Pawn.Health > 0 )
				EndPanicSound(); // shhhhh, you're dead already
		}
				
		// undo panicked properties
		SetAlert( false );
		RestoreWanderingParameters();
		RemoveTimer( 'StartPanicSound' );
		DodgeEnableTime = Level.TimeSeconds + 0.50;
	}
} // WanderingPanicState

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

defaultproperties
{
	MaxWanderAttempts=8
	MaxWanderFallbackTypes=5
	TestTacticalMoveType=TMT_Serpentine
	DefaultState='Wandering'
	DefaultScriptControllerClass=Class'U2AI.ScriptControllerInterf'
	ScriptedScriptControllerClass=Class'U2AI.ScriptControllerBase'
	CrouchingMoveSpeedMultiplier=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"
}