U2AI.U2NPCControllerShared

//=============================================================================
// U2NPCControllerShared.uc
// Created By: Steve Polge, Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 1/29/03 4:24p $
// $Revision: 150 $
//=============================================================================

class U2NPCControllerShared extends U2NPCControllerScriptable
	config(User)
	abstract;

// state name consts -- see U2AI.doc
const AcquisitionState					= 'Acquisition';				// just acquired an enemy
const AttackCloseState					= 'AttackClose';				// closing in on enemy
const AttackCloseChargeState			= 'AttackCloseCharge';			// charge at enemy and possibly overshoot if enemy moves out of the way
const AttackFallbackState				= 'AttackFallback';				// going to an item while engaged, and remaining engaged
const AttackHideState					= 'AttackHide';					// remain waiting in safe spot (maybe use attackstakeout?)
const AttackHuntState					= 'AttackHunt';					// hunting for an enemy
const AttackLeapState					= 'AttackLeap';					// leap towards enemy (push state)
const AttackMeleeState					= 'AttackMelee';				// attempting to perform melee attack against enemy
const AttackMoveToCoverBaseState		= 'AttackMoveToCoverBase';		// base state for AttackMoveToCoverCombat/Flee
const AttackMoveToCoverCombatState		= 'AttackMoveToCoverCombat';	// try to find/move to a cover spot while remaining engaged with enemy
const AttackMoveToCoverFleeState		= 'AttackMoveToCoverFlee';		// try to find/move to a cover spot while fearing enemy
const AttackRecoverEnemyState			= 'AttackRecoverEnemy';			// recover enemy after losing LOS to enemy (might not necessarily ever reach cover spot)
const AttackStakeOutState				= 'AttackStakeOut';				// waiting for enemy to reappear
const AttackStakeOutCoverState			= 'AttackStakeOutCover';		// waiting for enemy to reappear at cover spot
const AttackStationaryState				= 'AttackStationary';			// stationary and attacking from a distance using projectiles
const AttackRetreatState				= 'AttackRetreat';				// go toward item while engaged with an enemy and fearing that enemy
const AttackTacticalMoveState			= 'AttackTacticalMove';			// performing a tactical move while handling an enemy
const AttackTacticalMoveMeleeState		= 'AttackTacticalMoveMelee';	// performing a tactical move while handling an enemy within melee metastate
const AttackTacticalRetreatState		= 'AttackTacticalRetreat';		// back away from enemy
const AttackTacticalRetreatMeleeState	= 'AttackTacticalRetreatMelee';	// back away from enemy within melee metastate
const AttackTauntState					= 'AttackTaunt';				// taunt enemy
const CoweringState						= 'Cowering';					// immobile and playing a cower animation
const DeadlockedState					= 'DeadLocked';					// used to wait a few ticks when behavior is deadlocked
const DodgingState						= 'Dodging';					// performing a dodging maneuver
const DodgingWithAttackState			= 'DodgingWithAttack';			// performing a dodging maneuver into an attack
const EnemyKilledState					= 'EnemyKilled';				// for performing any special "enemy killed" behavior
const FindAirState						= 'FindAir';					// search for surface when in water in order to breathe
const HandleInvalidLandingState			= 'HandleInvalidLanding';		// state for getting off railings and such
const HoldState							= 'Hold';						// NPC is trying to get to a holdspot
const HoldingState						= 'Holding';					// NPC is at the holdspot
const KnockDownState					= 'KnockDown';					// NPC knocked down by damage
const ImpalingState						= 'Impaling';					// Impaling melee attack state
const MoveToGoalBaseState				= 'MoveToGoalBase';				// base state for moving to a goal
const MoveToGoalNoEnemyState			= 'MoveToNoEnemyGoal';			// extends MoveToGoalBase -- no enemy
const MoveToGoalWithEnemyState			= 'MoveToGoalWithEnemy';		// extends MoveToGoalBase -- enemy
const RoamingState						= 'Roaming';					// going to items with no enemy
const UsingState						= 'Using';						// using a usable item
const VictoryDanceState					= 'VictoryDance';				// celebrate kill
const WanderingState					= 'Wandering';					// picking random locations (vectors) to move to
const WanderingPanicState				= 'WanderingPanic';				// NPC is panicking (e.g. on fire)

const FrozenState						= 'Frozen';						// testing: NPC can't move, can't rotate, can't shoot
const TestMoveState						= 'TestMove';					// testing: NPC immediately heads to TestMoveTarget

// label name consts (some only used in subclasses)
const AdjustFromWallLabel				= 'AdjustFromWall';
const AdjustPositionLabel				= 'AdjustPosition';
const AdjustPositionAgainLabel			= 'AdjustPositionAgain';
const AdjustRotationLabel				= 'AdjustRotation';
const AttackOngoingLabel				= 'AttackOngoing';		// used to maintain focus/rotation, check target etc. during ranged/melee attack
const AttackDoneLabel					= 'AttackDone';			// current melee/ranged attack ended
const AutoEndLabel						= 'AutoEnd';
const CampLabel							= 'Camp';
const CampAgainLabel					= 'CampAgain';
const CampLongLabel						= 'CampLong';
const CantReachLabel					= 'CantReach';
const ChallengeLabel    				= 'Challenge';
const CloseLabel						= 'Close';
const DelayLabel						= 'Delay';
const DialogBeginLabel					= 'DialogBegin';
const DialogEndLabel					= 'DialogEnd';
const DialogFocusRestoreLabel			= 'DialogFocusRestore';
const DialogFocusSetLabel				= 'DialogFocusSet';
const DialogPauseLabel					= 'DialogPause';
const DialogUnPauseLabel				= 'DialogUnPause';
const DodgeFinishedLabel				= 'DodgeFinished';
const DontCloseLabel					= 'DontClose';
const DoneLabel							= 'Done';
const DuckingLabel						= 'Ducking';
const ErrorLabel						= 'Error';
const FaceTargetLabel   				= 'FaceTarget';
const FireLabel							= 'FireFalling';
const GiveUpLabel						= 'GiveUp';
const GiveWayLabel						= 'GiveWay';
const HuntLabel							= 'Hunt';
const IdleLabel							= 'Idle';
const LandLabel							= 'Land';
const MoveActiveLabel					= 'MoveActive';
const MoveActiveStrafeLabel				= 'MoveActiveStrafe';
const MoveCheckLabel					= 'MoveCheck';
const MoveDoneLabel						= 'MoveDone';
const MoveFailedLabel					= 'MoveFailed';
const MoveFallingLabel					= 'MoveFalling';
const MoveNoDestLabel					= 'MoveNoDest';
const MovePickDestLabel					= 'MovePickDest';
const MovePickDestLoopLabel				= 'MovePickDestLoop';
const MoveSpecialLabel					= 'MoveSpecial';
const MoveTestLabel						= 'MoveTest';
const PauseLabel						= 'Pause';
const PostBeginLabel					= 'PostBegin';
const PreBeginLabel						= 'PreBegin';
const ReachedDestinationLabel			= 'ReachedDestination';
const ReadyToAttackLabel				= 'ReadyToAttack';
const RecoverEnemyLabel					= 'RecoverEnemy';
const ResumePatrolLabel					= 'ResumePatrol';
const ShootDecorationLabel				= 'ShootDecoration';
const StanceChangeDelayLabel			= 'StanceChangeDelay';
const StartLeapLabel					= 'StartLeap';
const StartupDelayLabel					= 'StartupDelay';
const TacticalTickLabel					= 'TacticalTick';
const TrackFocusLabel					= 'TrackFocus';
const TryAgainLabel						= 'TryAgain';
const TurnLabel							= 'Turn';
const WaitingForStartLabel  			= 'WaitingForStart';
const WavingLabel						= 'Waving';
										
const UnuseEvent						= 'unuse';

const NeedToTurnAngleCos				= 0.990;	// NOTE: should be at least as large as CosMinFacingTargetAngle
const NeedToTurnDialogAngleCos			= 0.350;

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

const DefaultIsCloseToDynamicGoalDistance	= 128.0;	// distance to use if no distance specified when checking if close to a moving goal
const MaxNoLOSFollowDistance				= 16.0;		// if no LOS to follow target, use this distance instead of default
const MinFollowDistance						= 1;//16.0;	// never try to move closer than this to a followed goal (e.g. Pawn)
const MinGoalDistance						= 1;//16.0;	// never try to move closer than this to a non-follow goal (engine could fail to reach it otherwise)
const MaxRadiusEnemiesDistance				= 1600.0;	// max distance used to find nearby enemies

const INCOMINGCOLLISIONFUDGE				= 2.0;

enum EMoveType
{
	// in order of decreasing "severity"
	MT_Error,						// pathing error
	MT_None,						// no current destination (caller can decide whether this is an error or not?)
	MT_Wait,						// can't currently get to destination -- try again in a bit
	MT_Near,						// near or at destination (no need to move)
	MT_Success,						// can move towards destination
};

enum EDestinationResult
{
	DR_Predicted,					// using a predicted destination
	DR_Raw,							// using a raw (direct) destination
	DR_Wait,						// wait a bit...
};

var int MaxMoveToPointAttempts;		// caps number of failed attempts to reach same goal
var int MaxMoveToActorAttempts;		// caps number of failed attempts to reach same goal
var int MaxMoveRecoverAttempts;		// caps number of failed attempts to reach same goal

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

// AI flags

// AI internal - misc
var	float LastAcquireTime;			// set as NPC acquires enemy
var bool bTargetObscured;			// set when checking odds of hitting enemy with shot

// set in Possess
var U2PawnBase U2PBase;
var U2PawnBasic U2PBasic;
var U2PawnAdvanced U2PAdvanced;

// AI internal - movement
var EMoveType GMoveType;			// holds result of last call to SetMoveTarget etc.
var	int	NumMoveAttempts;			// number of failed attempts to reach current destination
var	int	NumMoveRecoverAttempts;		// number of failed attempts to reach current destination
var vector WanderDirectionExternal; // used for resolving friendly interactions (clustering, defer to etc.)
var vector OldMoveLocation;

var float ReduceStanceAgainTime;	// used to lock out going standing -> crouching/prone or crouching -> prone for a while

// for testing movement/pathing
var Actor TestMoveTarget;
var float TestMoveSpeed;
var ETacticalMoveType TestTacticalMoveType;

var float DodgeEnableTime;			// used in some cases to block dodging for a while (e.g. right after a knockdown/panic)
var Actor SpecialGoal;				// special goal (scripted, flag, replicator, gotoactor destination etc.)
var float SpecialGoalDistance;		// used with special goal command to control "destination reached" distance (-1.0 means not used)
var bool  bFaceSpecialGoal;			// whether to try to face goal actor

var bool bLastAimLocationHitFriendly; // set to true when last adjustaim trace hits a friendly NPC/XMP item

var float TemporaryGoalDistance;	// used to temporarily override special goal distance
var float CloseEnoughDistance;		// if NPC following a Pawn which isn't currently reachable, stay put if at least this close
var float GetCloserThreshold;		// if NPC following a Pawn which isn't currently reachable, stay put unless can get this much closer

// dialog
//NOTE (MIB): Are 2 focii needed? (mdf): probably not -- we should be able to use Focus for this?                      
//NOTE (MIB): Are there scenarios where it be useful for the AI to decide whether to face the Focus or the DialogFocus?
var protected Actor OldFocus;
var protected vector OldFocalPoint;
var protected Actor DialogFocus;		
var protected bool bDialogSetFocus;			// set if a dialog session sets NPC rotation

var float StopFiringAtEnemyTime;

var float MaxAffectedByHitTime;				// (secs)
var float MaxAffectedByAcquisitionTime;		// (secs)

// odds of trying to hit target at min..max difficulty
var float TryToHitInstantBaseOddsMin;		
var float TryToHitInstantBaseOddsMax;
var float TryToHitProjectileBaseOddsMin;
var float TryToHitProjectileBaseOddsMax;
var float TryToHitTossedBaseOddsMin;
var float TryToHitTossedBaseOddsMax;

// distance around which base odds are based
var float TryToHitInstantBaseDistance;
var float TryToHitProjectileBaseDistance;
var float TryToHitTossedBaseDistance;

// don't try to miss if distance < min
var float TryToHitInstantMinMissDistance;
var float TryToHitProjectileMinMissDistance;
var float TryToHitTossedMinMissDistance;

// always try to miss if distance > max
var float TryToHitProjectileMaxHitDistance;
var float TryToHitInstantMaxHitDistance;
var float TryToHitTossedMaxHitDistance;

var float TryToHitBaseSpeed;				// speed around which try to hit odds scaled
var float TryToHitBaseSpeedOdds;			// odds used at this speed
var float BlockedByCoverHitOdds;

var float MaxAlwaysLeadDistance;			// if enemy distance > this, sometimes don't lead
var float MaxHitMissMultiplier;
var float MaxAcquireMissMultiplier;
var int MaxHitPitchError;
var int MinHitPitchError;
var int MaxAcquirePitchError;
var int MinAcquirePitchError;

var int Hits, Misses;						//!!mdf-tmp testing / stat gathering

const MaxDistanceActors = 32;
struct TDistanceInfo
{
	var() float Distance;
	var() Actor TargetActor;
};

var float MinTeleportRangeMoveError, MaxTeleportRangeMoveError;
var float MinTeleportRangeMinZError, MaxTeleportRangeMinZError;
var float MinTeleportRangeStuckError, MaxTeleportRangeStuckError;

var float MinLastRenderedTeleportDelay;

var int DefaultRotationThreshold;
var int ScriptedRotationThreshold;

var name DefaultState;						// default state when NPC initialized (usually Roaming/Wandering etc.)

//-----------------------------------------------------------------------------
// interface

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

//-----------------------------------------------------------------------------
// Completely freezes NPC -- won't be able to shoot or rotate. Useful for doing
// various testing.

function SetFrozen( bool bVal )
{
	if( bVal )
	{
		GotoState( FrozenState );
	}
	else
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
	}
}

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

function Possess( Pawn P )
{
	// helpers
	U2PBase = U2PawnBase(P);
	U2PBasic = U2PawnBasic(P);
	U2PAdvanced = U2PawnAdvanced(P);

	OldMoveLocation = P.Location;

	#debug DMAI( "U2PBase: " $ U2PBase );
	#debug DMAI( "U2PBasic: " $ U2PBasic );
	#debug DMAI( "U2PAdvanced: " $ U2PAdvanced );

	Super.Possess( P );
}

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

event PreBeginPlay()
{
	Super.PreBeginPlay();
	
	// or else NPCs might not turn towards what they want to fire at
	assert( NeedToTurnAngleCos >= CosMinFacingTargetAngle );
}

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

function SetPeripheralVision()
{
	U2PBase.RestoreSightRadius();
}

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

function Shutdown( bool bVal )
{
	if( bVal )
	{
		U2PBase.Visibility			=  0.0;
		U2PBase.HearingThreshold	=  0.0;
		U2PBase.Alertness			= -1.0;
		U2PBase.AirControl			=  0.0;
		U2PBase.SetSightRadius( 0.0 );
	}
	else
	{
		U2PBase.HearingThreshold	= U2PBase.InitialHearingThreshold;
		U2PBase.Alertness			= U2PBase.InitialAlertness;
		U2PBase.AirControl			= U2PBase.default.AirControl;
		U2PBase.Visibility			= U2PBase.default.Visibility;
		U2PBase.RestoreSightRadius();
	}
}

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

function LockAnimationController( int LockLevel )
{
	if( U2P != None && U2P.AnimationController != None )
		U2P.AnimationController.LockAnimationController( LockLevel );
}

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

function UnlockAnimationController( optional bool bClear )
{
	if( U2P != None && U2P.AnimationController != None )
	{
		U2P.AnimationController.UnlockAnimationController();
		if( bClear )
			U2P.AnimationController.SpecialAnimationClear();
	}
}

//-----------------------------------------------------------------------------
//@ INPUT -- RAW ENGINE EVENTS
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Map HearNoise event to HearNoiseFriendly/Other/Threat.
// mdf-tbi: Do we need to pass on the Loudness param?

event final HearNoise( float Loudness, Actor NoiseMaker )
{
	local Pawn NoiseInstigator;
	local EAttitude AttitudeToOther;

	// mdf-tbr: should only be called with Actors/Pawns -- fix callers if any passing in a Controller
	// otherwise do if( Controller(Instigator) != None ) Instigator = Controller(Instigator).Pawn;
	//DMAssert( Controller(NoiseMaker) == None, "HearNoise" );

	// need to check the Instigator, not the source of the noise itself
	NoiseInstigator = NoiseMaker.Instigator;

	//mdf-tbd: seems this can happen? This means engine isn't filtering these out
	// unless we ever plan to have NPCs react to noises which they instigated 
	// might be best to make engine filter these out. Only case I can think of 
	// where we might want these events is for a projectile that the NPC fired
	// (NPC follows projectile via its MakeNoise events?)

	#debug DMAssert( NoiseInstigator != Pawn, GetContext() );

	if( NoiseInstigator != None )
	{
		if( ValidPawn( NoiseInstigator ) )
		{
			// Pawn is alive and well and visible etc.

			// NOTE: engine currently only sends HearNoise for enemies
			#debug DMAssert( GetAttitudeTo( NoiseInstigator ) == ATTITUDE_Enemy, GetContext() );
			if( StationaryPawn(NoiseInstigator) == None || StationaryPawn(NoiseInstigator).ConsiderAttacking( NoiseInstigator, Self ) )
				HearNoiseThreat( Loudness, NoiseMaker );
/*
			AttitudeToOther = GetAttitudeTo( NoiseInstigator );

			if( AttitudeToOther == ATTITUDE_Enemy )
			{
				// mdf-tbd: be reasonable about whether should set Instigator as ControllerEnemy -- could be miles away)
				// unless ControllerEnemy = Instigator (already the NPC's enemy) or CanSee Instigator (taking
				// peripheral vision, sightrange into account), don't pass as NoiseThreat -- pass as NoiseOther
				// and NPC should *investigate* the noise -- only set ControllerEnemy if sees him & gets close enough
				HearNoiseThreat( Loudness, NoiseMaker );
			}
			else if( AttitudeToOther == ATTITUDE_Friend )
			{
				// mdf-tbd: filter a lot of these for performance reasons?
				//HearNoiseFriendly( Loudness, NoiseMaker );
			}
*/
		}
	}
	else
	{
		// and allow for reactions to noises with no Instigator (need to fix engine code though -- won't send these currently)
		// mdf-tbd: how to handle non-Pawn sources of noise (or no Instigator?
		// mdf-tbd: filter a lot of these for performance reasons?
		//HearNoiseOther( Loudness, NoiseMaker );
	}
}

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

function MaybeAvoidFriendlyBump( Pawn Other );

//-----------------------------------------------------------------------------
// Map bump event to BumpFriendly/Other/Threat.

event final bool NotifyBump( Actor Other )
{
	local EAttitude AttitudeToOther;

	//DMAssert( Controller(Other) == None, "NotifyBump" );

	#debug DMAI( "NotifyBump: " $ Other );
	//DMTNS( "NotifyBump: " $ Other );

	//mdf-tbr:
	#debug DMAssert( Other != Pawn, GetContext() );

	if( Pawn(Other) != None )
	{
		if( ValidPawn( Pawn(Other) ) )
		{
			// Pawn is alive and well and visible etc.

			AttitudeToOther = GetAttitudeTo( Pawn(Other) );

			if( AttitudeToOther == ATTITUDE_Enemy )
			{
				//DMTNS( "  (enemy)" );
				BumpEnemy( Pawn(Other) );
			}
			else if( AttitudeToOther == ATTITUDE_Friend )
			{
				// mdf-tbd: filter a lot of these for performance reasons?
				BumpFriend( Pawn(Other) );
				
				// allow for special handling of friendly bumps regardless of
				// whether bump events are being filtered by the script
				MaybeAvoidFriendlyBump( Pawn(Other) );
			}
		}
	}
	else
	{
		// mdf-tbd: how to handle non-Pawn sources of noise (or no Instigator?
		// mdf-tbd: filter a lot of these for performance reasons?
		//BumpOther( Other );
	}

	// never pass this on to the Pawn?
	return true;
}

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

event bool NotifyPhysicsVolumeChange( PhysicsVolume NewVolume )
{
	local vector JumpDir;

	if( NewVolume.bWaterVolume )
	{
		if( !Pawn.bCanSwim )
		{
			MoveTimer = -1.0;
		}
		else if( Pawn.Physics != PHYS_Swimming )
		{
			Pawn.SetPhysics( PHYS_Swimming );
		}
	}
	else if( Pawn.Physics == PHYS_Swimming )
	{
		if( Pawn.bCanFly )
		{
			 Pawn.SetPhysics( PHYS_Flying ); 
		}
		else
		{ 
			Pawn.SetPhysics( PHYS_Falling );
			if( Pawn.bCanWalk && ( Abs( Pawn.Acceleration.X ) + Abs( Pawn.Acceleration.Y ) > 0 )
				&& ( Destination.Z >= Pawn.Location.Z ) 
				&& Pawn.CheckWaterJump( JumpDir ) )
				Pawn.JumpOutOfWater( JumpDir );
		}
	}

	//DMTNS( "Global.NotifyPhysicsVolumeChange Physics: " $ Pawn.Physics );
	
	return false;
}

/*-----------------------------------------------------------------------------
A number of states override SetFall to specify the state and label to return 
to after going to the falling state.
*/

function SetFall()
{
	//local float OldJumpZ;

	if( Pawn.bCanFly )
	{
		Pawn.SetPhysics( PHYS_Flying );
	}
	else if( !Pawn.bBlockAdjustJump )
	{
		if( Pawn.bCanAdjustJump )
		{
			// allow full adjust jump
			StopMovement( true, false );
			Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
			StartFalling();	
		}
		else
		{
			// recuce / eliminate jump adjust?
			/*
			// reduce JumpZ used for adjusting jump
			StopMovement( true, false );
			OldJumpZ = Pawn.JumpZ;
			Pawn.JumpZ = 10; //tbd: using a low JumpZ seemed to work well in-game
			Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
			Pawn.JumpZ = OldJumpZ;
			*/
			
			StartFalling();	
		}
	}
		
	// always clear for next call
	Pawn.bBlockAdjustJump = false;
}

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

//-----------------------------------------------------------------------------
// mdf-tbd: we need to be very careful about how often this function is called
// e.g. due to texture sounds etc. -- short-circuit this as much as possible.

function eventHearNoiseThreat( float Loudness, Actor NoiseMaker )
{
	#debug DMAIE( "Global eventHearNoiseThreat" );
	//log( class$" heard noise by "$NoiseMaker.class );
	// mdf-tbd: see HearNoise -- at this point we can assume that NoiseMaker is a valid ControllerEnemy
	if( MaybeSetEnemy( NoiseMaker.Instigator ) && NoiseMaker.Instigator == ControllerEnemy )
	{
		// mdf-tbd: without above check, this assumes NoiseMaker is the NPC's enemy which
		// may not be the case in Unreal2 (e.g. NPC reacting to explosion or projectile 
		// in a situation where the Instigator is unknown.
		HandleEnemyNoise( NoiseMaker );
	}
}

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

function eventHearNoiseFriendly( float Loudness, Actor NoiseMaker )
{
	// mdf-tbd: do nothing / if no enemy occasionally look at source?
}

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

function eventHearNoiseOther( float Loudness, Actor NoiseMaker )
{
	// mdf-tbd: go into a higher state of alert / search the area?
}

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

function eventSeeAlertFriend( Pawn Seen )
{
	#debug DMAIE( "Global.eventSeeAlertFriend" );
	ReactToAlertFriend( Seen );
}

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

function eventSeeEnemy( Pawn Seen )
{
	#debug DMAIE( "Global eventSeeEnemy" );
	MaybeSetEnemy( Seen );
}

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

function eventSeeFriend( Pawn Seen )
{
	#debug DMAIE( "Global eventSeeFriend" );

	ReactToFriend( Seen );
}

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

function eventSeeOther( Actor Seen )
{
	#debug DMAIE( "Global eventSeeOther" );
	// NPCs default to not reacting to seeing "other" ?
	// I should be able to uncomment this -- events aren't enabled so "see" never happens
	//mdf-tbd: ambients & such
	//tbd: enemies can only be Pawns currently
	//MaybeSetEnemy( Seen );
}

//-----------------------------------------------------------------------------
// Called by eventBumpEnemy/Friend/Other for use in situations where code wants
// to know about *any* bumps.

function eventBumpAll( Actor Other )
{
}

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

function eventBumpEnemy( Pawn Other )
{
	local Pawn OldControllerEnemy;

#debugbegin
	if( !ValidPawn( Other ) )
		DMAssert( false, Other $ " is invalid " $ GetContext() );
#debugend

	eventBumpAll( Other );

	OldControllerEnemy = ControllerEnemy;

	//DMTNS( "eventBumpEnemy calling MaybeSetEnemy: " $ Other );
	
	MaybeSetEnemy( Other );
	if( ControllerEnemy == Other && IsPreparedToFire( true, true, U2Weapon.RatingIneffective ) )
	{
		//DMTNS( "calling HandleBumpEnemy" );
		HandleBumpedByEnemy();
	}
	else 
	{
		//DMTNS( "restoring OldControllerEneny" );
		#debug   SetControllerEnemy( OldControllerEnemy, GetContext() );
		#release SetControllerEnemy( OldControllerEnemy );
	}
		
	//DMTNS( "eventBumpEnemy called MaybeSetEnemy  ControllerEnemy: " $ ControllerEnemy );
}

//-----------------------------------------------------------------------------
// refactoring hacks

function bool WanderAfterFriendlyBumpExtra() { return false; }
function bool FriendlyBumpSpecial() { return false; }

//-----------------------------------------------------------------------------
// NOTE (mdf): instrumental in helping to resolve clustering between friendly
// NPCs.

function eventBumpFriend( Pawn Other )
{
	local vector VelDir, OtherDir;
	local float Speed, Dist, OldVelocityZ;
	local Controller C;
	local bool bDestinationObstructed, bAmLeader;
	local int Num;

	eventBumpAll( Other );

	// mdf-tbd: clean up this crapola
	if( HandleFriendlyBumps() && Other != None && Other.Controller != None && MoveTarget != None )
	{
		OtherDir = Other.Location - MoveTarget.Location;
		if( Abs( OtherDir.Z ) < Other.CollisionHeight )
		{
			OtherDir.Z = 0;
			Dist = VSize( OtherDir );
			bDestinationObstructed = ( VSize( OtherDir ) < Other.CollisionRadius );

			bAmLeader = Other.Controller.DeferTo( Self );

			// check if someone else is on destination or within 3 * collisionradius
			for( C=Level.ControllerList; C!=None; C=C.NextController )
				if( C != Self && C.Pawn != None )
				{
					Dist = VSize( C.Pawn.Location - MoveTarget.Location );
					if( Dist < C.Pawn.CollisionRadius )
					{
						bDestinationObstructed = true;
						bAmLeader = bAmLeader || C.DeferTo( Self );
					}
					if( Dist < 3 * C.Pawn.CollisionRadius ) 
					{
						Num++;
						if( Num >= 2 )
						{
							bDestinationObstructed = true;
							bAmLeader = bAmLeader || C.DeferTo( Self );
						}
					}
				}

			if( bDestinationObstructed && !bAmLeader )
			{
				// Other is standing on my destination
				MoveTimer = -1.0;

				if( !FriendlyBumpSpecial() &&
					Pawn.Health > 0 && 
					(!IsInState( WanderingState ) || Pawn.Acceleration == vect(0,0,0)) )
				{
					if( AllowFriendlyBumpStateChanges() )
					{
						WanderDirectionExternal = Other.CollisionRadius*2.0*Normal( Pawn.Location - Other.Location );
						GotoState( WanderingState, BeginLabel );
					}
				}
			}
		}
	}

	Speed = VSize( Pawn.Velocity );
	if( Speed > 10 )
	{
		VelDir = Pawn.Velocity/Speed;
		VelDir.Z = 0;
		OtherDir = Other.Location - Pawn.Location;
		OtherDir.Z = 0;
		OtherDir = Normal( OtherDir );

		if( ( VelDir dot OtherDir ) > 0.8 )
		{
			OldVelocityZ = Pawn.Velocity.Z;

			Pawn.Velocity.X = VelDir.Y;
			Pawn.Velocity.Y = -1 * VelDir.X;
			Pawn.Velocity *= FMax( Speed, 280 );

			// mdf-tbd: don't scale Z velocity for falling/walking NPCs or NPC can get slammed into the ground and take damage
			if( Pawn.Physics == PHYS_Falling || Pawn.Physics == PHYS_Walking )
				Pawn.Velocity.Z = OldVelocityZ;
		}
	} 
	else if( WanderAfterFriendlyBumpExtra() )
	{
		GotoState( WanderingState, BeginLabel );
	}

	// basically an error situation?
	if( AllowFriendlyBumpStateChanges()	)
		Pawn.GotoState( NoState );
}

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

function eventBumpOther( Actor Other )
{
	eventBumpAll( Other );
}

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

#if0
// mdf-tbd: make native so GetAttitudeTo can hook into this?
// which maintains a list of Pawns that this NPC is annoyed at?
function bool AnnoyedAt( Pawn Other )
{
	// hacked in for now -- generalize
	// turn into an annoyance factor which can be modified by several things
	// also annoyance should fade with time
	return false; // mdf-tbd: ( (AttackBumpLimit >= 0) && (PlayerBumpedMeCount > AttackBumpLimit) );
}
#endif0

/*-----------------------------------------------------------------------------
Returns a value indicating the relative strength of other:

	< 0 ==> weaker
	0.0 ==> equal
	> 0 ==> stronger

Since the result will be compared to the creature's aggressiveness, it should be
on the same order of magnitude (-1 to 1)
*/

function float RelativeStrength( Pawn Other )
{
	local float Compare;
	local int AdjustedOtherHealth;

	//2002.12.15 (mdf) basically a hack to prevent skaarj from concentrating on McMillan in M10):
	if( U2PawnBasic(Other) != None && U2PawnBasic(Other).bIgnoreRelativeHealth )
		AdjustedOtherHealth = 0.5 * Other.default.Health;	
	else
		AdjustedOtherHealth = 0.5 * (Other.Health + Other.default.Health);	
		
	if( U2PBasic != None && U2PBasic.bIgnoreRelativeHealth )
		Compare = 0.01 * float( AdjustedOtherHealth - Pawn.default.Health );
	else
		Compare = 0.01 * float( AdjustedOtherHealth - Pawn.Health );

	Compare -= Pawn.DamageScaling * (GetAttackRating( Other ) - 0.3);

	if( GetFireRating() < 0.5 )
	{
		Compare += 0.3;

		if( Other.Controller.GetFireRating() > 0.5 )
			Compare += 0.35;
	}

	Compare += Other.DamageScaling * (Other.Controller.GetAttackRating( Pawn ) - 0.3);
	
	if( Other.Location.Z > Pawn.Location.Z + 400 )
		Compare -= 0.2;
	else if( Pawn.Location.Z > Other.Location.Z + 400 )
		Compare += 0.15;

	//DMTNS( "RelativeStrength of " $ Other $ " to " $ Pawn $ " is " $ Compare );
	return Compare;
}

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

function float AddedHumanThreat()
{
	return 0.15;
}

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

function bool ReduceThreat()
{
	return false;
}

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

function float AssessThreat( Pawn Other )
{
	local float ThreatValue, OtherStrength, OtherDistance;
	local Pawn CurrentEnemy;
	
	OtherStrength = RelativeStrength( Other );
	
	//!!mdf-tbd whether this makes sense
	ThreatValue = FMax( 0, OtherStrength );
	if( Other.Health < 20 )
		ThreatValue += 0.3;

	//!!mdf-tbd whether this makes sense
	OtherDistance = VSize( Other.Location - Pawn.Location );
	if( OtherDistance < 800 )
		ThreatValue += 0.3;

	//!!mdf-tbd whether this makes sense
	CurrentEnemy = ControllerEnemy;
	
	if( Other != CurrentEnemy && CurrentEnemy != None )
	{
		if( OtherDistance > 0.7 * VSize( ControllerEnemy.Location - Pawn.Location ) )
			ThreatValue -= 0.25;

		ThreatValue -= 0.2;

		if( !LineOfSightTo( Other ) )
		{
			if( OtherDistance < 1200 )
				ThreatValue += 0.2;
			if( bPreparingMove )
				ThreatValue += 5;

			if( ReduceThreat() && 
				OtherStrength < 0.2 && 
				(Level.TimeSeconds - GetLastEnemySeenTime()) < 3 && 
				RelativeStrength( CurrentEnemy ) < FMin( 0, OtherStrength ) )
			{
				ThreatValue -= 0.3;
			}
		}
	}

	// NOTE: this will make NPCs tend to go after (real) players all things being equal
	if( Other.IsHumanControlled() )
		ThreatValue += AddedHumanThreat();

	//DMTNS( "AssessThreat for " $ Other $ ": " $ ThreatValue );
	return ThreatValue;
}

//-----------------------------------------------------------------------------
// Returns:
// P1 > P2 : X > 0.0
// P1 = P2 : X = 0.0
// P1 < P2 : X < 0.0

function float CompareThreat( Pawn P1, Pawn P2 )
{
	local float ThreatP1, ThreatP2;
	local Controller C;
	local float P1Distance, P2Distance, DistanceDifference, MinDist;

	if( P1 == P2 )
		return 0.0;

	//!!mdf-tbd: should prefer to attack stationary pawn (aggresive even more so)
	//if other is an NPC/player which already has N (2 might work) enemies
	if( StationaryPawn(P1) != None && StationaryPawn(P2) == None )
	{
		// P1 is a stationary pawn, P2 is an NPC
		//!! make sure NPC can be hit (e.g. not through a force field)
		ThreatP2 = 1.0; // NPC P2 is greater threat than stationary pawn P1
	}
	//2002.12.10 (mdf) bug?
	//else if( StationaryPawn(P1) == None || StationaryPawn(P2) != None )
	else if( StationaryPawn(P1) == None && StationaryPawn(P2) != None )
	{
		// P1 is an NPC, P2 is a stationary pawn
		//!! make sure NPC can be hit (e.g. not through a force field)
		ThreatP1 = 1.0;	// NPC P1 is greater threat than stationary pawn P2
	}
	else if( StationaryPawn(P1) != None && StationaryPawn(P2) != None )
	{
		// P1 and P2 are both stationary pawns - if either has an attack that one is more dangerous
		if( StationaryPawn(P1).bHasAttack )
			ThreatP1 = 1.0; // P1 can attack
		else if( StationaryPawn(P2).bHasAttack )
			ThreatP2 = 1.0;	// P2 can attack
	}
	else if( P1.bIsRealPlayer != P2.bIsRealPlayer && (U2PBasic.bFearPlayersMoreThanNPCs || U2PBasic.bFearNPCsMoreThanPlayers) )
	{
		// one Pawn is a player
		if( U2PBasic.bFearPlayersMoreThanNPCs )
		{
			if( P1.bIsRealPlayer )
			{
				ThreatP1 =  1.0;
				ThreatP2 = -1.0;
			}
			else
			{
				ThreatP1 = -1.0;
				ThreatP2 =  1.0;
			}
		}
		else
		{
			if( P1.bIsRealPlayer )
			{
				ThreatP1 = -1.0;
				ThreatP2 =  1.0;
			}
			else
			{
				ThreatP1 =  1.0;
				ThreatP2 = -1.0;
			}
		}
	}
	//!!mdf: complete hack so NPC won't consider health if either enemy has bIgnoreRelativeHealth
	// (in general NPCs seem to almost never switch from one enemy to another currently)
	else if( (U2PawnBasic(P1) != None && U2PawnBasic(P1).bIgnoreRelativeHealth) || 
			 (U2PawnBasic(P2) != None && U2PawnBasic(P2).bIgnoreRelativeHealth) )
	{
		// attack P1 if closer, P2 otherwise
		P1Distance = VSize( Pawn.Location - P1.Location );
		P2Distance = VSize( Pawn.Location - P2.Location );
		DistanceDifference = P2Distance - P1Distance;
		MinDist = FMin( P1Distance, P2Distance );
		if( DistanceDifference > 256.0 || (MinDist < 256.0 && DistanceDifference > 32.0) || MinDist < 64.0 )
			return DistanceDifference;
		else
			return 0.0; // keep current enemy
	}
	else
	{
		// evaluate relative strength of non-StationaryPawns
		ThreatP1 = AssessThreat( P1 );
		ThreatP2 = AssessThreat( P2 );
	}

	if( ThreatP1 == ThreatP2 )
	{
		// decrease threat relative to number of enemies each Pawn already has that I can see?
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C != Self )
			{
				if( C.ControllerEnemy == P1 && LineOfSightTo( C.Pawn ) )
					ThreatP1 -= 1.0;
				else if( C.ControllerEnemy == P2 && LineOfSightTo( C.Pawn ) )
					ThreatP2 -= 1.0;
			}
		}
	}	

	if( ThreatP1 == ThreatP2 )
	{
		// increase threat of closer one
		if( VSize( Pawn.Location - P1.Location ) <= VSize( Pawn.Location - P2.Location ) )
			ThreatP1 += 1.0;
		else
			ThreatP2 += 1.0;
	}
	
	//DMTNS( "CompareThreat " $ P1 $ " (" $ ThreatP1 $ ") " $ P2 $ " (" $ ThreatP2 $ ")" );
	return ( ThreatP1 - ThreatP2 );
}

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

function bool HandleFriendlyBumps()
{
	return true;
}

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

function bool AllowFriendlyBumpStateChanges()
{
	return true;
}

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

function ReactToAlertFriend( Pawn P )
{
	local Controller Friend;

	DMAI( "Global.ReactToAlertFriend" );
	Friend = P.Controller;
	if( ValidPawn( Friend.ControllerEnemy ) && Pawn.SameTeam( P ) )
		MaybeInheritEnemy( P, Friend.ControllerEnemy, true );
	else
		LPawn.SetAlert( true );
}

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

function ReactToFriend( Pawn P )
{
	// make sure friend isn't alert (in case SeeFriend enabled without SeeAlertFriend)
	if( ValidPawn( P.Controller.ControllerEnemy ) || LPawn.GetAlert() )
		ReactToAlertFriend( P );

	/*
	local Controller Friend;
	!!mdf-tbd: "react to "calm" friend stuff?
	local bool bNotSeen;
	local EReaction NewReaction;
	
	#1: GetReactionToEnemy only returns attack/fear currently
	#2: this code appears to be trying to let this NPC inherit
	    the friend's enemy but

	if( Friend.GetTimeSinceEnemyLastDetected() > 5 )
	*/
}

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

function EnemyAcquired()
{
	DMTNS( "WARNING: EnemyAcquired not implemented for " $ Name $ " (" $ Pawn.Name $ ")" );
}

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

function MaybeAlertOthers( Pawn PotentialEnemy );

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

function eventInheritEnemy( Pawn NewEnemy )
{
	MaybeSetEnemy( NewEnemy, true );
}

//-----------------------------------------------------------------------------
// Note: caller should verify on same team (if desired).

function MaybeInheritEnemy( Pawn Other, Pawn NewEnemy, optional bool bCanSee )
{
	//DMTNS( "MaybeInheritEnemy: " $ NewEnemy $ " from " $ Other );
	if( ControllerEnemy == None &&
		StationaryPawn(NewEnemy) == None && // 2002.12.12 (mdf) don't inherit XMP item enemies?
		U2PawnBase(Other) != None &&
		VSize( Pawn.Location - Other.Location ) <= U2PawnBase(Other).AlertOthersRadius &&
 		(bCanSee || !U2PawnBase(Other).bAlertOthersRequiresLOS || CanSee( Other )) )
	{
		#debug DMAIA( "MaybeInheritEnemy calling InheritEnemy" );
		//DMTNS( "MaybeInheritEnemy calling InheritEnemy for " $ NewEnemy );
		U2PBase.bAmbientCreature = false;
		InheritEnemy( NewEnemy );
	}
}

//-----------------------------------------------------------------------------
// Note: most Base NPCs don't track an OldControllerEnemy and if they react at all to 
// enemies they'll just run away (or have special behavior which doesn't make
// use of Basic+ code).

function bool MaybeAcquireEnemy( Pawn NewEnemy )
{
	if( ControllerEnemy == None || (U2PBasic != None && U2PBasic.bAlwaysAttackNewEnemy) )
	{
		#debug   SetControllerEnemy( NewEnemy, GetContext() );
		#release SetControllerEnemy( NewEnemy );
		return true;
	}
	
	return false;
}

//-----------------------------------------------------------------------------
// Returns true if NewEnemy became (or already was) the current enemy. Note:
// the reason we return true if NewEnemy already was the NPC's enemy is because
// input is often used to update/inform the NPC's current behavior. For example
// and NPC might have X as the enemy but might not currently have LOS to the
// enemy and might be hunting it. Seeing or hearing X might cause the NPC to
// change states. Note also that EnemyAcquired is only called when enemy 
// *becomes* NewEnemy.
//
// Callers should ensure that NewEnemy is valid enemy (e.g. this is often done
// early in the event handling stage and it would be inefficient to do this 
// again here given that events can occur so frequently).

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

	#debug DMAI( "MaybeSetEnemy NewEnemy=" $ NewEnemy );
	//DMTNS( "MaybeSetEnemy NewEnemy: " $ NewEnemy $ " Distance: " $ VSize( NewEnemy.Location - Pawn.Location ) );
#debugbegin
	// mdf-tbr: if this asserts fix the caller -- remove prior to release
	if( !ValidPawn( NewEnemy ) || GetAttitudeTo( NewEnemy ) != ATTITUDE_Enemy )
	{
		DMTNS( "Warning: invalid situation in" @ GetContext() );
		DMTNS( "  Pawn:                  " $ Pawn );
		DMTNS( "  AttitudeTo:            " $ EnumStr( Enum'EAttitude', GetAttitudeTo( NewEnemy ) ) );
		DMTNS( "  Enemy:                 " $ ControllerEnemy );
		DMTNS( "  NewEnemy:              " $ NewEnemy );
		DMTNS( "  ValidPawn:             " $ ValidPawn( NewEnemy ) );
		DMTNS( "     NewEnemy.bDeleteMe: " $ NewEnemy.bDeleteMe );
		DMTNS( "     NewEnemy.Health:    " $ NewEnemy.Health );    //!!mdf-tbd: stationary pawns not calling notifykilled?
		DMTNS( "     NewEnemy.bHidden:   " $ NewEnemy.bHidden );
	}
#debugend

	if( ControllerEnemy == NewEnemy )
	{
		bResult = true;
	}
	else
	{
		if( MaybeAcquireEnemy( NewEnemy ) )
		{
			bResult = true;
			EnemyAcquired(); // NOTE: this is pretty much *the* hook that states should use to handle acquiring an enemy
			if( !bAlertingOthers )
				MaybeAlertOthers( NewEnemy );
		}
	}

	// mdf-tbd: I'm not sure this makes sense -- we don't shouldn't necessarily 
	// know where the enemy is, no?
	if( bResult )
		EnemyDetected( ControllerEnemy.Location );

	return bResult;
}

//-----------------------------------------------------------------------------
// Maybe update last detected location due to noise from or originated by
// enemy?

function HandleEnemyNoise( Actor NoiseMaker )
{
	local vector NewEnemyDetectedLocation;
		
	//NOTE (mdf) - don't necessarily have LOS to enemy...
	if( NoiseMaker.Instigator == ControllerEnemy )
	{
		// sound was instigated by enemy -- use point half way between noisemaker location and where NPC is looking at same distance
		NewEnemyDetectedLocation = 0.5 * (NoiseMaker.Location + VSize( NoiseMaker.Location - Pawn.Location ) * vector(Pawn.Rotation));
	}
	/*!!mdf-tbr: isn't this the same as checking whether the noisemaker is the enemy?
	else if( Pawn(NoiseMaker) != None && 
			 Pawn(NoiseMaker).Controller != None && 
			 Pawn(NoiseMaker).Controller.ControllerEnemy == enemy )
	*/
	else if( NoiseMaker == ControllerEnemy )
	{
		// sound is from enemy -- use point half way between enemy location and where NPC is looking at same distance
		NewEnemyDetectedLocation = 0.5 * (ControllerEnemy.Location + VSize( ControllerEnemy.Location - Pawn.Location ) * vector(Pawn.Rotation));
	}
		
	if( VSize( NewEnemyDetectedLocation - ControllerEnemy.Location ) < VSize( GetLastEnemySeenLocation() - ControllerEnemy.Location ) )
		EnemyDetected( NewEnemyDetectedLocation );
}

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

function Pawn FindLocalEnemy( float MaxDistance )
{
	local Controller C;

   	// look for a nearby enemy
   	for( C=Level.ControllerList; C!=None; C=C.NextController )
   	{
   		if( StationaryPawn( C.Pawn ) == None && //2002.12.08 mdf-tbd: don't pick up nearby XMP items?
   			ValidEnemy( C.Pawn ) &&
   			(VSize(Pawn.Location - C.Pawn.Location) < MaxDistance) && 
   			CanSee( C.Pawn ) )
   		{
   			return C.Pawn;
   		}
	}

	return None;
}

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

function bool ShouldBounceProjectile()
{
	return FDecision( U2PBasic.BounceProjectileOdds );
}

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

function float GetBounceLifespan()					
{ 
	return U2PBasic.BounceLifespan + 2.0 * (1.0 - Level.Game.GetNormalizedDifficulty());
}

//-----------------------------------------------------------------------------
// maybe make mobile?

function VerifyMobility( float EnemyDistance )
{
	if( !bStayStationary && !IsMobile() )
	{
		//!!mdf-tbd: move health check into damage handling
		if( Pawn.Health < U2PBasic.MinStationaryHealth || EnemyDistance < U2PBasic.MinStationaryDistance )
		{
			SetStationary( false );
		}
	}
}

//-----------------------------------------------------------------------------
// maybe change stance due to enemy being too close?
// !!mdf-tbd: how to coordinate with transition animation (might not be in
// attackstationary etc.?

function bool UpdateStance( byte TargetStance, optional float EnemyDistance )
{
	local byte CurrentStance;
	
	// force crouching/standing if enemy is close
	CurrentStance = LPawn.GetDesiredStance(); // use desired stance in case it hasn't been set yet

	//DMTNS( "UpdateStance: " $ CurrentStance $ " --> " $ TargetStance $ "?" );

	if( (TargetStance == ST_Prone || TargetStance == ST_Crouching) && EnemyDistance <= 0.0 )
	{
		if( ControllerEnemy != None )
			EnemyDistance = VSize( Pawn.Location - ControllerEnemy.Location );
		else
			EnemyDistance = 99999.0; // default to handling as if far away
	}

	if( (TargetStance == ST_Prone || CurrentStance == ST_Prone) && EnemyDistance < U2PBasic.MinProneDistance )
	{
		//DMTNS( "too close for prone" );
		TargetStance = ST_Crouching;
	}
	
	if( (TargetStance == ST_Crouching || CurrentStance == ST_Crouching) && EnemyDistance < U2PBasic.MinCrouchDistance )
	{
		//DMTNS( "too close for crouch" );
		TargetStance = ST_Standing;
	}

	//DMTNS( "  Setting stance to: " $ TargetStance $ " result: " $ (LPawn.GetStance() != CurrentStance) );
	LPawn.SetStance( TargetStance ); // note: its possible for this to fail (e.g. no room for new stance)
	return ( TargetStance != CurrentStance );
}

//-----------------------------------------------------------------------------
// tbd: call for moving states also (need a more realistic crouch walk/run)

function bool SelectStance( bool bAvoidProne )
{
	local bool bResult;
	local float TotalOdds, RandVal;
	local byte CurrentStance, TargetStance;
	local float EnemyDistance;
	local float StandOdds, CrouchOdds, ProneOdds;

	if( !U2PBasic.bCanCrouch && !U2PBasic.bCanCrawl )
		return false;
		
	//DMTNS( "SelectStance current stance: " $ LPawn.GetStance() );

	// only consider changing stance if none was specified (e.g. via a script)
	if( StationaryStance == ST_None )
	{
		if( ControllerEnemy != None )
			EnemyDistance = VSize( ControllerEnemy.Location - Pawn.Location );
		else
			EnemyDistance = 9999999.999;
			
		CurrentStance = LPawn.GetStance();

		StandOdds = U2PBasic.StationaryStandOdds;
		if( Pawn.bCanCrouch && EnemyDistance >= U2PBasic.MinCrouchDistance && Level.TimeSeconds >= ReduceStanceAgainTime )
		{
			CrouchOdds = U2PBasic.StationaryCrouchOdds;
			if( Pawn.Weapon != None  )
				CrouchOdds *= Pawn.Weapon.GetPreferCrouchingMultiplier();
		}
		if( !bAvoidProne && Pawn.bCanCrawl && EnemyDistance >= U2PBasic.MinProneDistance && Level.TimeSeconds >= ReduceStanceAgainTime )
		{
			ProneOdds = U2PBasic.default.StationaryProneOdds;
			if( Pawn.Weapon != None  )
				ProneOdds *= Pawn.Weapon.GetPreferProneMultiplier();
		}
		
		TotalOdds = StandOdds + CrouchOdds + ProneOdds;
		
		//DMTNS( "  StandOdds:  " $ StandOdds );
		//DMTNS( "  CrouchOdds: " $ CrouchOdds );
		//DMTNS( "  ProneOdds:  " $ ProneOdds );
		//DMTNS( "  TotalOdds:  " $ TotalOdds );
		if( TotalOdds > 0.0 )
		{
			// in most cases NPC will tend to stay crouching/prone (as long as enemy doesn't
			// get too close or NPC isn't taking damange).
			if( (CurrentStance == ST_Crouching && FDecision( U2PBasic.StationaryStayCrouchingOdds )) ||
				(CurrentStance == ST_Prone && FDecision( U2PBasic.StationaryStayProneOdds )) )
			{
				//DMTNS( "Keeping stance: " $ CurrentStance );
				TargetStance = CurrentStance;
			}
			else
			{
				RandVal	= FRand()*TotalOdds;

				//DMTNS( "  RandVal: " $ RandVal );

				if( RandVal < StandOdds )
					TargetStance = ST_Standing;
				else if( RandVal < (StandOdds + CrouchOdds) )
					TargetStance = ST_Crouching;
				else
					TargetStance = ST_Prone;

				//DMTNS( "  TargetStance: " $ TargetStance );
			}

			bResult = UpdateStance( TargetStance );
		}
	}

	return bResult;
}

//-----------------------------------------------------------------------------
// Returns true if stance being changed.

function bool RestoreStance()
{
	// mdf-tbd: odds of keeping stance for movement (crouching only)
	//if( Pawn != None && Pawn.Health > 0 && StationaryStance == ST_None )
	if( Pawn != None && Pawn.Health > 0 )
	{
		//DMTNS( "RestoreStance calling UpdateStance" );
		return UpdateStance( ST_Standing ); //!!mdf-tbd: animation issues
	}
	
	return false;
}

//-----------------------------------------------------------------------------
//mdf-tbd: not currently used -- outside code can call this to have NPC avoid
//given location.

function FearThisSpot( Actor aSpot )
{
	StopMovement( true, false );
	MoveTimer = -1.0;
}

/*-----------------------------------------------------------------------------
SetAlertness()
Change creature's alertness, and appropriately modify attributes used by engine for determining
seeing and hearing.
SeeEnemy() is affected by PeripheralVision, and also by SightRadius and the target's visibility
HearNoise() is affected by HearingThreshold
*/

function SetAlertness( float NewAlertness )
{
	if( Pawn != None )
		Pawn.Alertness = NewAlertness;
}

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

function RestoreAlertness()
{
	if( Pawn != None )
		Pawn.Alertness = Pawn.default.Alertness;
}

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

function bool CanRespawn()
{
	return false;
}

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

function TeleportedPawn( vector OldLocation, Actor TargetActor )
{
	if( !U2P.bDisableErrorMessages )
		DMTNS( "Teleported " $ Pawn $ " from " $ class'Util'.static.GetVectorString( OldLocation ) $ " to " $ class'Util'.static.GetVectorString( Pawn.Location ) $ " TargetActor: " $ TargetActor $ "!" );
		
	if( !U2P.bDisableErrorColors )
	{
		AddArrow( OldLocation, Pawn.Location, ColorGreen() );
		AddActor( Pawn, ColorGreen() );
	}
}

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

function bool TeleportPawn( Actor TargetActor )
{
	local vector OldLocation;
	local vector TargetLocation;
		
	TargetLocation = class'Util'.static.GetLocationAtActor( TargetActor, Pawn.CollisionRadius, Pawn.CollisionHeight );
	
	OldLocation = Pawn.Location;
	if( Pawn.SetLocation( TargetLocation ) )
	{
		TeleportedPawn( OldLocation, TargetActor );
		return true;
	}
	else if( !U2P.bDisableErrorMessages )
	{
		DMTNS( "TeleportPawn failed for " $ Pawn $ " from " $ class'Util'.static.GetVectorString( OldLocation ) $ " to " $ class'Util'.static.GetVectorString( TargetLocation ) $ " TargetActor: " $ TargetActor $ "!" );
	}
	
	return false;
}

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

static function GetNearbyPathNodes( Actor SourceActor, out TDistanceInfo DistanceList[ MaxDistanceActors ], float MinDistance, float MaxDistance, bool bIgnoreZ )
{
	local int ii, jj, Len;
	local float Distance;
	local NavigationPoint NP;
	
	// collect valid pathnodes in MinTeleportRange..MaxTeleportRange
	Len = 0;
	for( NP=SourceActor.Level.NavigationPointList; NP!=None; NP=NP.NextNavigationPoint )
	{
		if( PathNode(NP) == None )
			continue;

		if( SourceActor.Physics == PHYS_Walking && !NP.bFindBase )
			continue;

		if( SourceActor.Physics == PHYS_Swimming && !NP.PhysicsVolume.bWaterVolume )
			continue;

		if( SourceActor.Physics != PHYS_Swimming && NP.PhysicsVolume.bWaterVolume )
			continue;
			
		if( bIgnoreZ )
			Distance = VSize2D( NP.Location - SourceActor.Location );
		else
			Distance = VSize( NP.Location - SourceActor.Location );
			
		if( Distance < MinDistance )
			continue;
		if( Distance > MaxDistance )
			continue;

		// sorted insert
		for( ii=0; ii<Len; ii++ )
		{
			if( DistanceList[ ii ].Distance >= Distance )
				break;
		}

		// shift everything else down
		for( jj=Len; jj>ii; jj-- )
		{
			if( jj < MaxDistanceActors )
			{
				DistanceList[ jj ] = DistanceList[ jj-1 ];
				if( jj == Len )
					Len++;
			}
		}
		
		if( ii < MaxDistanceActors )
		{
			DistanceList[ ii ].Distance = Distance ;
			DistanceList[ ii ].TargetActor = NP;
			
			if( ii == Len )
				Len++;
				
			//SourceActor.DMTNS( "Added " $ NP $ " at " $ ii $ " Len: " $ Len );
		}
	}

	//SourceActor.DMTNS( "DistanceList: " );
	//for( ii=0; ii<Len; ii++ )
	//	SourceActor.DMTNS( ii $ " " $ DistanceList[ii].TargetActor $ " : " $ DistanceList[ii].Distance );
}

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

//!!mdf-refactor after gold
static function GetNearbyPathNodesRelativeTo( Actor SourceActor, Actor RelativeActor, out TDistanceInfo DistanceList[ MaxDistanceActors ], float MinDistance, float MaxDistance, bool bIgnoreZ )
{
	local int ii, jj, Len;
	local float Distance;
	local NavigationPoint NP;
	
	// collect valid pathnodes in MinTeleportRange..MaxTeleportRange
	Len = 0;
	for( NP=SourceActor.Level.NavigationPointList; NP!=None; NP=NP.NextNavigationPoint )
	{
		if( PathNode(NP) == None )
			continue;

		if( SourceActor.Physics == PHYS_Walking && !NP.bFindBase )
			continue;

		if( SourceActor.Physics == PHYS_Swimming && !NP.PhysicsVolume.bWaterVolume )
			continue;

		if( SourceActor.Physics != PHYS_Swimming && NP.PhysicsVolume.bWaterVolume )
			continue;
			
		if( bIgnoreZ )
			Distance = VSize2D( NP.Location - SourceActor.Location );
		else
			Distance = VSize( NP.Location - SourceActor.Location );
			
		if( Distance < MinDistance )
			continue;
		if( Distance > MaxDistance )
			continue;

		if( bIgnoreZ )
			Distance = VSize2D( NP.Location - RelativeActor.Location );
		else
			Distance = VSize( NP.Location - RelativeActor.Location );
			
		// sorted insert
		for( ii=0; ii<Len; ii++ )
		{
			if( DistanceList[ ii ].Distance >= Distance )
				break;
		}

		// shift everything else down
		for( jj=Len; jj>ii; jj-- )
		{
			if( jj < MaxDistanceActors )
			{
				DistanceList[ jj ] = DistanceList[ jj-1 ];
				if( jj == Len )
					Len++;
			}
		}
		
		if( ii < MaxDistanceActors )
		{
			DistanceList[ ii ].Distance = Distance ;
			DistanceList[ ii ].TargetActor = NP;
			
			if( ii == Len )
				Len++;
				
			//SourceActor.DMTNS( "Added " $ NP $ " at " $ ii $ " Len: " $ Len );
		}
	}

	//SourceActor.DMTNS( "DistanceList: " );
	//for( ii=0; ii<Len; ii++ )
	//	SourceActor.DMTNS( ii $ " " $ DistanceList[ii].TargetActor $ " : " $ DistanceList[ii].Distance );
}

//-----------------------------------------------------------------------------
// Traces staight down and attempts to move the pawn to the hit location. If
// TargetActor is valid (can move NPC there and can build a path to the GoalActor
// from there or is actually within the specified GoalDistance from the 
// GoalActor), the NPC is left at TargetActor's location, otherwise its location
// will be unchanged when the call returns.

function EMoveType CheckNavigationFrom( Actor TargetActor, Actor GoalActor, float GoalDistance )
{
	local EMoveType ReturnedMoveType;
	local vector SavedLocation, TargetLocation;

	ReturnedMoveType = MT_None;
	
	if( TargetActor != None )
	{
		SavedLocation = Pawn.Location;

		TargetLocation = class'Util'.static.GetLocationAtActor( TargetActor, Pawn.CollisionRadius, Pawn.CollisionHeight );
		
		if( Pawn.SetLocation( TargetLocation ) )
		{
			ReturnedMoveType = GetPathTo( GoalActor, MoveTarget, GoalDistance ); 
			if( ReturnedMoveType != MT_Success && ReturnedMoveType != MT_Near )
			{
				Pawn.SetLocation( SavedLocation );
			}
			else
			{
				TeleportedPawn( SavedLocation, TargetActor );
			}
		}
	}

	return ReturnedMoveType;
}

//-----------------------------------------------------------------------------
// Searches in a 2d radius for navigation points and tries to teleport the
// npc there.  It checks first for navigation points that are of out of view
// of the player, but will resort to those in sight if necessary.
//
// !!mdf-tbd: CanSee seems to be a little too conservative (says player can see
// targets when these are actually out of range of peripheral vision)?

function EMoveType RecoverFromNavigationError( Actor GoalActor, float GoalDistance, bool bConsiderMoveTarget )
{
	local EMoveType ReturnedMoveType;
	local PlayerController PC;
	local Actor TargetActor;
	local int ii;
	local TDistanceInfo NPList[ MaxDistanceActors ];
	
	
	PC = Level.PlayerControllerList;
	if( PC == None )
		return MT_Wait; // player is dead so it don't matter...

	//DMTNS( "time since last rendered: " $ Level.TimeSeconds - Pawn.LastRenderTime );
		
	// if we've been rendered fairly recently (i.e. a player was looking at us) wait
	// (unless player is viewing through this NPC then go ahead and teleport...
	if( PC.ViewTarget != Self && PC.ViewTarget != Pawn && (Level.TimeSeconds - Pawn.LastRenderTime) < MinLastRenderedTeleportDelay )
	{
		//DMTNS( "rendered recently -- wait..." );
		return MT_Wait;
	}

	/*!!tbd: not needed?
	if( PC!=None && Pawn.PlayerCanSeeMe() )
		return MT_Wait;
	*/
	
	ReturnedMoveType = MT_None;

	if( bConsiderMoveTarget )
	{
		// first, try the move target if it's out of player's sight
		if( MoveTarget != None && !PC.CanSee( MoveTarget ) )
		{		
			//DMTNS( "trying MoveTarget: " $ MoveTarget $ " CanSee: " $ PC.CanSee( TargetActor ) );
			ReturnedMoveType = CheckNavigationFrom( MoveTarget, GoalActor, GoalDistance );
		}
		
		/* not sure about this -- if NPC is stuck pbly better to forge ahead and teleport
		   to some other location -- we've already established that the player isn't 
		   looking at the NPC itself above via LastRenderedTime.
		else
		{
			ReturnedMoveType = MT_Wait;
		}
		*/
	}
	
	//DMTNS( "ReturnedMoveType #1: " $ EnumStr( enum'EMoveType', ReturnedMoveType ) );
	if( ReturnedMoveType <= MT_None )
	{
		GetNearbyPathNodes( Pawn, NPList, MinTeleportRangeMoveError, MaxTeleportRangeMoveError, false );

		// try pathnodes out of player's sight
		//DMTNS( "try out of sight targets" );
		for( ii=0; ii<ArrayCount(NPList); ii++ )
		{
			TargetActor = NPList[ii].TargetActor;
			if( TargetActor == None )
				break;
				
			if( !PC.CanSee( TargetActor ) )
			{
				ReturnedMoveType = CheckNavigationFrom( TargetActor, GoalActor, GoalDistance );
				if( ReturnedMoveType == MT_Success || ReturnedMoveType == MT_Near )
					break;
				else
					NPList[ii].TargetActor = None; // no point considering this actor in the "can see" test below
			}
		}

		//DMTNS( "ReturnedMoveType #2: " $ EnumStr( enum'EMoveType', ReturnedMoveType ) );
		if( ReturnedMoveType <= MT_None )
		{
			//DMTNS( "try in sight targets" );
			// try pathnodes even if player can see them
			for( ii=0; ii<ArrayCount(NPList); ii++ )
			{
				TargetActor = NPList[ii].TargetActor;
				if( TargetActor == None )
					break;
					
				ReturnedMoveType = CheckNavigationFrom( TargetActor, GoalActor, GoalDistance );
				if( ReturnedMoveType == MT_Success || ReturnedMoveType == MT_Near )
					break;
			}
		}
	}

	//DMTNS( "ReturnedMoveType #3: " $ EnumStr( enum'EMoveType', ReturnedMoveType ) );
	
	return ReturnedMoveType;
}

//-----------------------------------------------------------------------------
	
function bool RecoverFromMinZError()
{
	local PlayerController PC;
	local Actor TargetActor;
	local vector TargetLocation;
	local int ii;
	local TDistanceInfo NPList[ MaxDistanceActors ];
	
	PC = Level.PlayerControllerList;
	if( PC == None )
		return false; // player is dead so it don't matter...
		
	GetNearbyPathNodes( Pawn, NPList, MinTeleportRangeMinZError, MaxTeleportRangeMinZError, true );
	
	// try pathnodes out of player's sight
	for( ii=0; ii<ArrayCount(NPList); ii++ )
	{
		TargetActor = NPList[ii].TargetActor;
		
		if( TargetActor == None )
			break;
			
		if( !PC.CanSee( TargetActor ) )
		{
			if( TeleportPawn( TargetActor ) )
			{
				return true;
			}
			else
			{
				NPList[ii].TargetActor = None; // no point considering this actor in the "can see" test below
			}
		}
	}

	// try pathnodes even if player can see them
	for( ii=0; ii<ArrayCount(NPList); ii++ )
	{
		TargetActor = NPList[ii].TargetActor;

		if( TargetActor == None )
			break;
			
		if( TeleportPawn( TargetActor ) )
			return true;
	}
	
	return false;
}

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

function bool RecoverFromStuckError()
{
	local PlayerController PC;
	local Actor TargetActor;
	local vector TargetLocation;
	local int ii;
	local TDistanceInfo NPList[ MaxDistanceActors ];
	
	PC = Level.PlayerControllerList;
	if( PC == None )
		return false; // player is dead so it don't matter...
		
	GetNearbyPathNodes( Pawn, NPList, MinTeleportRangeStuckError, MaxTeleportRangeStuckError, true );
	
	// only try pathnodes out of player's sight
	for( ii=0; ii<ArrayCount(NPList); ii++ )
	{
		TargetActor = NPList[ii].TargetActor;
		
		if( TargetActor == None )
			break;
			
		if( !PC.CanSee( TargetActor ) )
		{
			if( TeleportPawn( TargetActor ) )
			{
				return true;
			}
		}
	}
	
	return false;
}

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

function bool RandomizeStakeOutDir()
{
	return false;
}

//-----------------------------------------------------------------------------
// Pick a navigation point to look at that won't require looking too far away
// from the given TargetActor. Useful when staking out and waiting for the 
// enemy to appear, not terribly useful if using cover and about to go hunting
// to reacquire the enemy.

function FindNewStakeOutDir( Actor TargetActor )
{
	local NavigationPoint N, Best;
	local vector Dir, EnemyDir;
	local float Dist, BestVal, Val;

	EnemyDir = Normal( TargetActor.Location - Pawn.Location );
	for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
	{
		Dir = N.Location - Pawn.Location;
		Dist = VSize( Dir );
		if( Dist < 800 && Dist > 100 )
		{
			Val = ( EnemyDir dot Dir/Dist );

			if( RandomizeStakeOutDir() )
				Val += FRand();

			if( Val > BestVal && LineOfSightTo( N ) )
			{
				BestVal = Val;
				Best = N;
			}
		}
	}

	if( Best != None )
		EnemyDetected( Best.Location + 0.5 * Pawn.CollisionHeight * vect(0,0,1) );
}
	
//-----------------------------------------------------------------------------

function ClearMoveAttempts()
{
	NumMoveAttempts = 0;
	NumMoveRecoverAttempts = 0;
}

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

function bool MoveAgain()
{
	NumMoveAttempts++;
	return ( NumMoveAttempts < MaxMoveToActorAttempts );
}
	
//-----------------------------------------------------------------------------

function HoldSpot GetHoldSpot( Actor LocationActor )
{
	local HoldSpot HS;
	
	HS = LocationActor.Spawn( class'HoldSpot' );
	if( HS != None )
	{
		if( !HS.PhysicsVolume.bWaterVolume )
		{
			// !!mdf-tbd: make sure the hold spot is on the ground if the NPC can't
			// fly (in case LocationActor was above the ground)
			class'UtilGame'.static.PlaceActorOnFloor( HS );
		}
	}
	else
	{
		DMTN( "Warning: Can't create holdspot at given location" );
	}

	//DMTNS( "GetHoldSpot returning" $ HS );
	
	return HS;
}

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

function ClearHoldSpot( out Actor HS )
{
	//DMTNS( "ClearHoldSpot clearing " $ HS );
	
	if( HoldSpot(HS) != None )
	{
		HS.Destroy();
		HS = None;
	}
}

//-----------------------------------------------------------------------------
// Called when all holdspots associated with this controller should be 
// destroyed and cleared, e.g. when NPC dies.

function ClearHoldSpots()
{
	//DMTNS( "ClearHoldSpots" );
	ClearHoldSpot( TestMoveTarget );
}

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

function Actor GetSpecialGoal()
{
	if( SpecialGoal != None && SpecialGoal.bDeleteMe )
		SpecialGoal = None;

	return SpecialGoal;
}

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

function float GetSpecialGoalDistance()
{ 
	local float ReturnedDistance;
	
	if( TemporaryGoalDistance > 0.0 )
	{
		ReturnedDistance = TemporaryGoalDistance;
		TemporaryGoalDistance = -1.0;
	}
	else
	{
		ReturnedDistance = SpecialGoalDistance;
	}
	
	return ReturnedDistance; 
}

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

function bool GetFaceSpecialGoal()
{ 
	return bFaceSpecialGoal;
}

//-----------------------------------------------------------------------------
// Mover has notifies controller that Pawn is underneath it

function UnderLift( Mover M )
{
	local NavigationPoint N;

	// find nearest lift exit and go for that
	if( MoveTarget != None && LiftCenter(MoveTarget) != None )
		for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
			if( LiftExit(N) != None && ( LiftExit( N ).LiftTag == M.Tag )
				&& ActorReachable( N ) )
			{
				MoveTarget = N;
				return;
			}
}

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

function HandleDestinationReached()
{
	MoveTarget = None;
	Destination = Pawn.Location;
}

/* mdf-tbd: interface changed and base code does nothing now -- is this still needed?

//-----------------------------------------------------------------------------
// mdf-tbd: overridden so that NPCs won't duck until they actually hit 
// obstructions. tbd:

event PrepareForMove( NavigationPoint Goal, int MaxRadius, int MaxHeight ) --> event PrepareForMove(NavigationPoint Goal, ReachSpec Path);
{
	Goal.SuggestMovePreparation( Pawn );
}
*/

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

function bool ShouldClearSpecialColliders()
{
	return ( ControllerEnemy == None || StationaryPawn(ControllerEnemy) != None );
}

//-----------------------------------------------------------------------------
// Wrapper for FindPathToActor which calls ShouldClearSpecialColliders.

function EPathResult GetPathToActor( Actor TargetActor, optional out Actor ReturnedActor, optional bool bIncludeDirect )
{
	return FindPathToActor( 
			TargetActor,
			ReturnedActor,
			bIncludeDirect,
			true,
			ShouldClearSpecialColliders() );
}

//-----------------------------------------------------------------------------
// Sets Path to the given TargetActor if this is directly reachable, otherwise 
// tries to build a path to the target and sets Path to that.

function EMoveType GetPathTo( Actor TargetActor, out Actor Path, optional float GoalDistance )
{
	local EMoveType ReturnedMoveType;

	//2002.11.23 !!mdf-tbd: check if at destination even if no goal distance given?
	//if( GoalDistance > 0.0 && AtDestinationActor( TargetActor, GoalDistance ) )
  	//DMTNS( "GetPathTo -- " $ TargetActor $ " calling AtDestinationActor" );
	if( AtDestinationActor( TargetActor, GoalDistance ) )
	{
		ReturnedMoveType = MT_Near;
	}
	else
	{
	  	#debug DMAIM( "GetPathTo -- " $ TargetActor $ " calling GetPathToActor" );
		GetPathToActor( TargetActor, Path, true );
		if( Path != None )
			ReturnedMoveType = MT_Success;
		else
			ReturnedMoveType = MT_Error;
	}

  	#debug DMAIM( "GetPathTo -- Path: " $ Path );
	return ReturnedMoveType;
}

//-----------------------------------------------------------------------------
// Used when moving towards a destination which could be moving (e.g. when 
// following another Pawn) to check if "close" to destination.

function bool IsCloseToDynamicGoal( Actor Other, optional float DesiredDistance, optional bool bHasLineOfSightTo )
{
	local float PredictedDistance;
	local vector PredictedGoalLocation;
	local float PawnSpeed;

	if( Pawn.Base != None && Other.Base != None && Other.Base != Pawn.Base )
		return false;	

	if( DesiredDistance <= 0.0 )
		DesiredDistance = DefaultIsCloseToDynamicGoalDistance;
		
	// compensate for target moving: use predicted intercept location if possible, otherwise default to other's current location
	PawnSpeed = VSize( Pawn.Velocity );
	if( PawnSpeed ~= 0.0 || !class'UtilGame'.static.GetAimingDestination( Pawn, PawnSpeed, 0.0, Other, PredictedGoalLocation ) )
		PredictedGoalLocation = Other.Location;

	// note: DesiredDistance assumed to imply the 2D CC to CC distance
	PredictedDistance = VSize2D( Pawn.Location - PredictedGoalLocation ) - Pawn.CollisionRadius - Other.CollisionRadius;

	//DMTNS( "IsCloseToDynamicGoal  PredictedDistance: " $ PredictedDistance $ " DesiredDistance: " $ DesiredDistance );
	if( PredictedDistance > DesiredDistance )
		return false;

	// LOS to other?				
	return bHasLineOfSightTo || LineOfSightTo( Other );
}

/*-----------------------------------------------------------------------------
Try to move to within GoalDistance units of the GoalActor (with reachability)
if possible. Otherwise, move to the closest location from which the GoalActor 
can be seen. Don't bother moving if the move won't bring the NPC significantly 
closer to the GoalActor.

!!mdf-tbd: also check RouteCache distance so that NPC doesn't go "miles" out of
its way when it could stay where it is or move to a seeing (but not reachable)
location instead?
*/

function EMoveType GetMoveTargetFollow( Actor GoalActor, out Actor Path, float GoalDistance )
{
	local TDistanceInfo NPList[ MaxDistanceActors ];
	local Actor TargetActor;
	local EMoveType ReturnedMoveType;
	local EPathResult PathResult;
	local float CurDistance, NewDistance;
	local Actor FinalPath;
	local bool bHasLineOfSightTo;
	local int ii;
	
	#debug DMAIM( "GetMoveTargetFollow: " $ GoalActor );

	if( GoalActor != None )
	{
		bHasLineOfSightTo = LineOfSightTo( GoalActor );
		
		//2002.11.23 !!mdf-tbd: line of sight takes precendence over distance
		if( !bHasLineOfSightTo )
		{
			GoalDistance = FMin( MaxNoLOSFollowDistance, GoalDistance );
			TemporaryGoalDistance = GoalDistance;
		}
		
		//2002.11.23 !!mdf-tbd: I don't think that using the predicted location to
		//possibly return MT_Near (which will stop the NPC) makes sense
		//if( !IsCloseToDynamicGoal( GoalActor, GoalDistance, bHasLineOfSightTo ) )
		
		//DMTNS( "   GetMoveTargetFollow checking if at GoalActor " $ GoalActor $ " using distance " $ GoalDistance );
		if( AtDestinationActor( GoalActor, GoalDistance ) )
		{
			//DMTNS( "    close to " $ GoalActor );
			//	SendMessageNearPoint( GoalActor, 10.0 );
			ReturnedMoveType = MT_Near;
		}
		else 
		{
			// can we build a path to the goal?
			//DMTNS( "    Path should be None here: " $ Path );
			
			//ReturnedMoveType = GetPathToActor( GoalActor, Path, GoalDistance );
			PathResult = GetPathToActor( GoalActor, Path, true );
			//DMTNS( "    GetMoveTargetFollow Path: " $ Path $ " PathResult: " $ EnumStr( enum'EPathResult', PathResult ) );
			CurDistance = VSize( Pawn.Location - GoalActor.Location );

			//!!mdf-tbd: this is already being done more-or-less in FindPathToward...
			// hmm, not really -- seeing plenty of cases where GetPathTo fails where this can succeed?
			if( PathResult == PR_None && (CurDistance > CloseEnoughDistance || !bHasLineOfSightTo) )
			{
				// couldn't build a path to it -- try picking closest visible navigation point to target?
				//DMTNS( "    no path to " $ GoalActor $ " -- trying to build path to closest NP" );

				GetNearbyPathNodes( GoalActor, NPList, MinTeleportRangeMoveError, MaxTeleportRangeMoveError, false );

				for( ii=0; ii<Min(16, ArrayCount(NPList)); ii++ )
				{
					TargetActor = NPList[ii].TargetActor;
		
					if( TargetActor == None )
						break;

					// can our goal actor see the navigation point (not taking fov into account)						
					if( class'UtilGame'.static.ActorCanSeeActor( GoalActor, TargetActor, -1.0 ) )
					{
						// make sure we can get there (we know that GoalActor isn't currently pathable...)
						ReturnedMoveType = GetPathTo( TargetActor, Path, GoalDistance );
						if( Path != None )
						{
							PathResult = PR_Visible;
							break; // found one
						}
					}
				}
			}

			if( Path != None )
			{
				ReturnedMoveType = MT_Success;
					
				//DMTNS( "found path to " $ GoalActor $ ":" $ Path );
				FinalPath = Path;
				for( ii=0; ii<ArrayCount(RouteCache); ii++ )
				{
					if( RouteCache[ ii ] == None )
					{
						FinalPath = RouteCache[ ii-1 ];
						break;
					}
						
					//DMTNS( "  " $ ii $ ": " $ RouteCache[ ii ] );
				}

				//DMTNS( "checking if AtDestination " $ Path );
				//NOTE: we don't pass in the destination distance here since that is relative to the goal actor
				if(	AtDestinationActor( Path ) )
				{
					//DMTNS( "  yes" );
					ReturnedMoveType = MT_Wait;
				}
				else if( Path != GoalActor && FinalPath != GoalActor && PathResult < PR_Reachable )
				{
					//DMTNS( "  no" );
					
					NewDistance = VSize( FinalPath.Location - GoalActor.Location );
					
					//DMTNS( "CurDistance: " $ CurDistance );
					//DMTNS( "NewDistance: " $ NewDistance );
					
					if( (CurDistance < CloseEnoughDistance || (CurDistance - NewDistance) < GetCloserThreshold) && bHasLineOfSightTo )
					{
						// !!mdf-tbd: 
						// already fairly close to goal OR path won't bring NPC
						// that much close to goal and goal is currently visible, 
						// so just chill out at current location?
						ReturnedMoveType = MT_Wait;
					}
				}
			}
			else
			{
				// try again in a bit
				// /*~~*/ !!mdf-tbd: what to do now...?
				// NOTE: we could try finding the closest reachable/pathable location
				// but this could be expensive -- lets see how well this works for now
				// teleport?
				// if there is no pathnode (anchor) around the NPC, we pbly need to teleport him...
				//DMTNS( " found no Path to " $ GoalActor );
				ReturnedMoveType = MT_Wait;
			}
		}
	}

	#debug DMAIM( "GetMoveTargetFollow returning Path: " $ Path $ " ReturnedMoveType: " $ EnumStr( enum'EMoveType', ReturnedMoveType ) );
	//DMTNS( "GetMoveTargetFollow returning Path: " $ Path $ " ReturnedMoveType: " $ EnumStr( enum'EMoveType', ReturnedMoveType ) );

	return ReturnedMoveType;
}

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

function EMoveType HandleSetMoveTargetError( Actor GoalActor, float GoalDistance )
{
	local EMoveType ReturnedMoveType;

	NavigationError( ET_ExternalPath, "SetMoveTarget -- can't build path to destination " $ GoalActor );
			
	// try to recover by teleporting
	if( UnderScriptControl() )
	{
		U2P.MakeErrorObvious( ET_ExternalPath );
		if( !U2P.bDisableErrorColors )
			AddActor( Pawn, ColorBlue() );
		ReturnedMoveType = RecoverFromNavigationError( GoalActor, GoalDistance, false );
		if( !U2P.bDisableErrorColors && (ReturnedMoveType == MT_Success || ReturnedMoveType == MT_Near) )
			AddCylinder( Pawn.Location, 4, 4, ColorBlue() );
	}
	else
	{
		U2P.MakeErrorObvious( ET_InternalPath );
	}
	
	return ReturnedMoveType;
}

//-----------------------------------------------------------------------------
// mdf-tbi: generalize this and similar functions (all pathing/movement).

function EMoveType SetMoveTarget( Actor GoalActor, optional float GoalDistance, optional bool bWaitForLanding )
{
	local Actor OldMoveTarget;
	local EMoveType ReturnedMoveType;

//  	DMN( "Physics: " $ class'Util'.static.GetPhysicsString( Self ) );
//  	DMN( "Radius: " $ Pawn.CollisionRadius );
//  	DMN( "Height: " $ Pawn.CollisionHeight );

	#debug DMAIM( "SetMoveTarget GoalActor:" $ GoalActor );

	OldMoveTarget = MoveTarget;

	#debugbegin
	if( bVisibleAI )
		HideActor( MoveTarget );
	#debugend

	ReturnedMoveType = MT_None;

	MoveTarget = None;
	if( GoalActor != None && !GoalActor.bDeleteMe )
	{
		if( bWaitForLanding && !GoalActor.bStatic && GoalActor.Physics == PHYS_Falling )
		{
			//DMTNS( "  SetMoveTarget: goal is falling!" );
			ReturnedMoveType = MT_Wait;
		}
		else if( Pawn(GoalActor) == None )
		{
			//DMTNS( "  SetMoveTarget: goal is a non-Pawn!" );
			ReturnedMoveType = GetPathTo( GoalActor, MoveTarget, GoalDistance );
		}
		else
		{
			//DMTNS( "  SetMoveTarget: goal is a Pawn!" );
			ReturnedMoveType = GetMoveTargetFollow( GoalActor, MoveTarget, GoalDistance );
		}
		
		// testing support
		if( U2P.bCauseMoveTargetNavError )
		{
			#debug DMAIM( "testing navigation error recovery -- causing the move target to be MT_Error" );
			U2P.bCauseMoveTargetNavError = false;
			ReturnedMoveType = MT_Error;
		}

		if( ReturnedMoveType == MT_Error )
			ReturnedMoveType = HandleSetMoveTargetError( GoalActor, GoalDistance );
		
		if( ReturnedMoveType != MT_Error )
		{
			// MoveTarget might be none if already at / near goal
			#debugbegin
			if( bVisibleAI && MoveTarget != None )
				ShowActor( MoveTarget  );
			#debugend
			
			// mdf-tbd: isn't it safer to reset NumMoveAttempts at BeginLabel?
			// NO -- NumMoveAttempts also needs to be reset here everytime the MoveTarget 
			// changes since it is used to limit # times NPC tries to reach a given target.
			// We clear NumMoveAttempts here since any call to MoveToActor is preceeded with a 
			// call to SetMoveTarget but we should also clear it whenever a new (final)
			// destination is specified in case the new and old MoveTarget happen to match
			if( ReturnedMoveType == MT_Wait || MoveTarget != OldMoveTarget || VSize( Pawn.Location - OldMoveLocation ) > Pawn.CollisionRadius )
				ClearMoveAttempts();

			OldMoveLocation = Pawn.Location;
			
			//2002.12.11 (mdf) why was I doing this? -- Destination is always set during/near
			//calls to MoveTarget etc. and shouldn't be set otherwise?
			/*
			if( MoveTarget != None )
				Destination = MoveTarget.Location;
			else
				Destination = Pawn.Location;
			*/
			
			//2002.12.11 (mdf) why was I doing this? -- Focus is always set during/near
			//calls to MoveToward etc. and setting it here is borking turntoactor because
			//NPC might try to turn to an actor that its already facing.
			/*
			// determines which movement animation is used
			if( ScriptedFocus == None )
			{
				if( Focus == None )
					Focus = GoalActor; //?
				else
			 		Focus = MoveTarget;
			}
			else
		 		Focus = ScriptedFocus;
		 	*/
		}
	}

	// NOTE (mdf): we still return MT_None if given GoalActor was None (orders rescinded?) which will be treated
	// as an error by callers -- should callers not be flagging an error in this case?
	#debug DMAIM( "SetMoveTarget returning MoveTarget: " $ MoveTarget $ " ReturnedMoveType: " $ EnumStr( enum'EMoveType', ReturnedMoveType ) );
	return ReturnedMoveType;
}

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

function bool SetTestMoveTarget( Actor TargetActor, optional float MoveSpeed, optional ETacticalMoveType TMT )
{
	local bool bResult;
	local Actor NewMoveTarget;

	NewMoveTarget = TargetActor;
	if( Controller(TargetActor) != None )
		NewMoveTarget = Controller(TargetActor).Pawn;

	if( Pawn(NewMoveTarget) != None )
		NewMoveTarget = GetHoldSpot( NewMoveTarget );

	if( NewMoveTarget != None )
	{
		NewMoveTarget.bHidden = false;
		GotoState( TestMoveState );
		bResult = true;
	}
	else if( TargetActor != None )
	{
		#debug DMAI( "SetTestMoveTarget failed: " $ GetContext() );
	}
	else
	{
		#debug   WhatToDoNext( GetContext() );
		#release WhatToDoNext();
		bResult = true;
	}

	#debug DMAIM( "SetTestMoveTarget - bResult: " $ bResult $ " NewMoveTarget: " $ NewMoveTarget );
	if( bResult )
	{
		ClearHoldSpot( TestMoveTarget );
		TestMoveTarget = NewMoveTarget;
		if( MoveSpeed <= 0.0 )
			MoveSpeed = 1.0;
		TestMoveSpeed = MoveSpeed;
		TestTacticalMoveType = TMT;
	}

	return bResult;
}

//-----------------------------------------------------------------------------
/* Assumes the desired destination is not directly reachable. Tries to set 
Destination to the location of the best waypoint, and returns true if successful.
*/

function bool FindBestPathToward( Actor TargetActor, bool bClearPaths )
{
	local Actor Path;
	local bool bSuccess;
	
	FindPathToActor( TargetActor, Path, false, bClearPaths, ShouldClearSpecialColliders() );
		
	bSuccess = ( Path != None );	
	if( bSuccess )
	{
		/*
		AddActor( Pawn, ColorOrange() );
		AddActorAt( Pawn, MoveTarget.Location, ColorOrange() );
		AddArrow( Pawn.Location, MoveTarget.Location, ColorOrange() );
		*/
		
		MoveTarget = Path; 
		Destination = Path.Location;
	}	
	return bSuccess;
}	

//-----------------------------------------------------------------------------
// Find an inventory spot destination.

function NavigationPoint SelectInventorySpotDestination()
{
	local NavigationPoint N, ReturnedInventorySpot;
	local int ii;

	if( Pawn.bCanPickupInventory )
	{
		ii = 0;
		for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
		{
			//NEW (mdf) -- temp (?) fix for massive terrain slowdown when tracing/pathing over large distances
			//if( InventorySpot(N) != None && VSize(Pawn.Location - N.Location) < 1200 )
			//OLD
		  	if( InventorySpot(N) != None )
			{
				//mdf-tbd: is this really what is wanted here -- this has a 50% chance
				//of sticking with the first IS. The odds of ever picking the last IS are
				//going to be something like 0.5 * 0.33 * 0.25 * ... Does this give even 
				// odds to all inventory spots?
				ii++;
				if( ReturnedInventorySpot == None || Rand( ii ) == 0 )
					ReturnedInventorySpot = N;
			}
		}
		#debug DMAIM( "SelectInventorySpotDestination iterated InventorySpots: " $ ReturnedInventorySpot );
	}

	if( ReturnedInventorySpot == None )
	{
		#debug DMAIM( "SelectInventorySpotDestination ReturnedInventorySpot=" $ ReturnedInventorySpot );
	}
	else
	{
		#debug DMAIM( "SelectInventorySpotDestination ReturnedInventorySpot=" $ ReturnedInventorySpot $ " Dist=" $ VSize(Pawn.Location - ReturnedInventorySpot.Location));
	}

	return ReturnedInventorySpot;
}

//-----------------------------------------------------------------------------
// Force NPCs to either not get their move targets, or fail to reach their
// destinations

function ForceNavigationError( bool bScriptedStateMoves, bool bMoveTarget, bool bMinZ )
{
	if( U2P != None )
	{
		U2P.bCauseMoveTargetNavError = false;
		U2P.bCauseScriptedNavError = false;
	
		if( bMinZ )
		{
			U2P.FellOutOfWorld();
		}
		else
		{	
			U2P.bCauseMoveTargetNavError = bMoveTarget;
			U2P.bCauseScriptedNavError = bScriptedStateMoves;
			MoveTimer = -1.0;
		}
	}
}

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

function bool SplashDamageAttack() { return false; }
function ImpalePawn();
function UnImpalePawn();
function NotifyMeleeDamagedEnemy( int Damage, Pawn Instigator, vector HitLocation, vector Momentum, class<DamageType> DamageType );

//-----------------------------------------------------------------------------
// Given that we have an enemy and we are updating the attack behavior, check
// for things like the enemy being too close to remain in the current stance or
// to remain immobile.

function CheckEnemyDistance( float EnemyDistance )
{
	local byte CurrentStance;

	VerifyMobility( EnemyDistance );

	// maybe change stance due to enemy being too close?
	CurrentStance = LPawn.GetStance();
	UpdateStance( CurrentStance, EnemyDistance );
}

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

function float GetLookedAtCos( Actor SeeingActor )
{
	if( Pawn(SeeingActor) != None )
		return Pawn(SeeingActor).PeripheralVision;
	else
		return U2PBasic.DefaultLookedAtCos;
}

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

function vector GetFireOffset( vector SourceLocation, vector TargetLocation )
{
	return class'UtilGame'.static.GetRotatedFireStart( Pawn, SourceLocation, rotator(TargetLocation - SourceLocation), U2PBasic.FireOffset );
}

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

function bool IgnoreTargetRange() { return false; }

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

function bool CheckMaxAttackRanges( float EnemyDistance, Actor TargetActor )
{
	//!!mdf-tbd: add special checks for TargetActor being a stationary Pawn?		
	if( IsMobile() )
	{
		if( U2PBasic.RangeMaxAttackMobileNoLOS == U2PBasic.RangeMaxAttackMobile || class'UtilGame'.static.ActorLookingAt( TargetActor, Pawn, GetLookedAtCos( TargetActor ) ) )
			return ( EnemyDistance <= U2PBasic.RangeMaxAttackMobile );
		else
			return ( EnemyDistance <= U2PBasic.RangeMaxAttackMobileNoLOS );
	}
	else
	{
		if( U2PBasic.RangeMaxAttackStationaryNoLOS == U2PBasic.RangeMaxAttackStationary || class'UtilGame'.static.ActorLookingAt( TargetActor, Pawn, GetLookedAtCos( TargetActor ) ) )
			return ( EnemyDistance <= U2PBasic.RangeMaxAttackStationary );
		else
			return ( EnemyDistance <= U2PBasic.RangeMaxAttackStationaryNoLOS );
	}
}

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

function bool CheckTargetInAttackRange( bool bTest )
{
	local float EnemyDistance;
	local Actor TargetActor;
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	local bool bResult;
	
	TargetActor = GetTarget();
	if( Pawn == None || TargetActor == None )
	{
		bResult = false;
	}
	else if( IgnoreTargetRange() )
	{
		bResult = true;
	}
	else if( U2PBasic.RangeMinAttack > 0.0 || U2PBasic.bHasMaxAttackRanges )
	{			
		bResult = true;
		
		//if( !bTest )
		//	DMTNS( "CheckTargetInAttackRange TargetActor: " $ TargetActor );
	
		// NOTE: we don't even need to do this trace if there are no active force fields in the level...
		if( Level.HasSpecialColliders() )
		{
			// see if firing through an enemy XMP item?
			HitActor = Pawn.Trace( HitLocation, HitNormal, TargetActor.Location, GetFireOffset( Pawn.Location, TargetActor.Location ), true );

			if( HitActor != None && 
				HitActor != TargetActor && 
				!HitActor.bWorldGeometry && 
				!HitActor.bStatic &&
				// could be a ForceWallCollider? StationaryPawn(HitActor) != None &&
				OKToHit( HitActor, HitLocation, HitNormal ) )
			{
				//if( !bTest )
				//	DMTNS( "  trace hit " $ HitActor );
				//TargetActor = HitActor;
				// !!mdf-tbd: temp hack fix so NPCs will always shoot at an enemy through a force field
				// regardless of the distance. What we *should* pbly be doing here is changing the TargetActor and
				// using the distance to that but there are other issues -- the izarians won't close properly 
				// currently (pbly applies to other NPCs too). I'll check this hack fix in then look into the
				// other issues.
				TargetActor = None;
			}
		}
						
		if( TargetActor != None )
		{
			EnemyDistance = VSize( TargetActor.Location - Pawn.Location );
			
			if( EnemyDistance < U2PBasic.RangeMinAttack )
			{
				bResult = false;
			}
			else if( U2PBasic.bHasMaxAttackRanges )
			{
				bResult = CheckMaxAttackRanges( EnemyDistance, TargetActor );
			}
		}
	}
	else
	{
		bResult = true;
	}
	
	//if( !bTest )
	//	DMTNS( "CheckTargetInAttackRange bResult: " $ bResult );
	
	return bResult;
}

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

function UpdateAcceleration( Actor TargetActor, float AccelerationChangeLimit, float MeleeAccelRate, float MeleeSpeed )
{
	local vector OldAccelerationNormal, NewAccelerationNormal;
	local vector Axis;
	local float CosAngle;
	
	if( TargetActor != None && VSize( TargetActor.Velocity ) > 10.0 )
	{
		OldAccelerationNormal = Normal( Pawn.Acceleration );
		NewAccelerationNormal = Normal( TargetActor.Location - Pawn.Location );
		CosAngle = NewAccelerationNormal dot OldAccelerationNormal;
		
		if( Abs(CosAngle) < AccelerationChangeLimit )
		{
			// constrain acceleration change
			Axis = Normal( OldAccelerationNormal cross NewAccelerationNormal );
			NewAccelerationNormal = Normal( RotateAngleAxis( OldAccelerationNormal, Axis, ACos(AccelerationChangeLimit)*RadiansToDegrees*DegreesToRotationUnits ) );
		}

		// apply new acceleration
		if( MeleeAccelRate <= 0.0 )
			MeleeAccelRate = Pawn.default.AccelRate;
			
		Pawn.Acceleration = MeleeAccelRate * NewAccelerationNormal;
/*				
		if( MeleeSpeed > 0.0 )\
			Pawn.Velocity =  MeleeSpeed * Normal(Pawn.Velocity) * Pawn.default.GroundSpeed;
*/			
	}
	else if( Pawn.Physics == PHYS_Walking )
		StopMovement( true, false ); // don't push-move around a more-or-less stationary target if walking
		
	//DMTNS( "UpdateAcceleration  Speed: " $ VSize( Pawn.Velocity ) $ " Acceleration: " $ VSize( Pawn.Acceleration ) );
}

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

function float GetAttackRating( Pawn Other )
{
	return 0.3; // mdf-tbd: add property for this for tweaking various basic NPCs
}

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

function float GetFireRating()
{
	return 0.3;
}

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

function bool CanDodge( optional bool bIgnoreFalling )
{
	return ( U2PBasic != None &&
			 Level.TimeSeconds > DodgeEnableTime &&
			 U2PBasic.IsStanding() &&
			 U2PBasic.Health > 0 &&
			 (U2PBasic.Physics == PHYS_Walking || (bIgnoreFalling && U2PBasic.Physics == PHYS_Falling)) );
}	

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

function ExecuteDodge( bool bLeft, vector DodgeDestination )
{
	//DMTNS( "ExecuteDodge bLeft: " $ bLeft $ " Distance: " $ VSize( DodgeDestination - Pawn.Location ) );
	//AddArrow( Pawn.Location, DodgeDestination, ColorGreen() );
	
	U2PBasic.DodgeDestination = DodgeDestination;
	Destination = Pawn.Location;
	MoveTarget = None;
	
	if( bLeft )
		U2P.Dodge( DCLICK_Left, U2PBasic.bJumpDodges );
	else
		U2P.Dodge( DCLICK_Right, U2PBasic.bJumpDodges );
}

//-----------------------------------------------------------------------------
// !!mdf-tbd: this still seems like a pretty flaky test if the NPC is on uneven
// ground for example.
// NOTE: hard-coded currently to try dodging between 150 and 240 units.

function bool VerifyJumpDodgeVector( vector DuckDir, out vector DodgeDestination )
{
	local vector HitLocation, HitNormal, Extent;
	local Actor HitActor;
	local float HitDistance;

	Extent.X = Pawn.CollisionRadius;
	Extent.Y = Pawn.CollisionRadius;
	Extent.Z = Pawn.CollisionHeight;
	
	DodgeDestination = Pawn.Location + U2PBasic.DodgeDistance*DuckDir;
	//AddArrow( Pawn.Location, DodgeDestination );
	HitActor = Pawn.Trace( HitLocation, HitNormal, DodgeDestination, Pawn.Location, false, Extent );

	if( HitActor != None )
	{
		//AddCylinder( HitLocation, 4, 4, ColorRed() );
		HitDistance = VSize( HitLocation - Pawn.Location );
		//DMTNS( "VerifyJumpDodgeVector hit " $ HitActor $ "Distance: " $ VSize( HitLocation - Pawn.Location ) );

		if( HitDistance < 150 )
		{
			//DMTNS( "VerifyJumpDodgeVector return false " $ GetContext() );
			return false;
		}
			
		DodgeDestination = Pawn.Location + HitDistance*DuckDir;
	}
	
	// make sure didn't dodge off a ledge
	HitActor = Pawn.Trace( HitLocation, HitNormal, DodgeDestination - Pawn.MaxStepHeight * vect(0,0,1), DodgeDestination, false, Extent );
	if( HitActor == None )
	{
		//DMTNS( "VerifyJumpDodgeVector return false " $ GetContext() );
		return false;
	}
	
	return true;
}

//-----------------------------------------------------------------------------
// We will use MoveToPoint to move the cylinder so do a reachability test.
// !!mdf-tbd: should we always use this test?

function bool VerifyRollDodgeVector( vector DuckDir, out vector DodgeDestination )
{
	local vector HitLocation, HitNormal, Extent;
	local Actor HitActor;
	local bool bOldCanJump;
	local bool bResult;
	
	// assume that the ground is sloped at no more than 45 degrees and find
	// point above ground where NPC should end up
	DuckDir.Z = 0;
	DodgeDestination = Pawn.Location + U2PBasic.DodgeDistance*DuckDir;
	
	// move up by same amount + padding
	DodgeDestination.Z += 1.25*U2PBasic.DodgeDistance;
	
	// trace down until we hit the ground (allow for ground falling away)
	//!!mdf-tbd: use extents? -- pbly best to expose MoveActor
	HitActor = Pawn.Trace( HitLocation, HitNormal, DodgeDestination - vect(0,0,1024), DodgeDestination, false );
	if( HitActor == None )
		return false;
		
	DodgeDestination = HitLocation + vect(0,0,1) * Pawn.CollisionHeight;
	//AddCylinder( DodgeDestination, 4, 4, ColorMagenta() );
	
	bOldCanJump = Pawn.bCanJump;
	Pawn.bCanJump = false;
	bResult = PointReachable( DodgeDestination );
	Pawn.bCanJump = bOldCanJump;
	
	return bResult;
}

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

function TryToDodge( vector DuckDir, bool bDuckLeft )
{
	local vector DodgeDestination;
	local bool bSuccess;

	//DMTNS( "TryToDodge" );
	if( Pawn.PhysicsVolume.bWaterVolume || Pawn.PhysicsVolume.Gravity.Z > Pawn.PhysicsVolume.default.Gravity.Z )
	{
		//DMTNS( "TryToDodge return " $ GetContext() );
		return;
	}
	
	// try in desired direction
	if( U2PBasic.bJumpDodges )
		bSuccess = VerifyJumpDodgeVector( DuckDir, DodgeDestination );
	else
		bSuccess = VerifyRollDodgeVector( DuckDir, DodgeDestination );
	
	if( !bSuccess )
	{
		// try in opposite direction
		
		//DMTNS( "  failed -- reverse direction" );
		bDuckLeft = !bDuckLeft;
		DuckDir *= -1;
		if( U2PBasic.bJumpDodges )
			bSuccess = VerifyJumpDodgeVector( DuckDir, DodgeDestination );
		else
			bSuccess = VerifyRollDodgeVector( DuckDir, DodgeDestination );
		
		if( !bSuccess )
		{
			//DMTNS( "TryToDodge return " $ GetContext() );
			return;
		}
	}
	
	//DMTNS( "calling ExecuteDodge" );
	ExecuteDodge( bDuckLeft, DodgeDestination );
}

//-----------------------------------------------------------------------------
// Assumes IncomingDirection is normalized.

function HandleIncoming( Actor IncomingActor, vector IncomingDirection, float IncomingSpeed )
{
	local vector PawnToIncomingVector, PawnToIncomingNormal, LeftVector;
	local vector FuturePawnPosition, FutureIncomingPosition;
	local float IncomingDistance, FutureMissDistance;
	local float ApproximateIntersectTime, CosToIntersect;
	local bool bDodgeRight;
	
	//AddCylinder( IncomingActor.Location, 4, 4, ColorRed() );
	//DMTNS( "HandleIncoming : " $ IncomingActor $ " projectile speed: " $ IncomingSpeed $ " Pawn speed: " $ VSize( Pawn.Velocity ) );

	if( U2PBasic == None || !FDecision( U2PBasic.DodgeProjectileOdds ) )
		return; // doesn't dodge incoming projectiles

	if( !CanDodge() )
		return;

	/* tbd:
	if( GetSkill() < FRand() )
		return;
	*/

	PawnToIncomingVector = IncomingActor.Location - Pawn.Location;
	
	//tbd: what's the best approach, add properties for all of these,
	//support dodging by ducking, jumping up etc.
	PawnToIncomingNormal = Normal( PawnToIncomingVector );

	if( PawnToIncomingNormal dot vector(Pawn.Rotation) < 0.10 ) 
	{
		//DMTNS( "NPC not facing incoming" );
		return; // NPC isn't looking enough towards incoming actor
	}

	// if close/fast decrease odds of reacting
	IncomingDistance = VSize( PawnToIncomingVector );
	//DMTNS( "IncomingDistance: " $ IncomingDistance );

	// see if projectile is likely to hit NPC
	// assumes projectile speed much higher than NPC speed and assumes NPC won't change velocity
	ApproximateIntersectTime = IncomingDistance / VSize( IncomingSpeed*IncomingDirection - Pawn.Velocity );
	
	// where will projectile, NPC be at that time?
	FuturePawnPosition = Pawn.Location + ApproximateIntersectTime * Pawn.Velocity;
	FutureIncomingPosition = IncomingActor.Location + ApproximateIntersectTime * IncomingDirection * IncomingSpeed;
	
	//AddCylinder( FuturePawnPosition, 6, 6, ColorCyan() );
	//AddCylinder( FutureIncomingPosition, 8, 8, ColorOrange() );
	
	FutureMissDistance = VSize( FuturePawnPosition - FutureIncomingPosition );
	//DMTNS( "FutureMissDistance: " $ FutureMissDistance );

	if( FutureMissDistance < (FMax( Pawn.CollisionRadius, Pawn.CollisionHeight ) + INCOMINGCOLLISIONFUDGE) )
	{	
		// tbd: decrease odds as angle to actor relative to NPC's view direction increases
				
		LeftVector = Normal( vector(Pawn.Rotation) cross vect(0,0,1) );

		//AddArrow( Pawn.Location, FutureIncomingPosition, ColorRed() );
		//AddArrow( Pawn.Location, Pawn.Location + 256.0*LeftVector, ColorGreen() );
		//AddArrow( Pawn.Location, Pawn.Location + 256.0*vector(Pawn.Rotation), ColorYellow() );
		
		CosToIntersect = Normal( FutureIncomingPosition - Pawn.Location) dot LeftVector;
		//DMTNS( "Cos: " $ CosToIntersect );
		
		bDodgeRight = false;
		if( CosToIntersect < -0.1 )
			bDodgeRight = true; // intercept point to right
		else if( CosToIntersect < 0.1 && FRand() < 0.50 )
			bDodgeRight = true; // intercept point not to left
		
		//DMTNS( "  calling TryToDodge: " $ bDodgeRight );
		if( bDodgeRight ) // note: LeftVector is wrt Pawn, TryToDodge uses wrt viewer in front of NPC
			TryToDodge( LeftVector, false );
		else
			TryToDodge( -LeftVector, true );
	}
}

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

function ShotFiredNotification( Pawn Shooter, vector FireDir, class<Projectile> ProjectileClass, float ProjSpeed )
{
	HandleIncoming( Shooter, Normal( FireDir ), ProjSpeed );
}

//-----------------------------------------------------------------------------
// Returns true if NPC should face enemy/target while heading towards next 
// MoveTarget based on how recently the enemy was seen and whether the NPC is 
// ready to fire etc.

function bool FaceTarget( float F )
{
	local float RelativeDir;
	local float TimeSinceEnemyLastSeen;
	
	if( !Pawn.bCanStrafe )
		return false;
		
	TimeSinceEnemyLastSeen = GetTimeSinceEnemyLastSeen();
	
	if( TimeSinceEnemyLastSeen > 7.5 - F )
		return false;

	//2002.12.18 (mdf) NPCs having trouble attacking turrets because they aren't facing them?
	//Why would we ever not want them to face an enemy just because its a StationaryPawn which isn't in sight?
	//if( !IsPreparedToAttack( true ) || ControllerEnemy == None || (StationaryPawn(ControllerEnemy) != None && !LineOfSightTo( ControllerEnemy )) )
	if( !IsPreparedToAttack( true ) || ControllerEnemy == None )
		return false;

	if( GetSkill() > 0.75 && IsPreparedToFire( true ) )
		return true;

	if( TimeSinceEnemyLastSeen > 4 - F )
		return false;

	RelativeDir = Normal( ControllerEnemy.Location - Pawn.Location - vect(0,0,1) * (ControllerEnemy.Location.Z - Pawn.Location.Z) ) 
			dot Normal( MoveTarget.Location - Pawn.Location - vect(0,0,1) * (MoveTarget.Location.Z - Pawn.Location.Z) );

	if( RelativeDir > NeedToTurnAngleCos )
		return true;

	if( IsPreparedToMelee( true ) && RelativeDir < 0 )
		return false;

	if( FRand() < 0.2 * (2 - F) )
		return true;

	if( 0.5 * 8*GetSkill() - F * FRand() + RelativeDir + 0.6 + U2PBase.StrafingAbility < 0 )
		return false;

	return true;
}

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

function bool NeedToTurn( vector TargetLocation, float CosAngle )
{
	local vector LookDir, AimDir;

	LookDir = vector(Pawn.Rotation);
	LookDir.Z = 0;
	LookDir = Normal( LookDir );
	AimDir = TargetLocation - Pawn.Location;
	AimDir.Z = 0;
	AimDir = Normal( AimDir );

	#debug DMAIA( "NeedToTurn: " $ TargetLocation $ " returning " $ ((LookDir dot AimDir) < CosAngle) );

	return ((LookDir dot AimDir) < CosAngle);
}

//-----------------------------------------------------------------------------
// Returns true if there is a nearby barrier at eyeheight, and changes 
// FocalPoint to a suggested place to look.

function bool ViewObstructed( float CheckWallDistance )
{
	local Actor HitActor;
	local vector HitLocation, HitNormal, ViewSpot, ViewDist, LookDir;

	if( Pawn == None )
		return false;

	LookDir = vector( Rotation );
	ViewSpot = Pawn.Location + Pawn.BaseEyeHeight * vect(0,0,1);
	ViewDist = LookDir * CheckWallDistance; 
	HitActor = Pawn.Trace( HitLocation, HitNormal, ViewSpot + ViewDist, ViewSpot, false );
	if( HitActor == None )
		return false;

	ViewDist = Normal( HitNormal cross vect(0,0,1) ) * CheckWallDistance;
	if( FRand() < 0.5 )
		ViewDist *= -1;

	Focus = None;
	if( Pawn.FastTrace( ViewSpot + ViewDist, ViewSpot ) )
	{
		FocalPoint = Pawn.Location + ViewDist;
		return true;
	}

	if( Pawn.FastTrace( ViewSpot - ViewDist, ViewSpot ) )
	{
		FocalPoint = Pawn.Location - ViewDist;
		return true;
	}

	FocalPoint = Pawn.Location - LookDir * 300;
	return true;
}

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

function final SetSharedTimer( float DelaySeconds, bool bLoop )
{
	#debug DMAIA( "SetSharedTimer -- DelaySeconds: " $ DelaySeconds $ " bLoop: " $ bLoop );
	SetTimer( DelaySeconds, bLoop );
}

//-----------------------------------------------------------------------------
// This should never be called for the new AI. Overridden to not assert for 
// the old AI since this still makes use of global shared timers.

function SharedTimerEvent()
{
	#debug DMAIA( "SharedTimerEvent" );
	DMAssert( false, GetContext() $ " Global.SharedTimerEvent called -- should never happen" );
}

/*-----------------------------------------------------------------------------
The (new) AI code doesn't generally make use of the global timer, preferring
instead to use AddTimer to map timers to specific functions. In a few cases,
its convenient to simply use a global timer within a specific state (the timer 
should be cleared before leaving that state). If the above global 
SharedTimerEvent gets called (because a state didn't clean up after itself), an
assertion will be logged (the old AI won't assert).
*/

event final Timer()
{
	SharedTimerEvent();
}

//-----------------------------------------------------------------------------
//@ AIMING
//-----------------------------------------------------------------------------

function bool TryToHit( 
	Actor TargetActor, 
	float TargetDistance,
	float SpreadDegrees,
	bool bLOSToTarget, 
	float TryToHitBaseOddsMin, 
	float TryToHitBaseOddsMax, 
	float TryToHitBaseDistance, 
	float TryToHitMinMissDistance, 
	float TryToHitMaxHitDistance )
{
	local Actor HitActor;
	local vector HitNormal, HitLocation;
	local int ii;
	local bool bFoundBlockingActors, bResult;

	//bResult = true; goto skipcheck; // uncomment to always try to hit for testing
	//bResult = false; goto skipcheck; // uncomment to always try to miss for testing
	
	// first check for any smoke etc. in the way
	bTargetObscured = false;
	if( bLOSToTarget )
	{
		// flip trace flags temporarily so a trace will hit CoverProxy actors
		for( ii=0; ii<Level.CoverActorList.Length; ii++ )
		{
			if( CoverProxy(Level.CoverActorList[ ii ]) != None )
			{
				Level.CoverActorList[ ii ].SetCollision( true, true, true );
				bFoundBlockingActors = true;
			}
		}
		
		if( bFoundBlockingActors )
		{
			// do the trace
			//AddArrow( Pawn.Location, TargetActor.Location, ColorOrange() );
			HitActor = Pawn.Trace( HitLocation, HitNormal, TargetActor.Location, Pawn.Location, true );
			bTargetObscured = (CoverProxy(HitActor) != None );

			//!!mdf-tbr:
			//assert( bTargetObscured || HitActor == None || HitActor == TargetActor );
			
			// restore trace flags temporarily so a trace will hit CoverProxy actors
			for( ii=0; ii<Level.CoverActorList.Length; ii++ )
			{
				if( CoverProxy(Level.CoverActorList[ ii ]) != None )
				{
					Level.CoverActorList[ ii ].SetCollision( false, false, false );
				}
			}
		}
	}

	//DMTNS( "Blocked by smoke: " $ bTargetObscured );
		
	if( bTargetObscured )
	{
		bResult = FDecision( BlockedByCoverHitOdds );
	}
	else
	{
		bResult =
			class'UtilGame'.static.TryToHit(
				Pawn,
				TargetActor, 
				TargetDistance, 
				SpreadDegrees,
				Pawn.LastPainAnimTime,
				MaxAffectedByHitTime,
				LastAcquireTime,
				MaxAffectedByAcquisitionTime,
				TryToHitBaseOddsMin, 
				TryToHitBaseOddsMax, 
				TryToHitBaseDistance, 
				TryToHitMinMissDistance, 
				TryToHitMaxHitDistance,
				TryToHitBaseSpeed,
				TryToHitBaseSpeedOdds );
	}

skipcheck:
#debugbegin
	/*
	if( bResult )
	{
		Hits++;
		DMT( "Hits: " $ class'Util'.static.PadString( Hits, 4, true ) $ " Misses: " $ class'Util'.static.PadString( Misses, 4, true ) $ " (" $ class'Util'.static.GetFloatString( float(Hits)/float(Hits+Misses), 3 ) $ ")    hit!" );
	}
	else
	{
		Misses++;
		DMT( "Hits: " $ class'Util'.static.PadString( Hits, 4, true ) $ " Misses: " $ class'Util'.static.PadString( Misses, 4, true ) $ " (" $ class'Util'.static.GetFloatString( float(Hits)/float(Hits+Misses), 3 ) $ ")    miss!" );
	}
	*/
#debugend			
	return bResult;
} // TryToHit

/*-----------------------------------------------------------------------------
ProjStart:				location from which shot will be fired
ProjSpeed:				projectile speed
TargetActor:			actor we're trying to hit
AimLocation:			location at which we are aiming (e.g. could be at last seen position)
MaxMissTargetDistance:	if trace to target blocked, max distance by which NPC can miss
bCanHitOtherActors:		if true, succeeds even if trace hits a Pawn which isn't the TargetActor as long as its ok to hit it (e.g. another enemy, an enemy force field etc.)

Returns true if the NPC can shoot from the ProjStart at the given AimLocation 
and will either hit the given target actor or won't miss it by much or (if
bCanHitOtherActors=true) will hit an Actor which is ok to hit anyway).
*/
	
function bool TestAimLocation( vector ProjStart, float ProjSpeed, Actor TargetActor, vector AimLocation, float MaxMissTargetDistance, bool bCanHitOtherActors )
{
	local bool bResult;
	local Actor HitActor;
	local vector HitNormal, HitLocation;
	local float HitDistance, HitTime, HitActorSpeed;
	
	HitActor = Pawn.Trace( HitLocation, HitNormal, AimLocation, ProjStart, true );

	bLastAimLocationHitFriendly = false;
	if( HitActor == None || HitActor == TargetActor )
	{
		// didn't hit anything
		bResult = true;
	}
	else 
	{
		HitDistance = VSize( HitLocation - AimLocation );

		//DMTNS( "  TestAimLocation hit " $ HitActor $ " at " $ HitDistance $ " bCanHitOtherActors: " $ bCanHitOtherActors );

		// 2002.12.05 (mdf) fix so that hitting non-Pawn actors (e.g. 
		// ForceWallColliders) is handled correctly.
		if( HitActor.bWorldGeometry || HitActor.bStatic )
		{
			// trace hit world geometry / static actor -- return true if hit location fairly close to aim location
			//DMTNS( "  hit geometry / static actor" );
			bResult = ( HitDistance <= MaxMissTargetDistance );
		}
		else
		{
			// trace hit dynamic, non-geometry actor (not the TargetActor) -- see if ok to hit
			if( bCanHitOtherActors )
			{
				if( OKToHit( HitActor, HitLocation, HitNormal )  )
				{
					// not a friend -- fire away
					//DMTNS( "  not a friend" );
					bResult = true;
				}
				else 
				{
					if( Pawn(HitActor) != None && StationaryPawn(HitActor) == None && !HitActor.IsA( 'ForceWallCollider') ) //!!mdf: refactor IsA
					{
						// friendly pawn -- return true if we're not likely to hit it
						HitTime = HitDistance / ProjSpeed;
						//DMTNS( "  HitTime: " $ HitTime );
						HitActorSpeed = VSize( HitActor.Velocity );
						//2002.12.08 (mdf) friendly Pawn could be moving in line with enemy so
						//check vs its collision radius doesn't really make sense and there's
						//pbly no point in checking the perpendicular component since the friend
						//could change direction or another friend could run in the way -- just
						//go off the HitTime?
						//DMTNS( "  HitTime: " $ HitTime $ " HitActorSpeed: " $ HitActorSpeed );
						//HitActorSpeed = VSize( HitActor.Velocity );
						//bResult = ( HitTime > 0.5 && (HitActorSpeed > 4*HitActor.CollisionRadius || HitTime > 2.0) );
						bResult = (HitTime > 2.0);
					}
					
					if( !bResult )
						bLastAimLocationHitFriendly = true;
				}
			}
		}
	}
		
	//DMTNS( "  TestAimLocation ProjSpeed: " $ ProjSpeed );
	//DMTNS( "  TestAimLocation bResult: " $ bResult );
	//if( bResult )
	//	AddArrow( ProjStart, AimLocation, ColorGreen() );
	//else
	//	AddArrow( ProjStart, AimLocation, ColorRed() );
	
	return bResult;
} // TestAimLocation

/*-----------------------------------------------------------------------------
ProjStart:			location from which shot will be fired
ProjSpeed:			projectile speed
TargetActor:		actor we're trying to hit
AimLocation:		location at which we are aiming (e.g. could be at last seen position)
MaxMissDistance:	if trace to target blocked, max distance by which NPC can miss

Returns true if the NPC can shoot from the ProjStart at the given AimLocation 
and won't hit anything close by itself. TestAimLocation (above) is used when 
trying to find a good location to aim at whereas this function checks whether
the location at which we are aiming in order to intentionally miss will cause
the NPC to blow itself up or look stupid (e.g. by shooting into a wall at close
range). If this test fails, the NPC will probably move to a different location.
*/
	
function bool TestMissLocation( vector ProjStart, float ProjSpeed, Actor TargetActor, vector AimLocation, float MinAvoidSelfDistance )
{
	local bool bResult;
	local Actor HitActor;
	local vector HitNormal, HitLocation;
	local float HitDistance, HitTime;//, HitActorSpeed;
	
	//DMTNS( "ProjSpeed: " $ ProjSpeed );
	
	//AddArrow( ProjStart, AimLocation, ColorGreen() );
	
	//HitActor = Pawn.Trace( HitLocation, HitNormal, AimLocation, ProjStart, false );
	//bResult = ( HitActor == None || HitActor.bWorldGeometry || MaxDistance <= 0.0 || VSize( HitLocation - TargetLocation ) < MaxDistance );
	HitActor = Pawn.Trace( HitLocation, HitNormal, AimLocation, ProjStart, true );

	bLastAimLocationHitFriendly = false;
	if( HitActor == None || HitActor == TargetActor )
	{
		// didn't hit anything
		bResult = true;
	}
	else 
	{
		HitDistance = VSize( HitLocation - Pawn.Location );
		
		//DMTNS( "  TestMissLocation hit " $ HitActor $ " at " $ HitDistance );
		
		if( HitDistance >= MinAvoidSelfDistance )
		{
			// we didn't hit something too close to self
			
			// 2002.12.05 (mdf) fix so that hitting non-Pawn actors (e.g. 
			// ForceWallColliders) is handled correctly.
			if( HitActor.bWorldGeometry || HitActor.bStatic )
			{
				// trace hit world geometry / static actor
				//DMTNS( "  hit geometry / static actor" );
				bResult = true;
			}
			else
			{
				// trace hit dynamic, non-geometry actor (not the TargetActor) -- see if ok to hit
				if( OKToHit( HitActor, HitLocation, HitNormal )  )
				{
					// not a friend -- fire away
					//DMTNS( "  not a friend" );
					bResult = true;
				}
				else 
				{
					if( Pawn(HitActor) != None && StationaryPawn(HitActor) == None && !HitActor.IsA( 'ForceWallCollider') ) //!!mdf: refactor IsA
					{
						// friendly pawn -- return true if we're not likely to hit it
						HitTime = HitDistance / ProjSpeed;
						//DMTNS( "  HitTime: " $ HitTime );
						//2002.12.08 (mdf) friendly Pawn could be moving in line with enemy so
						//check vs its collision radius doesn't really make sense and there's
						//pbly no point in checking the perpendicular component since the friend
						//could change direction or another friend could run in the way -- just
						//go off the HitTime?
						//DMTNS( "  HitTime: " $ HitTime $ " HitActorSpeed: " $ HitActorSpeed );
						//HitActorSpeed = VSize( HitActor.Velocity );
						//bResult = ( HitTime > 0.5 && (HitActorSpeed > 4*HitActor.CollisionRadius || HitTime > 2.0) );
						bResult = (HitTime > 2.0);
					}
					if( !bResult )
						bLastAimLocationHitFriendly = true;
				}
			}
		}
	}
		
	//DMTNS( "  TestMissLocation bResult: " $ bResult );
	
	return bResult;
} // TestMissLocation

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

function vector GetMissVector( Actor TargetActor, int PitchError )
{
	return class'UtilGame'.static.GetMissVector(
		Pawn,
		TargetActor,
		Pawn.LastPainAnimTime,
		MaxAffectedByHitTime,
		MaxHitMissMultiplier,
		MinHitPitchError,
		MaxHitPitchError,
		LastAcquireTime,
		MaxAffectedByAcquisitionTime,
		MaxAcquireMissMultiplier,
		MinAcquirePitchError,
		MaxAcquirePitchError,
		bTargetObscured,
		PitchError );
} // GetMissVector

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

function float GetDamageRadius( class<Projectile> ProjectileClass )
{
	if( ProjectileClass != None )
		return ProjectileClass.default.DamageRadius;
	else
		return 0.0;
}
		
//-----------------------------------------------------------------------------

function float GetTimeOutTolerance( class<Projectile> ProjectileClass )
{
	if( ProjectileClass != None )
		return 4.0 * GetDamageRadius( ProjectileClass );
	else
		return 0.0;
} // GetTimeOutTolerance

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

function bool GetTossedAim( 
	class<Projectile> ProjectileClass, 
	float ProjSpeed, 
	vector ProjStart, 
	float WeaponFireSpread, 
	Actor TargetActor, 
	out vector TargetLocation, 
	float TargetDistance, 
	bool bLOSToTarget, 
	out rotator ReturnedRotation )
{
	local float Theta, InterceptTime;
	local bool bUseHigh;
	local bool bSuccess;
	local vector MissVector;
	local float MissDistance;
	local int PitchError;
	local float UseHighOdds;
	local float MaxRange;
	
	//DMTNS( " BEGIN GetTossedAim  TargetActor: " $ TargetActor );

	// maybe use high trajectory if target not too close and projectile will get there within some delta before it explodes
	UseHighOdds = U2PBasic.PreferHighTrajectoryOdds;
	
	if( bLOSToTarget )
	{
		// don't use high if target is visible & within 50% of max range (looks bad 
		// having grenade aimed way high in these situatios)
		MaxRange = class'UtilGame'.static.GetMaxRange( Pawn, ProjectileClass, ProjSpeed );
		if( TargetDistance < (0.5 * MaxRange) )
			UseHighOdds = 0.0;
	}

	//DMT( "  UseHighOdds: " $ UseHighOdds );
	bUseHigh = FDecision( UseHighOdds );
		
	if( bLOSToTarget )
	{
		// try to predict target's location since we can see it
		class'UtilGame'.static.GetBestPredictedProjectileLocation( Pawn, TargetActor, ProjectileClass, ProjSpeed, 0.0, ProjStart, TargetDistance, bUseHigh, TargetLocation );
		//AddActorAt( TargetActor, TargetLocation, ColorMagenta() );
	}
	
	if( bUseHigh )
	{
		//DMT( "  GetTossedAim: prefering high trajectory" );
		bSuccess = class'UtilGame'.static.GetVerifiedInverseTrajectory( Pawn, ProjectileClass, ProjSpeed, ProjStart, TargetLocation, TargetActor, TRAJ_PreferHigh, Theta, InterceptTime, /*Extents*/, GetTimeOutTolerance( ProjectileClass ) );
	}
	else
	{		
		//DMT( "  GetTossedAim: prefering low trajectory" );
		bSuccess = class'UtilGame'.static.GetVerifiedInverseTrajectory( Pawn, ProjectileClass, ProjSpeed, ProjStart, TargetLocation, TargetActor,  TRAJ_PreferLow, Theta, InterceptTime, /*Extents*/, GetTimeOutTolerance( ProjectileClass ) );
	}
			
	if( !bSuccess )
	{
		//DMT( "  GetTossedAim: no solution -- trying 45 degrees" );
		
		// try firing at 45 degrees to achieve max range?
		Theta = -UtilGame.Radians45;
		bSuccess = class'UtilGame'.static.VerifyTrajectory( 
						Pawn, 
						ProjectileClass, 
						ProjSpeed, 
						ProjStart, 
						TargetLocation, 
						TargetActor, 
						Theta, 
						/*InterceptTime*/, 
						/*Extents*/, 
						GetTimeOutTolerance( ProjectileClass ) );
	}

	if( bSuccess )
	{
		if( !TryToHit( 
			TargetActor, 
			TargetDistance, 
			WeaponFireSpread,
			bLOSToTarget, 
			TryToHitTossedBaseOddsMin, 
			TryToHitTossedBaseOddsMax, 
			TryToHitTossedBaseDistance, 
			TryToHitTossedMinMissDistance, 
			TryToHitTossedMaxHitDistance ) )
		{
			//DMT( "  Trying to miss" );
			// muck with pitch and/or rotation so NPC will probably miss
			MissVector = GetMissVector( TargetActor, PitchError );
			
			MissDistance = 2*TargetActor.CollisionRadius + GetDamageRadius( ProjectileClass ) * TargetDistance / TryToHitTossedMaxHitDistance;
			TargetLocation += MissVector * MissDistance;
			TargetLocation.Z += TargetActor.CollisionHeight - 2*FRand() * TargetActor.CollisionHeight;
		}
		
		//#debug DMAIA( " calling AdjustToss #1: " $ ProjectileClass );
		ReturnedRotation = rotator(TargetLocation - ProjStart);
		
		// set the pitch
		if( Theta < 0 )
			ReturnedRotation.Pitch = RadiansToDegrees * -Theta * DegreesToRotationUnits;
		else
			ReturnedRotation.Pitch = 65535 - RadiansToDegrees * Theta * DegreesToRotationUnits;
			
		if( PitchError != 0 )
			class'Util'.static.IncrementRotatorParam( ReturnedRotation.Pitch, PitchError );
	}
		
	#debug DMAIA( " GetTossedAim: " $ bSuccess );
	
	return bSuccess;
} // GetTossedAim

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

function bool GetLastSeenAimLocation( 
	class<Projectile> ProjectileClass, 
	float ProjSpeed, 
	vector ProjStart, 
	float WeaponFireSpread, 
	Actor TargetActor, 
	float TargetDistance, 
	out vector TargetLocation )
{	
	local bool bAimingAtFeet;
	local bool bSuccess;
	local float RandVal, MissDistance, ZShift;
	local vector SavedTargetLocation, OriginalTargetLocation;
	local vector MissVector2D;

	//DMTNS( "Aiming at last seen position" );

	OriginalTargetLocation = TargetLocation;

	// in case the target was falling when last seen, check whether the target 
	// location should be moved to the ground (but don't trace too far)
	TargetLocation = TargetActor.FallLanding( TargetLocation, vect(0,0,-450) );
	if( (OriginalTargetLocation.Z - TargetLocation.Z) > 1024 )
		TargetLocation = OriginalTargetLocation;
	
	// shift some random distance away from the target actor (which is hidden)
	MissVector2D = Normal( (TargetLocation - ProjStart) cross vect(0,0,1) );
	if( MissVector2D dot (TargetActor.Location - TargetLocation) > 0 )
		MissVector2D *= -1.0;

	// make most shots miss close to last seen location
	RandVal = FRand();
	if( RandVal < 0.25 )
		MissDistance = 128.0;
	else if( RandVal < 0.67 )
		MissDistance = 64.0;
	else
		MissDistance = 32.0;
		
	TargetLocation = TargetLocation + MissDistance*FRand() * MissVector2D;

	//AddArrow( OriginalTargetLocation, OriginalTargetLocation + 128.0*MissVector2D, ColorCyan() );
	
	// shift away/towards the projstart somewhat
	//TargetLocation.Z += (16.0 - 32.0*FRand());
	ZShift = ((8.0 * TargetDistance/4096.0) - 32.0*FRand());
	//DMTNS( "ZShift: " $ ZShift );
	TargetLocation.Z += ZShift;

	// aiming at last seen position - i.e. we're probably not going to hit the 
	// enemy (at least not with an instant hit shot) so try to pick an effective 
	// "miss" location where the enemy is likely to see it.
	if( TargetActor == ControllerEnemy && ProjStart.Z >= (TargetLocation.Z - ControllerEnemy.CollisionHeight) )
	{
		// NPC is firing from above the last seen position -- try to hit 
		// ground near last seen position (for greater effect)
		//DMTNS( "  Aiming at feet" );
		bAimingAtFeet = true;
		TargetLocation.Z -= TargetActor.CollisionHeight;
		TargetLocation.Z -= CCFloatHeight; // account for float height of CC above ground
	}

	SavedTargetLocation = TargetLocation;
	
	bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0, false );
    //DMTNS( "  bSuccess #0: " $ bSuccess );

	/*
	if( bSuccess )
	{
		AddCylinder( TargetLocation, 4, 4, ColorGreen() );
		AddArrow( ProjStart, ProjStart + 8192*Normal( TargetLocation - ProjStart), ColorGreen() );
	}
	else
	{
		AddCylinder( TargetLocation, 4, 4, ColorRed() );
		AddArrow( ProjStart, ProjStart + 8192*Normal( TargetLocation - ProjStart), ColorRed() );
	}
	*/
	
	if( !bSuccess && bAimingAtFeet )
	{
		// try middle (if bAimingAtFeet is false, we already tried this)
		TargetLocation.Z += TargetActor.CollisionHeight;
		bSuccess =  TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0, false );
	    //DMTNS( "  bSuccess #1: " $ bSuccess );
	}

	if( !bSuccess )
	{
		// try head
		TargetLocation.Z += 0.9*TargetActor.CollisionHeight;
		bSuccess =  TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0, false );
	    //DMTNS( "  bSuccess #2: " $ bSuccess );
	}
	
	if( !bSuccess )
	{
		// try saved location from above, allowing Pawns to be hit
		TargetLocation = SavedTargetLocation;
		bSuccess =  TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0, true );
	    //DMTNS( "  bSuccess #3: " $ bSuccess );
	}
	
	if( !bSuccess )
	{
		// try original location, allowing Pawns to be hit
		TargetLocation = OriginalTargetLocation;
		bSuccess =  TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0, true );
	    //DMTNS( "  bSuccess #4: " $ bSuccess );
	}

	//if( bSuccess )
	//	AddCylinder( TargetLocation, 4, 4, ColorOrange() );

	#debug DMAIA( "GetLastSeenAimLocation: " $ bSuccess );
	return bSuccess;
} // GetLastSeenAimLocation

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

function bool GetSplashLocation( 
	class<Projectile> ProjectileClass, 
	vector ProjStart, 
	Actor TargetActor, 
	float TargetDistance,
	out vector TargetLocation )
{
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	local vector AdjustedLocation;
	local bool bDefendMelee;
	local bool bSuccess;

	//DMTNS( "GetSplashLocation" );

	// don't use splash damage against non-pawns?
	if( Pawn(TargetActor) == None )
		goto GetSplashLocationFailed;
		
	// don't use splash damage if firing from below or close to below NPC's feet
	if( ProjStart.Z <= TargetLocation.Z + 16.0 )
		goto GetSplashLocationFailed;
			
	// defending against a charging enemy?
	bDefendMelee = ( 
		TargetActor == ControllerEnemy && 
		ControllerEnemy.Controller.ControllerEnemy == Self && 
		FRand() < GetSkill() &&	// don't defend melee as much at lower skills
		ControllerEnemy.Controller.IsPreparedToMelee( false ) && 
		TargetDistance < 700 );
		
	// use splash damage less at lower skills
	if( !bDefendMelee && FRand() > GetSkill() )
		goto GetSplashLocationFailed;
			
	// if geometry just behind target location, just aim at target location?
	HitActor = Pawn.Trace( HitLocation, HitNormal, TargetLocation + GetDamageRadius( ProjectileClass ) * Normal( TargetLocation-ProjStart ), TargetLocation, false );
	if( HitActor != None )
	{
		//DMTNS( "Aiming at geometry behind target" );
		goto GetSplashLocationNoAdjust;
	}

	// try feet
	AdjustedLocation = TargetLocation;
	AdjustedLocation.Z -= TargetActor.CollisionHeight;
	AdjustedLocation.Z -= CCFloatHeight; // account for float height of CC above ground
	HitActor = Pawn.Trace( HitLocation, HitNormal, AdjustedLocation, TargetLocation, false );
	
 	bSuccess = ( HitActor == None );
	if( !bSuccess )
	{
		//DMTNS( "feet no good -- trying just above hit location" );
		AdjustedLocation = HitLocation + vect(0,0,3);
		bSuccess = Pawn.FastTrace( TargetLocation, ProjStart );
	}

	if( bSuccess )
		TargetLocation = AdjustedLocation;

GetSplashLocationNoAdjust:
GetSplashLocationFailed:
		
	#debug DMAIA( "GetSplashLocation returning " $ bSuccess );
	
	return bSuccess;
} // GetSplashLocation

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

function bool ShouldTryToLead( Actor TargetActor, float TargetDistance, bool bTrySplash )
{
	local rotator TargetLook;
	local bool bResult;
	
	bResult = true;
	if( TargetActor.Physics != PHYS_Falling && VSize( TargetActor.Velocity ) ~= 0.0 )
	{
		// not moving
		bResult = false;
	}
	// don't always lead far away targets, especially if they are moving sideways with respect to the NPC
	else if( FRand() < 0.55 &&
			 bTrySplash &&							 // always lead with non-splash damage projectiles?
			 MaxAlwaysLeadDistance > 0.0 &&
			 TargetDistance > MaxAlwaysLeadDistance ) // was 1024
	{
		TargetLook = TargetActor.Rotation;
		
		if( TargetActor.Physics == PHYS_Walking )
			TargetLook.Pitch = 0;
			
		if( (vector(TargetLook) dot Normal( TargetActor.Velocity )) < 0.71 )
			bResult = false;
	}
	
	#debug DMAIA( "ShouldTryToLead returning " $ bResult );
	
	return bResult;
} // ShouldTryToLead

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

function bool GetSlowProjectileAim( 
	class<Projectile> ProjectileClass, 
	float ProjSpeed, 
	vector ProjStart, 
	float WeaponFireSpread, 
	Actor TargetActor, 
	out vector TargetLocation, 
	float TargetDistance, 
	bool bTrySplash, 
	bool bLOSToTarget, 
	out rotator ReturnedRotation )
{	
	local vector OriginalTargetLocation;
	local vector OriginalPredictedTargetLocation;
	local vector MissVector;
	local float MissDistance;
	local float DamageRadius;
	local int PitchError;
	local bool bSuccess;
		
	#debug DMAIA( "GetSlowProjectileAim" );
	//DMTNS( "GetSlowProjectileAim" );
	
	OriginalTargetLocation = TargetLocation;
	
	if( !bLOSToTarget )
	{
		bSuccess = GetLastSeenAimLocation( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, TargetActor, TargetDistance, TargetLocation );
		//if( !bSuccess )
		//	DMTNS( "!bLOSToTarget failed" );
	}
	else
	{
		// lead target?		
		if( ShouldTryToLead( TargetActor, TargetDistance, bTrySplash ) )
		{
			//DMTNS( "Leading" );
			class'UtilGame'.static.GetBestPredictedLocation( Pawn, TargetActor, ProjSpeed, 0.0, TargetLocation );
			//AddCylinder( TargetLocation, 16, 16, ColorBlue() );
		}
		
		// aim at feet?
		OriginalPredictedTargetLocation = TargetLocation;
		if( bTrySplash )
			bTrySplash = GetSplashLocation( ProjectileClass, ProjStart, TargetActor, TargetDistance, TargetLocation );
		
		DamageRadius = GetDamageRadius( ProjectileClass );
		
		// check initial target location
		bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, DamageRadius, false );
		//DMTNS( "TestAimLocation #1 bSuccess: " $ bSuccess );
		//if( !bSuccess )
		//	AddArrow( ProjStart, TargetLocation, ColorRed() );

		if( !bSuccess && bTrySplash )
		{
			// try aiming at middle
			TargetLocation = OriginalPredictedTargetLocation;
			bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, DamageRadius, false );
			//DMTNS( "TestAimLocation #2 bSuccess: " $ bSuccess );
			//if( !bSuccess )
			//	AddArrow( ProjStart, TargetLocation, ColorRed() );
		}
		
		if( !bSuccess )
		{
			// try aiming at head
			TargetLocation.Z += 0.9 * TargetActor.CollisionHeight;
			bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation,  DamageRadius, false );
			//DMTNS( "TestAimLocation #3 bSuccess: " $ bSuccess );
			//if( !bSuccess )
			//	AddArrow( ProjStart, TargetLocation, ColorRed() );
		}

		if( !bSuccess )
		{
			// try aiming at middle, allow Pawns to be hit
			TargetLocation = OriginalPredictedTargetLocation;
			bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, DamageRadius, true );
			//DMTNS( "TestAimLocation #4 bSuccess: " $ bSuccess );
			//if( !bSuccess )
			//	AddArrow( ProjStart, TargetLocation, ColorRed() );
		}
		
		if( bSuccess )
		{	
			if( !TryToHit( 
				TargetActor, 
				TargetDistance,
				WeaponFireSpread,
				bLOSToTarget, 
				TryToHitProjectileBaseOddsMin, 
				TryToHitProjectileBaseOddsMax, 
				TryToHitProjectileBaseDistance, 
				TryToHitProjectileMinMissDistance, 
				TryToHitProjectileMaxHitDistance ) )
			{
				MissVector = GetMissVector( TargetActor, PitchError );
				// looks bad because NPC will miss by too much...
				//MissDistance = (1 + 2*FRand()) * TargetActor.CollisionRadius + GetDamageRadius( ProjectileClass );
				MissDistance = (2 + 3*FRand()) * TargetActor.CollisionRadius;
				TargetLocation += MissVector * MissDistance;
				
				// aim around chest height +/- collision height when missing?
				TargetLocation.Z = OriginalPredictedTargetLocation.Z + 0.5*CollisionHeight;
				TargetLocation.Z += (1 - 2*FRand()) * TargetActor.CollisionHeight;
				
				// mdf-tbd: final check for hitting wall close by self or hitting a friendly?
				bSuccess = TestMissLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0 + GetDamageRadius( ProjectileClass ) );
				
				//DMTNS( "TestMissLocation #4: " $ bSuccess );
				//if( !bSuccess )
				//	AddArrow( ProjStart, TargetLocation, ColorRed() );
			}
		}
	}
		
	if( bSuccess )
	{
		ReturnedRotation = rotator( TargetLocation - ProjStart );
		if( PitchError != 0 )
		{
			// NOTE: add pitch error after call to TestMissLocation above since that 
			// shouldn't take pitch error into account (pitch error, if any *should*
			// possibly allow NPC to shoot into walls & such.
			class'Util'.static.IncrementRotatorParam( ReturnedRotation.Pitch, PitchError );
		}
	}
			
	//DMTNS( "  GetSlowProjectileAim final bSuccess: " $ bSuccess );
	
	return bSuccess;
} // GetSlowProjectileAim

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

function bool GetInstantProjectileAim( 
	class<Projectile> ProjectileClass, 
	float ProjSpeed, 
	vector ProjStart, 
	float WeaponFireSpread, 
	Actor TargetActor, 
	out vector TargetLocation, 
	float TargetDistance, 
	bool bLOSToTarget, 
	out rotator ReturnedRotation )
{			
	local vector OriginalTargetLocation;
	local bool bTryFeet;
	local vector MissVector;
	local float MissDistance;
	local int PitchError;
	local bool bSuccess;

	//DMTNS( "GetInstantProjectileAim  TargetActor.Location: " $ TargetActor.Location $ " TargetLocation: " $ TargetLocation );
	
	bSuccess = false;
	
	OriginalTargetLocation = TargetLocation;
	
	if( !bLOSToTarget )
	{
		//DMTNS( " using last seen location" );
		bSuccess = GetLastSeenAimLocation( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, TargetActor, TargetDistance, TargetLocation );
	}
	else
	{
		// aiming at enemy
		
		// try aiming directly at target location
		bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 0.0, false );
 		
		//DMTNS( " tried middle take #1-- bSuccess: " $ bSuccess );

		if( !bSuccess ) 
		{
			// try head
 			TargetLocation.Z = TargetLocation.Z + 0.9 * TargetActor.CollisionHeight;
			bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 2.0*TargetActor.CollisionRadius, false );
			//DMTNS( GetContext() $ " try head -- bSuccess: " $ bSuccess );
			
 			// don't try feet -- having NPCs nailing you in the feet with 
 			// instant hit weapons when you can't see them would be unfun?
		}

		if( !bSuccess ) 
		{
			// try original location again, but now allow missing by X units
 			TargetLocation = OriginalTargetLocation;
			bSuccess = TestAimLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 8.0*TargetActor.CollisionRadius, true );
			//DMTNS( GetContext() $ " try middle take #2 -- bSuccess: " $ bSuccess );
			
 			// don't try feet -- having NPCs nailing you in the feet with 
 			// instant hit weapons when you can't see them would be unfun?
		}
		
		if( bSuccess )
		{
			// possibly adjust target location to miss intentionally		
			if( !TryToHit( 
					TargetActor, 
					TargetDistance, 
					WeaponFireSpread,
					bLOSToTarget, 
					TryToHitInstantBaseOddsMin, 
					TryToHitInstantBaseOddsMax, 
					TryToHitInstantBaseDistance, 
					TryToHitInstantMinMissDistance, 
					TryToHitInstantMaxHitDistance ) )
			{
				//DMTNS( "trying to miss" );
				
				MissVector = GetMissVector( TargetActor, PitchError );
				
				// looks bad because NPC will miss by too much...
				//MissDistance = TargetActor.CollisionRadius + FRand() * TargetActor.CollisionRadius + GetDamageRadius( ProjectileClass ) + 4.0;
				MissDistance = TargetActor.CollisionRadius + FRand() * TargetActor.CollisionRadius + 4.0;
				
				if( WeaponFireSpread > 0.0 )
				{
					//DMTNS( "Increasing MissDistance from " $ MissDistance $ " to " $ MissDistance + TargetDistance * sin( 0.5*DegreesToRadians*WeaponFireSpread ) );
					MissDistance += TargetDistance * sin( 0.5*DegreesToRadians*WeaponFireSpread );
				}
				
				TargetLocation += MissDistance * MissVector;
				
				// aim around chest height +/- collision height when missing?
				TargetLocation.Z = OriginalTargetLocation.Z + 0.5*CollisionHeight;
				TargetLocation.Z += (1 - 2*FRand()) * TargetActor.CollisionHeight;
				
				// mdf-tbd: don't shoot if hitting wall close by self or if hitting a friendly?
				bSuccess = TestMissLocation( ProjStart, ProjSpeed, TargetActor, TargetLocation, 512.0 );
			}
		}
	}
	
	if( bSuccess )
	{
		ReturnedRotation = rotator( TargetLocation - ProjStart );

		if( PitchError != 0 )
		{
			// NOTE: add pitch error after call to TestMissLocation above since that 
			// shouldn't take pitch error into account (pitch error, if any *should*
			// possibly allow NPC to shoot into walls & such.
			//DMTNS( "mucking with pitch" );
			//AddArrow( ProjStart, ProjStart + 128.0*vector(ReturnedRotation), ColorRed() );
			class'Util'.static.IncrementRotatorParam( ReturnedRotation.Pitch, PitchError );
			//AddArrow( ProjStart, ProjStart + 128.0*vector(ReturnedRotation), ColorGreen() );
		}
	}
	
	//DMTNS( "ProjStart: " $ ProjStart $ " Pawn.Location: " $ Pawn.Location $ " Pawn.Rotation: " $ Pawn.Rotation $ " ReturnedRotation: " $ ReturnedRotation );
	//AddArrow( ProjStart, ProjStart + 4096.0*vector(ReturnedRotation), ColorGreen() );	

	//DMTNS( "  GetInstantProjectileAim final bSuccess: " $ bSuccess );
		
	return bSuccess;
} // GetInstantProjectileAim

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

function vector GetTargetLocation( Actor TargetActor, bool bLOSToTarget, bool bTossed, vector LastEnemySeenLocation, float TimeSinceLastSeen )
{
	local float MinGuessDistance, MaxGuessDistance;
	local vector GuessLocationVector;
	local vector ReturnedLocation;

	if( !bLOSToTarget )
	{
		#debug DMAIA( "===> GetTargetLocation - no LOS to enemy -- will aim at LastEnemySeenLocation" );
		
		if( bTossed )
		{		
			// try to guess where enemy might be now (cheat a bit by peeking at target's actual location...)
			GuessLocationVector = Normal( TargetActor.Location - LastEnemySeenLocation );
			
			if( Pawn(TargetActor) != None )
			{
				// guess at min/max distance target may have moved (max "location")
				MinGuessDistance = 0.2*Pawn(TargetActor).GroundSpeed;
				MaxGuessDistance = FMin( TimeSinceLastSeen, 3.0 ) * Pawn(TargetActor).GroundSpeed;
				
				// now pick a location somewhere between min and max
				ReturnedLocation = LastEnemySeenLocation + RandRange( MinGuessDistance, MaxGuessDistance ) * GuessLocationVector;
			}
			else
			{
				// stationary target?
				ReturnedLocation = LastEnemySeenLocation;
			}
		}
		else
		{
			ReturnedLocation = LastEnemySeenLocation;
		}
	}
	else
	{
		ReturnedLocation = TargetActor.Location;
	}
	
	return ReturnedLocation;
} // GetTargetLocation

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

function bool StopFiringAtEnemy( Actor TargetActor, bool bTossed )
{
	local float SkillMultiplier;
	local float TimeSinceLastSeen;
	local float NewStopFiringAtEnemyDelay;

	TimeSinceLastSeen = TimeSinceTargetLastSeen( TargetActor );
	
	if( TimeSinceLastSeen <= 1.0 )
	{
		// reset timer
		SkillMultiplier = 0.5 + Level.Game.GetNormalizedDifficulty();
		if( bTossed )
			NewStopFiringAtEnemyDelay = (4.0 + 4.0*FRand()) * SkillMultiplier; // Difficulty 0: 2-4 secs, 1: 4-8 secs, 2: 6-12 secs
		else
			NewStopFiringAtEnemyDelay = (2.0 + 2.0*FRand()) * SkillMultiplier; // Difficulty 0: 1-2 secs, 1: 2-4 secs, 2: 3-6 secs
		
		StopFiringAtEnemyTime = Level.TimeSeconds + NewStopFiringAtEnemyDelay;
	}

	if( TimeSinceLastSeen <= 0.2 )
		return false;
	else		
		return ( Level.TimeSeconds > StopFiringAtEnemyTime );
}

/*-----------------------------------------------------------------------------
Determines the rotation which the NPC should use to aim for the given 
projectile type, speed, target location etc. If a solution is found, sets the
NPC's rotation and returns true, returns false otherwise (and possibly calls
StopFiring to abort the firing of the projectile).

The code generally first determines the ideal aiming direction then decides 
whether to try to miss the target (intentionally) based on the game difficulty,
target speed, how recently the target was acquired etc. If a miss is called 
for, a "good" miss direction is selected such that shots will often pass near 
and in front of the target for greater effect.

If the target isn't in sight currently, but was recently seen, NPCs will fire 
at the last seen location (generally on the ground) for some time.

Grenades can be lobbed over obstacles (using either of the 0/1/2 possible 
trajectories, checked for obstructions) at an enemy who is known but hidden 
(NPC "guesses" actual location based on last seen location, velocity with the 
error increasing with the amount of time that has passed).
*/

function bool AdjustAim( 
	class<Projectile> ProjectileClass, 
	float ProjSpeed, 
	vector ProjStart, 
	float WeaponFireSpread, 
	bool bLeadTarget, 
	bool bWarnTarget, 
	bool bTossed, 
	bool bTrySplash )
{
	local rotator ReturnedRotation;
	local vector TargetLocation;
	local vector LastEnemySeenLocation;
	local float TargetDistance;
	local Actor TargetActor;
	local float TimeSinceLastSeen;
	local bool bLOSToTarget;
	//debug
	//local Actor HitActor;
	//local vector HitLocation, HitNormal;

	#debug DMAIA( "===> AdjustAim -- BEGIN  Enemy: " $ ControllerEnemy $ " ControllerTarget: " $ ControllerTarget );
	//DMTNS( "===> AdjustAim -- BEGIN  Enemy: " $ ControllerEnemy $ " ControllerTarget: " $ ControllerTarget );

	//-------------------------------------------------------------------------
	// VERIFY TARGET
	//-------------------------------------------------------------------------

	TargetActor = GetTarget();

	if( TargetActor == None )
	{
		#debug DMAIA( "===> AdjustAim - StopFiring: no target -- called StopFiring and returning false" );
		#debug   StopFiring( 0.0, SFI_TargetInvalid, GetContext() );
		#release StopFiring( 0.0, SFI_TargetInvalid );
		return false;
	}
	
	if( StopFiringAtEnemy( TargetActor, bTossed ) ) // stop firing after 5-10 secs of not seeing enemy
	{
		#debug DMAIA( "===> AdjustAim - StopFiring: too long since target was last seen" );
		#debug   StopFiring( 0.5, SFI_TimeOut, GetContext() );
		#release StopFiring( 0.5, SFI_TimeOut );
		return false;
	}
	
	// assume we have LOS to target if seen within last 0.2 secs
	TimeSinceLastSeen = TimeSinceTargetLastSeen( TargetActor );
	bLOSToTarget = ( TimeSinceLastSeen < 0.2 );
	
	if( bLOSToTarget && !IsFacingTarget( TargetActor, CosMinFacingTargetAngle ) )
	{
		#debug DMAIA( "===> AdjustAim - StopFiring: facing too far away from target (" $ TargetActor $ ") to aim" );
		//AddArrow( Pawn.Location, Pawn.Location + 128.0*vector(Pawn.Rotation), ColorOrange() );
		//AddArrow( Pawn.Location, TargetActor.Location, ColorYellow() );
		#debug   StopFiring( 0.1, SFI_Orientation, GetContext() );
		#release StopFiring( 0.1, SFI_Orientation );
		return false;
	}

	if( !bLOSToTarget )
	{
		bLeadTarget = false;
		LastEnemySeenLocation = GetLastEnemySeenLocation();
		if( !bTossed && !Pawn.FastTrace( Pawn.Location, LastEnemySeenLocation ) )
		{
			#debug DMAIA( "===> AdjustAim - StopFiring: no LOS to target and no LOS to last seen location" );
			#debug   StopFiring( 0.1, SFI_NoLOS, GetContext() );
			#release StopFiring( 0.1, SFI_NoLOS );
			return false;
		}
	}

	//-------------------------------------------------------------------------
	// SET AIMING PARAMETERS
	//-------------------------------------------------------------------------

	TargetLocation = GetTargetLocation( TargetActor, bLOSToTarget, bTossed, LastEnemySeenLocation, TimeSinceLastSeen );
	TargetDistance = VSize( TargetLocation - ProjStart );

	//2002.12.15 hack to *force* NPCs to not fire outside min/max ranges
	if( U2PBasic.bForceRanges )
	{
		if( TargetDistance < U2PBasic.RangeMinAttack )
		{
			#debug   StopFiring( 0.1, SFI_OutOfRange, GetContext() );
			#release StopFiring( 0.1, SFI_OutOfRange );
			return false;
		}
		
		if( U2PBasic.bHasMaxAttackRanges && !CheckMaxAttackRanges( TargetDistance, TargetActor ) )
		{
			#debug   StopFiring( 0.1, SFI_OutOfRange, GetContext() );
			#release StopFiring( 0.1, SFI_OutOfRange );
			return false;
		}
	}
	
	if( ProjSpeed <= 0 )
	{	
		bTossed = false;
		bLeadTarget = false;
	}

	/*
	#debugbegin
	DMTNS( " Target:          "	$ TargetActor );
	DMTNS( " ProjClass:       "	$ ProjectileClass );
	DMTNS( " ProjSpeed:       "	$ ProjSpeed );
	DMTNS( " ProjStart:       "	$ class'Util'.static.GetVectorString(ProjStart) );
	DMTNS( " bLeadTarget:     "	$ bLeadTarget );
	DMTNS( " bWarnTarget:     "	$ bWarnTarget );
	DMTNS( " bTossed:         "	$ bTossed );
	DMTNS( " bTrySplash:      "	$ bTrySplash );
	//AddCylinder( ProjStart, 2, 2, ColorCyan() );
	#debugend
	*/

	/*
	if( !bLOSToTarget )
		AddActorAt( TargetActor, TargetLocation, ColorRed() );
	else
		AddActorAt( TargetActor, TargetLocation, ColorGreen() );
	*/
	
	//AddArrow( ProjStart, TargetLocation, ColorOrange() );
	
	//#debug DMAIA( " Target:      " $ TargetActor $ " Pawn(TargetActor).IsMobile(): " $ Pawn(TargetActor).IsMobile() );

	//-------------------------------------------------------------------------
	// ATTEMPT TO AIM
	//-------------------------------------------------------------------------

	if( bTossed )
	{
		if( !GetTossedAim( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, TargetActor, TargetLocation, TargetDistance, bLOSToTarget, ReturnedRotation ) )
		{
			#debug   StopFiring( 0.1, SFI_NoShot, GetContext() );
			#release StopFiring( 0.1, SFI_NoShot );
			return false;
		}
	}
	else if( bLeadTarget )
	{
		if( !GetSlowProjectileAim( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, TargetActor, TargetLocation, TargetDistance, bTrySplash, bLOSToTarget, ReturnedRotation ) )
		{
			#debug   StopFiring( 0.1, SFI_NoShot, GetContext() );
			#release StopFiring( 0.1, SFI_NoShot );
			return false;
		}
	}
	else
	{
		if( !GetInstantProjectileAim( ProjectileClass, ProjSpeed, ProjStart, WeaponFireSpread, TargetActor, TargetLocation, TargetDistance, bLOSToTarget, ReturnedRotation ) )
		{
			#debug   StopFiring( 0.1, SFI_NoShot, GetContext() );
			#release StopFiring( 0.1, SFI_NoShot );
			return false;
		}
	}

	#debugbegin
	
	//AddArrow( ProjStart, ProjStart + 16384.0*vector(ReturnedRotation), ColorRed() );
	
	/*
	//DMTNS( "===> AdjustAim -- END  ReturnedRotation=" $ ReturnedRotation );
	//AddCylinder( ProjStart, 4, 4, ColorOrange() );
	HitActor = Pawn.Trace( HitLocation, HitNormal, ProjStart + 16384.0*vector(ReturnedRotation), ProjStart, true ); 
	
	//DMTNS( "Hit " $ HitActor );
	//AddCylinder( HitLocation, 4, 4, ColorOrange() );

	if( HitActor == TargetActor )
		AddArrow( ProjStart, HitLocation, ColorGreen() );
	else if( HitActor != None )
		AddArrow( ProjStart, HitLocation, ColorRed() );
	else
		AddArrow( ProjStart, ProjStart + 16384.0*vector(ReturnedRotation), ColorRed() );
	*/
	#debugend

	//-------------------------------------------------------------------------
	// WRAPUP
	//-------------------------------------------------------------------------

	if( bWarnTarget && Pawn(TargetActor) != None && Pawn(TargetActor).Controller != None )
		Pawn(TargetActor).Controller.ShotFiredNotification( Pawn, vector(ReturnedRotation), ProjectileClass, ProjSpeed ); 
	
	SetRotation( ReturnedRotation );
	AimRotation = ReturnedRotation;
	//DMTNS( "==> AdjustAim  returning true  Rotation Pitch: " $ Rotation.Pitch $ " Roll: " $ Rotation.Roll $ " Yaw: " $ Rotation.Yaw );
	//DMTNS( "bRotateToDesired: " $ bRotateToDesired );
	//DMTNS( "Pawn.bRotateToDesired: " $ Pawn.bRotateToDesired );
	//AddArrow( Pawn.Location, Pawn.Location + 4096.0*vector(Rotation), ColorGreen() );	
	
	return true;
} // AdjustAim

//-----------------------------------------------------------------------------
//@ DIALOG STUFF
//-----------------------------------------------------------------------------

function bool DialogAllowed( Actor Other )
{
	local Pawn P;

	if ( Controller(Other) != None )
		Other = Controller(Other).Pawn;

	P = Pawn(Other);

	return( ValidPawn( P ) &&
			ControllerEnemy == None && 
			Pawn.Physics == PHYS_Walking &&
			GetAttitudeTo( P ) != ATTITUDE_Enemy &&
			class'DialogEngine'.static.HasDialog(Pawn,P) &&
			!class'DialogEngine'.static.IsAlreadyTalking(P) );
}

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

function DialogInitiate( Actor Other, optional name Topic, optional Actor WaitingActor )
{
	if( Pawn != None )
		class'DialogEngine'.static.Initiate( Pawn, Other, Topic, WaitingActor );
}

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

function DialogTerminate()
{
	if( Pawn != None )
		class'DialogEngine'.static.NotifyDialogScriptedAbort( Pawn );
}

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

function bool IsUsable( Actor Other )
{
	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return false;
		
	return DialogAllowed( Other );
}

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

function OnUse( Actor Other )
{
	if( Other? && Pawn? )
	{
		if ( Controller(Other)? )
			Other = Controller(Other).Pawn;

		// reverse the initiator / target since we're being "used"
		class'DialogEngine'.static.Initiate( Other, Pawn );
	}
}

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

function OnUnuse( Actor Other )
{
}

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

event DialogBegin( Actor Other )
{
	if( Pawn(Other) != None )
	{
		U2P.bHeadtrackingEnabled = false;   //!!Fix (mw): this is an ugly place for this
		ScriptController.eventSCDialogBegin( Self );
		GotoState( ScriptedDialogState, DialogBeginLabel );
	}
}

//-----------------------------------------------------------------------------
//@ SCRIPTING SUPPORT
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Called by AI to explicitely use the Actor which is currently in front of the
// NPC (must be within correct FOV and distance), e.g. when NPC is scripted to 
// use/unuse something, when autonomous AI decides to use something etc.

// tbd: drop parameter -- use manager should ensure that only usuable actor in range/fov is used
function UseActor( Actor A )
{
	class'U2UseManager'.static.UseTarget( U2PBase, A );
	GotoState( UsingState );
}

//-----------------------------------------------------------------------------
// Called by AI to explicitely unuse actor being used (if any), e.g. when NPC
// is scripted to use/unuse something, when autonomous AI decides to stop using
// something which was being used.

// tbd: drop parameter -- use manager should ensure that only usuable actor in range/fov is used
function UnuseActor( optional Actor A )
{
	// currently, unless we are scripted or in using state, nothing to do (we can't be using something)
}				

//-----------------------------------------------------------------------------
// Called when a Pawn dies or when actor being used can no longer be used (e.g.
// if a health station runs out of health).

exec function Unuse()
{
	UnuseActor( None );
}	

//-----------------------------------------------------------------------------
// Called when use stops because the NPC has walked away or stopped looking at 
// the actor being used. No longer used currently now that power/health 
// stations don't go through the use manager (you just walk on 'em).

function NotifyUnuse( Actor A )
{
	// global should never be called?
	DMAssert( false, GetContext() @ A );
}

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

function SetSpecialGoal( Actor NewSpecialGoal, optional float NewSpecialGoalDistance, optional bool bFaceSpecialGoalNew )
{
	#debug DMAI( "SetSpecialGoal: " $ NewSpecialGoal );
	SpecialGoal = NewSpecialGoal;

	// note: SpecialGoalDistance implies the 2D CC to CC distance for a Pawn Target, actual distance otherwise
	if( NewSpecialGoalDistance > 0.0 )
	{
		if( Pawn(NewSpecialGoal) != None )
			SpecialGoalDistance = FMax( MinFollowDistance, NewSpecialGoalDistance );
		else
			SpecialGoalDistance = FMax( MinGoalDistance, NewSpecialGoalDistance );
	}
	else
		SpecialGoalDistance = -1.0; // not used
	
	bFaceSpecialGoal = bFaceSpecialGoalNew;
}

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

function SetDirectionalPatrol( bool bNewVal )
{
	bDirectionalPatrol = bNewVal;
}

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

function bool GetDirectionalPatrol()
{
	return bDirectionalPatrol;
}

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

simulated function SetScriptedFocus( Actor A )
{ 
	ScriptedFocus = A;  
}

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

function SetScriptedIdleAnims( bool bNewVal )
{
	bScriptedIdleAnims = bNewVal;

	if( !bNewVal )
		UnlockAnimationController();

	GotoState( ScriptedState, IdleLabel );
}

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

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

//-----------------------------------------------------------------------------
// Rotation <-->degrees: 
// 
//   32	 =   0.18
//   64  =   0.35
//  128  =   0.70 
//  256  =   1.41 
//  512  =   2.81 
//  1024 =   5.63 
//  2048 =  11.25 
//  4096 =  22.50 
//  8192 =  45.00
// 16384 =  90.00 
// 32768 = 180.00

defaultproperties
{
	MaxMoveToPointAttempts=2
	MaxMoveToActorAttempts=10
	MaxMoveRecoverAttempts=5
	CloseEnoughDistance=512.000000
	GetCloserThreshold=256.000000
	MaxAffectedByHitTime=0.500000
	MaxAffectedByAcquisitionTime=1.000000
	TryToHitInstantBaseOddsMin=0.125000
	TryToHitInstantBaseOddsMax=0.625000
	TryToHitProjectileBaseOddsMin=0.250000
	TryToHitProjectileBaseOddsMax=1.000000
	TryToHitTossedBaseOddsMin=0.250000
	TryToHitTossedBaseOddsMax=1.000000
	TryToHitInstantBaseDistance=1024.000000
	TryToHitProjectileBaseDistance=1024.000000
	TryToHitTossedBaseDistance=1024.000000
	TryToHitInstantMinMissDistance=256.000000
	TryToHitProjectileMinMissDistance=256.000000
	TryToHitTossedMinMissDistance=256.000000
	TryToHitProjectileMaxHitDistance=4096.000000
	TryToHitInstantMaxHitDistance=9999999.000000
	TryToHitTossedMaxHitDistance=3000.000000
	TryToHitBaseSpeed=300.000000
	TryToHitBaseSpeedOdds=0.500000
	BlockedByCoverHitOdds=0.020000
	MaxHitMissMultiplier=1.000000
	MaxAcquireMissMultiplier=1.000000
	MaxHitPitchError=2048
	MinHitPitchError=512
	MaxAcquirePitchError=2048
	MinAcquirePitchError=512
	MinTeleportRangeMoveError=256.000000
	MaxTeleportRangeMoveError=4096.000000
	MinTeleportRangeMinZError=64.000000
	MaxTeleportRangeMinZError=4096.000000
	MinTeleportRangeStuckError=128.000000
	MaxTeleportRangeStuckError=1280.000000
	MinLastRenderedTeleportDelay=2.000000
	DefaultRotationThreshold=910
	ScriptedRotationThreshold=182
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}