Engine.UtilGame

//=============================================================================
// UtilGame.uc
// $Author: Mfox $
// $Date: 1/05/03 8:45p $
// $Revision: 38 $
//=============================================================================
//NEW: file

class UtilGame extends Actor // never instantiated and extending Actor makes things easier
	abstract;

//=============================================================================
// Game-level utility functions, e.g. inventory, actor searching, AI. 
//=============================================================================

const MaxFilteredActors		= 10;

const NonPawnGravityFactor	= 0.500;	// amount we need to scale gravity by for Newtonian physics calculations to work
const PawnGravityFactor		= 1.000;	// pawns seem to fall under 2x the gravity of other actors...?

// debug
const TimeFieldSize			=  8;
const NameFieldSize			= 15;
const StateFieldSize		= 32;
const PrefixFieldSize		=  5;

const MaxPathCheckRadius	= 1300;		// (PathsMaxDist+100)

const Radians45				= 0.785398; // 45 degrees in radians

//=============================================================================

enum ETrajectoryType
{
	TRAJ_None,
	TRAJ_Low,			// only check/return low trajectory
	TRAJ_High,			// only check/return high trajectory
	TRAJ_PreferLow,		// check/return low first, then check/return high if low fails
	TRAJ_PreferHigh,	// check/return high first, then check/return low if high fails
};

enum ELeapResult
{
	LR_None,			// no solution or blocked
	LR_OutOfRange,		// destination is too far to reach
	LR_OutOfAngle,		// angle between vector to destination and Pawn's rotation is too great
	LR_Success,			// found a valid solution
};

enum EDistanceFilterType
{
	DFT_First,
	DFT_Closest,
	DFT_Furthest,
	DFT_Any,
};

enum EVisibilityFilterType
{
	VFT_None,
	VFT_Visible,
	VFT_FOV,
};

var int VerifyTrajectorySamples;
var float VerifyTrajectoryHorizontalExtentPadding;
var float VerifyTrajectoryVerticalExtentPadding;
var int MaxPredictProjectileAttempts;
var float PredictProjectileThreshold;

var float MinTargetBlockedMissMultiplier;
var float MaxTargetBlockedMissMultiplier;
var float MinTargetBlockedPitchError;
var float MaxTargetBlockedPitchError;
var float MinModifyForSpreadDistance;
var float MinPitchError;
var float MaxPitchError;

var private name LastDebugName;

//=============================================================================
//@ Inventory accessor and mutator functions
//=============================================================================

static final function DumpInventory( Pawn P, optional string ContextString )
{
	local Inventory Inv;
	
	P.DMTNS( "DumpInventory" @ ContextString $ ":" );
	for( Inv = P.Inventory; Inv != None; Inv = Inv.Inventory )
		P.DMTNS( "  " $ Inv );
}

//-----------------------------------------------------------------------------
// Spawn and add to inventory if not already present. If an item of the same
// class is present, return that one.

static final function Inventory GiveInventoryClass( Pawn TargetPawn, class<Inventory> InvClass )
{
	local Inventory Inv, InvNew;

	//TargetPawn.DMTNS( "GiveInventoryClass " $ InvClass );
	//class'UtilGame'.static.DumpInventory( TargetPawn, "GiveInventoryClass BEGIN" );
	if( InvClass != None )
	{
		Inv = TargetPawn.FindInventoryType( InvClass );
		if( Inv == None || Inv.bMergesCopies )
		{
			InvNew = TargetPawn.Spawn( InvClass );
			if( InvNew != None )
				InvNew.GiveTo( TargetPawn );
		}
	}
	//class'UtilGame'.static.DumpInventory( TargetPawn, "GiveInventoryClass END" );
	if( Inv != None )
		return Inv;
	else
		return InvNew;
}

//-----------------------------------------------------------------------------
// Spawn and add to inventory if not already present.

static final function Inventory GiveInventoryString( Pawn TargetPawn, coerce string InventoryString )
{
	return GiveInventoryClass( TargetPawn, class<Inventory>(DynamicLoadObject( InventoryString, class'Class' )) );
}

//-----------------------------------------------------------------------------
// Add to inventory if not already present.

static final function bool GiveInventory( Pawn TargetPawn, Inventory Inv )
{
	local Inventory MatchingInv;

	if( Inv != None )
	{
		MatchingInv = TargetPawn.FindInventoryType( Inv.Class );
		if( MatchingInv == None || Inv.bMergesCopies )
		{
			Inv.GiveTo( TargetPawn );
			return true;
		}
	}

	return false;
}

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

static final function bool RemoveInventoryString( Pawn TargetPawn, coerce string InventoryString )
{
	local Inventory Inv;
	local class<Inventory> RemovedClass;

	if( InventoryString != "" )
		RemovedClass = class<Inventory>(DynamicLoadObject( InventoryString, class'Class' ));
	else
		RemovedClass = class'Inventory';

	if( RemovedClass != None )
	{
		for( Inv = TargetPawn.Inventory; Inv != None; Inv = Inv.Inventory )
		{
			if( Inv.IsA( RemovedClass.Name ) )
				Inv.Destroy(); //removes inventory as well
		}
	}

	return (RemovedClass != None);
}

//-----------------------------------------------------------------------------
// Return inventory item from holder's inventory matching class 'InventoryType'

static final function Inventory GetInventoryItem( Pawn InventoryHolder, class<Inventory> InventoryType )
{
	local Inventory CurrentInventoryItem;
	local Inventory FoundInventoryItem;

	if( InventoryHolder == None )
		return None;

	for( CurrentInventoryItem = InventoryHolder.Inventory;
			( ( None != CurrentInventoryItem ) && ( None == FoundInventoryItem ) );
			CurrentInventoryItem = CurrentInventoryItem.Inventory )
	{
		if( ClassIsChildOf( CurrentInventoryItem.Class, InventoryType ) )
		{
			FoundInventoryItem = CurrentInventoryItem;
		}
	}
	
	return FoundInventoryItem;
}

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

static final function int GetInventoryCount( Pawn InventoryHolder, class<Inventory> InventoryType )
{
	local Inventory CurrentInventoryItem;
	local int InventoryCount;

	for( CurrentInventoryItem = InventoryHolder.Inventory;
			CurrentInventoryItem != None;
			CurrentInventoryItem = CurrentInventoryItem.Inventory )
	{
		if( CurrentInventoryItem.IsA( InventoryType.Name ) )
		{
			InventoryCount++;
		}
	}
	
	return InventoryCount;
}

//-----------------------------------------------------------------------------
// Checks whether P has the given weapon in its inventory, spawning one and
// giving it to P if necessary.

static final function Weapon ForceWeaponIntoInventory( Pawn P, class<Weapon> WeapClass )
{
	local Inventory Inv;
	local Weapon Weap;

	//class'UtilGame'.static.DumpInventory( P, "ForceWeaponIntoInventory BEGIN" );
	// see if already in inventory
	Inv = P.FindInventoryType( WeapClass );
	if( Inv == None )
	{
		//P.DMTNS( "ForceWeaponIntoInventory spawning " $ WeapClass );
		Weap = P.Spawn( WeapClass );
		Weap.GiveTo( P );
	}
	else
	{
		Weap = Weapon( Inv );
	}

	//class'UtilGame'.static.DumpInventory( P, "ForceWeaponIntoInventory END" );
	
	return Weap;
}

//-----------------------------------------------------------------------------
// Note: Weap can be None to specify that the Pawn should be holding no weapon.

static final function MakeWeaponCurrent( Pawn P, Weapon Weap )
{
	#debug   P.Controller.StopFiring( 0.5, SFI_WeaponSwitch, GetContext() );
	#release P.Controller.StopFiring( 0.5, SFI_WeaponSwitch );

	P.PendingWeapon = Weap;
	if( P.PendingWeapon == P.Weapon )
		P.PendingWeapon = None;
	if( P.PendingWeapon == None )
		return;

	if( P.Weapon == None )
		P.ChangedWeapon();

	if( P.Weapon != P.PendingWeapon )
		P.Weapon.PutDown();
}

//-----------------------------------------------------------------------------
// Note: can use WeapClass=None to specify that the Pawn shouldn't be holding a
// weapon.

static final function Weapon SetCurrentWeaponClass( Pawn P, class<Weapon> WeapClass )
{
	local Weapon Weap;

 	if( WeapClass != None )
 	{
 		Weap = ForceWeaponIntoInventory( P, WeapClass );
 		
 		if( P.Weapon != Weap )
 			MakeWeaponCurrent( P, Weap );
 	}
 	
	return Weap;
}

//-----------------------------------------------------------------------------
// Makes sure Pawn has the given weapon in his inventory and makes it the 
// currently selected weapon. Makes sure that the Pawn has the default amount
// of ammo for the weapon. Can use WeaponClassString="" to specify that the
// Pawn shouldn't be holding a weapon.

static final function Weapon SetCurrentWeaponString( Pawn P, string WeaponClassString )
{
	local Weapon Weap;
	local class<Weapon> WeapClass;

	if( P != None )
	{
		if( WeaponClassString != "" )
			WeapClass = Class<Weapon>( DynamicLoadObject( WeaponClassString, Class'Class' ) );

		// set even if DynamicLoadObject fails to make problem obvious
		Weap = SetCurrentWeaponClass( P, WeapClass );
	}

	// !!mdf-tbr?:
	if( Weap == None && WeaponClassString != "" )
		P.DMTN( "SetCurrentWeaponString -- couldn't set weapon to: " $ WeaponClassString );

	return Weap;
}

//=============================================================================
//@ Misc
//=============================================================================

//-----------------------------------------------------------------------------
// Returns true if the given actor can be moved MoveDistance units along the 
// given MoveDir. Makes sure that the collision cylinder will fit along the
// trace from the actor's current location to the new location and that the
// maximum step height is not exceeded.
//-----------------------------------------------------------------------------

static final function bool CanActorMoveTo( Actor A, vector MoveDir, float MoveDistance )
{				
	local vector HitLocation, HitNormal, Extent;
	local Actor HitActor;
		
	Extent.X = A.CollisionRadius;
	Extent.Y = A.CollisionRadius;
	Extent.Z = A.CollisionHeight;

	//trace from actor's location MoveDistance units along MoveDir using extents	
	HitActor = class'Util'.static.TraceRecursive( A, HitLocation, HitNormal, A.Location, false, , MoveDir, MoveDistance, Extent, TRACE_AllBlocking );

	return ( ( HitActor == None ) || ( VSize( HitLocation - A.Location ) >= MoveDistance ) );
}

//-----------------------------------------------------------------------------
// Put the given actor at the given location, but adjust location's Z value so
// the bottom of the actor's collision cylinder is touching the floor.
//
// Doesn't handled sloped surfaces currently (actor could end up intersecting
// surface). Probably not too great on stairs either.
//
// !!mdf-tbd: add an optional offset used instead of calculated one to avoid doing
// this 2x?
//
// !!mdf-tbd: turn into exec function which calls actor version or at least consolidate
// common functionality?

static final function bool PlaceActorOnFloorUnderLocation( Actor TargetActor, vector TargetLocation )
{
	local vector HitLocation, HitNormal;
	local vector NewLocation;
	local float HeightAboveFloor;
	local bool bRetVal;

	bRetVal = false;

	// trace down from target location to determine height above floor
	// !!mdf-tbd: instance actor probably isn't at either of the endpoints for the trace -- can
	// this cause problems? More generally, can't TraceRecursive fail or return incorrect
	// results if the desired HitLocation is inside the instance actor?

	class'Util'.static.TraceRecursive( TargetActor, HitLocation, HitNormal, TargetLocation, false, 500, , 500 );

	// !!mdf-tbf: this assumes a flat surface. Not sure but I think the engine might "pop" the 
	// TargetActor up if necessary on a sloped surface or on stairs etc. Not trivial to determine
	// (quickly) exactly how much vertical offset should be so that actor under/over given location
	// will *just* sit on the floor.
	HeightAboveFloor = VSize( TargetLocation - HitLocation );

	NewLocation = TargetLocation;
	NewLocation.Z += (TargetActor.CollisionHeight - HeightAboveFloor);
			   
	return TargetActor.SetLocation( NewLocation );
}

//-----------------------------------------------------------------------------
// !!mdf-tbd: really need to turn this into a native function which uses 
// MoveActor to drop the actor to the floor (after turning on collision 
// temporarily as needed). This function will likely fail for sloped surfaces.

static final function PlaceActorOnFloor( Actor A )
{
	local Actor HitActor;
	local vector HitLocation, HitNormal;

	// NOTE: can't use phys_falling etc. -- we might want this to happen right away
	HitActor = class'Util'.static.TraceRecursive( A, HitLocation, HitNormal, A.Location, false, 500, , 500 );
	if( HitActor != None )
	{
		if( !A.SetLocation( HitLocation + A.CollisionHeight*vect(0,0,1) ) )
			A.DMAssert( false, GetContext() );
	}
}

//-----------------------------------------------------------------------------
// If the NPC could be obstructed by geometry at the given location, find point 
// on ground slightly above/below given location that Pawn is likely able to 
// reach. For flying or swimming NPCs, only need to adjust if the point above 
// the ground is higher than the original location (i.e. fix NPCs flying or
// swimming into geometry but don't fix case where destination will cause NPC
// to fly/swim above the ground since that is ok unless the NPC is walking).

//!!mdf-tbd: return false if destination is in geometry and can't be adjusted?

static function AdjustDestinationForPhysics( Actor SourceActor, out vector DestinationLocation )
{
	local float TargetDistance;
	local vector OriginalLocation, AdjustedLocation, HitLocation, HitNormal;
	local Actor HitActor;

	OriginalLocation = DestinationLocation;

	//AddCylinder( OriginalLocation, 2, 2, ColorWhite() );
	
	TargetDistance = 1.25*VSize2D( DestinationLocation - SourceActor.Location );

	//SourceActor.DMTNS( "TargetDistance #1: " $ TargetDistance );
	// first trace up to make sure TargetDistance won't shift us up into
	// geometry above the original location.
	//AddArrow( DestinationLocation, DestinationLocation + FMax( TargetDistance*1.10, 1024.0 )*vect(0,0,1), ColorWhite() );
	HitActor = SourceActor.Trace( HitLocation, HitNormal, DestinationLocation + FMax( TargetDistance*1.10, 1024.0 )*vect(0,0,1), DestinationLocation, false );
	if( HitActor != None && HitLocation != DestinationLocation )
		TargetDistance = VSize( DestinationLocation - HitLocation );
	
	// raise destination location up enough to account for where Pawn could end up if
	// walking toward destination on a max steepness slope
	AdjustedLocation = DestinationLocation;
	AdjustedLocation.Z += TargetDistance;
	
	// trace down until we hit the ground (allow for sloped surface)
	//SourceActor.DMTNS( "TargetDistance #2: " $ TargetDistance );
	//AddArrow( AdjustedLocation, AdjustedLocation - FMax( TargetDistance*1.10, 1024.0 )*vect(0,0,1), ColorOrange() );
	//!!mdf-tbd: use moveactor with extents to do this (drop location back to ground) then eliminate fitactor at stuff?
	HitActor = SourceActor.Trace( HitLocation, HitNormal, AdjustedLocation - FMax( TargetDistance*1.10, 1024.0 )*vect(0,0,1), AdjustedLocation, false );
	if( HitActor != None )
	{
		// adjust destination location?
		AdjustedLocation = HitLocation;
		AdjustedLocation.Z += SourceActor.CollisionHeight + CCFloatHeight;
		//AddCylinder( AdjustedLocation, 4, 4, ColorYellow() );
		if( SourceActor.FitActorAt( AdjustedLocation ) != 0 ) // get engine to pop location out of geometry?
		{	
			if( SourceActor.Physics == PHYS_Walking )
			{
				// trace to ground again (location may have been pushed above the ground
				HitActor = SourceActor.Trace( HitLocation, HitNormal, AdjustedLocation - 128.0*vect(0,0,1), AdjustedLocation, false );
				if( HitActor != None )
				{
					AdjustedLocation = HitLocation;
					AdjustedLocation.Z += SourceActor.CollisionHeight + CCFloatHeight;
					DestinationLocation = AdjustedLocation; // walking creature has to stay on ground
				}
			}
			else if( AdjustedLocation.Z > DestinationLocation.Z )
				DestinationLocation = AdjustedLocation; // flying/swimming creature blocked by geometry?
				
			//AddCylinder( AdjustedLocation, 8, 8, ColorOrange() );
		}
	}
	
	#debugbegin
	//AddCylinder( OriginalLocation, 4, 4, ColorMagenta() );
	//if( DestinationLocation != OriginalLocation )
	//	AddArrow( OriginalLocation, DestinationLocation, ColorMagenta() );
	#debugend
}

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

static final function MakeShake( Actor Context, vector ShakeLocation, float ShakeRadius, float ShakeMagnitude, optional float ShakeDuration )
{
	local Controller C;
	local PlayerController Player;
	local float Dist,Pct;

	if( Context==None || ShakeRadius<=0 || ShakeMagnitude<=0 )
		return;

	for( C=Context.Level.ControllerList; C!=None; C=C.nextController )
	{
		Player = PlayerController(C);
		//NEW (mib) - don't shake a flying / ghosted player (leave shake in for matinee cutscenes)
		if( Player!=None &&
			(Player.Pawn==None || Player.Pawn.Physics != PHYS_Flying) )
		/*OLD
		if( Player!=None )
		*/
		{
			Dist = VSize(ShakeLocation-Player.Location);
			if( Dist<ShakeRadius )
			{
				Pct = 1.0 - (Dist / ShakeRadius);
				Player.ShakeView( ShakeMagnitude * Pct, ShakeDuration );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Copies display-related information from Source Actor to DestinationActor.

static final function CopyDisplaySettings( Actor Source, Actor Destination )
{
	local int i;

	for( i = 0; i < Destination.Skins.length; i++ )
	{
		Destination.Skins[ i ] = Source.Skins[ i ];
	}

	Destination.Mesh					= Source.Mesh;
	Destination.Mesh					= Source.Mesh;
	Destination.Texture					= Source.Texture;
	Destination.SetDrawScale			( Source.DrawScale );
	Destination.AnimSequence			= Source.AnimSequence;
	Destination.AnimFrame				= Source.AnimFrame;
	Destination.AnimRate				= Source.AnimRate;
	Destination.TweenRate				= Source.TweenRate;
	Destination.SimAnim.bAnimLoop		= Source.SimAnim.bAnimLoop;
	Destination.SimAnim.AnimFrame		= Source.AnimFrame * 10000;
	Destination.SimAnim.AnimRate		= Source.AnimRate  * 5000; 
	Destination.SimAnim.TweenRate		= Source.TweenRate * 1000; 
//!!cdh	Destination.SimAnim.W				= Source.AnimLast  * 10000;
	Destination.bAnimFinished			= Source.bAnimFinished;
	Destination.bSpecialLit				= Source.bSpecialLit;
}

static final function string GetAIDebugMessage( Controller C, string Prefix, coerce string Msg, optional coerce string StateStr, optional bool bSpace )
{
	local name ThisDebugName;
	local string ThisDebugNameStr;

	if( C.Pawn != None )
		ThisDebugName = C.Pawn.Name;
	else
		ThisDebugName = 'xxxx';

	if( default.LastDebugName != ThisDebugName )
	{
		if( bSpace )
			log( "", '' );
		default.LastDebugName = ThisDebugName;
	}

	// use real name for players (bots)
	if( C.PlayerReplicationInfo != None )
		ThisDebugNameStr = C.PlayerReplicationInfo.PlayerName;
	else
		ThisDebugNameStr = string(ThisDebugName);

	return ( class'Util'.static.GetPaddedTime( C.Level.TimeSeconds, TimeFieldSize, true ) @
			 class'Util'.static.PadString( Right( ThisDebugNameStr, NameFieldSize ), NameFieldSize ) @
			 class'Util'.static.PadString( StateStr, StateFieldSize ) @
			 class'Util'.static.PadString( Prefix, PrefixFieldSize ) @
			 Msg );
}

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

static final function LogAIDebugMessage( Controller C, string Prefix, coerce string Msg, optional coerce string StateStr, optional bool bSkipLine )
{
	local string HealthStr;
	
	if( C.Pawn != None )
		HealthStr = string(C.Pawn.Health);	
	else
		HealthStr = "NA";
		
	C.DM( GetAIDebugMessage( C, Prefix, Msg $ " (Controller: " $ C $ " Enemy: " $ C.ControllerEnemy $ " Health: " $ HealthStr $ ")", StateStr, true ) );
	if( bSkipLine )
		log( "", '' );
}

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

static final function DrawFace( Face F, Color Clr )
{
	local int i;
	for( i=0; i<F.Points.Length-1; i++ )
		AddLine( F.Points[ i ], F.Points[ i+1 ], Clr );

	AddLine( F.Points[ F.Points.Length-1 ], F.Points[ 0 ], Clr );
}

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

static final function bool VertexWithinDistance( Actor A, array<Face> Faces, float MaxDistance )
{
	local float Distance;
	local int ii, jj;
	
	for( ii=0; ii<Faces.Length; ii++ )
	{
		for( jj=0; jj<Faces[ jj ].Points.Length; jj++ )
		{
			Distance = VSize( A.Location - Faces[ ii ].Points[ jj ] );
			if( Distance < MaxDistance )
				return true;
		}
	}
	
	return false;
}

//-----------------------------------------------------------------------------
// Note: assumes that no edge in Faces is > MaxPathDistance units long (for the
// quick-filter test).

static final function bool UpdatePathsForBlockingFaces( Actor ContextActor, array<Face> Faces, float CostToAdd, int TeamNumber, array<ReachSpec> ModifiedReachSpecs )
{
	local int ii, jj;
	local vector IntersectionPoint;
	local NavigationPoint StartNP, EndNP;
	local ReachSpec RS;
	local Controller C;
	local float AddPathOffset;
	local bool bIntersects;
	local bool bModifiedPaths;
	
	//!!debug help
	//ContextActor.DMTNS( "Faces: " $ Faces.Length );
	//for( ii=0; ii<Faces.Length; ii++ )
	//	DrawFace( Faces[ ii ], ColorRed() );

	ModifiedReachSpecs.Length = 0;
	for( StartNP = ContextActor.Level.NavigationPointList; StartNP != None; StartNP = StartNP.nextNavigationPoint )
	{
		// NOTE: optimization don't bother to check points which are too far away 
		// from any point in the Faces list to possibly have a path through it.
		if( VertexWithinDistance( StartNP, Faces, MaxPathCheckRadius ) )
		{
			// look at all paths (reachspecs) out of this StartNP
			for( ii=0; ii<StartNP.PathList.Length; ii++ )
			{
				RS = StartNP.PathList[ ii ];
				EndNP = StartNP.PathList[ ii ].End;
				//ContextActor.DMTNS( "  checking NP2: " $ EndNP );
				if( VertexWithinDistance( EndNP, Faces, MaxPathCheckRadius ) )
				{
					// see if path out of StartNP passes through wall (all 6 sides -- can't use a bounding box as left/right might not be at same height)
					bIntersects = false;
					for( jj=0; jj<Faces.Length; jj++ )
					{	
						if( class'Util'.static.LineConvexPolygonIntersection( RS.Start.Location, EndNP.Location, Faces[ jj ].Points, IntersectionPoint ) )
						{
							bIntersects = true;
							break;
						}
					}

					if( bIntersects )												
					{
						ModifiedReachSpecs[ ModifiedReachSpecs.Length ] = RS;
						
						// enable/disable modify/restore any paths which pass through or near the wall
						RS.ExtraCost += CostToAdd;
						
						// is the reachspec back to 0 ExtraCost?
						if( RS.ExtraCost != 0 )
						{
							RS.SpecialTeamNumber = TeamNumber;
							RS.bSpecialCollision = true;
						}
						else
						{
							RS.SpecialTeamNumber = class'ReachSpec'.default.SpecialTeamNumber;
							RS.bSpecialCollision = false;
						}
						
						bModifiedPaths = true;
					}
				}
			}
		}
	}

	//mdf-tbr: for testing (so path colors updated instantlly) but pbly not adding much overhead
	if( bModifiedPaths )
	{
		for( C=ContextActor.Level.ControllerList; C!=None; C=C.nextController )
		{
			if( C.IsRealPlayer() )
			{
				C.ConsoleCommand( "paths refresh" );
				break;
			}
		}
	}
	
	return bModifiedPaths;
}

//-----------------------------------------------------------------------------
// 
static function bool CutsceneIsRunning( actor ContextActor )
{
	local SceneManager SM;
	foreach ContextActor.AllActors( class'SceneManager', SM )
	{
		if( SM.bIsRunning )
			return true;
	}
	return false;
}


//=============================================================================
//@ Projectile Motion 
//=============================================================================

static final function float GetGravityConstant( Actor SourceActor, class<Actor> ProjectileClass )
{
	if( ClassIsChildOf( ProjectileClass, class'Pawn' ) )
		return -PawnGravityFactor * SourceActor.PhysicsVolume.default.Gravity.Z;
	else
		return -NonPawnGravityFactor * SourceActor.PhysicsVolume.default.Gravity.Z;
}

/*-----------------------------------------------------------------------------
The range of a projectile (horizontal distance traveled before the projectile
is back at the starting height is given by:

	Range = speed^2 * sin( 2*theta ) / g

where

	speed = initial speed
	theta = initial angle above horizontal
	g     = gravity
	
Unreal's simulated physics are close enough to Newtonian physics for these
equations to work fine as long as the gravity is scaled by a "magic" fudge
factor to get the gravity "right".
*/

static final function float GetRange( Actor SourceActor, class<Actor> ProjectileClass, float ProjectileSpeed, float Theta )
{
	return ProjectileSpeed * ProjectileSpeed * sin( 2*Theta ) / GetGravityConstant( SourceActor, ProjectileClass );
}

/*-----------------------------------------------------------------------------
The maximum range of a projectile (see GetRange equation) occurs when the
sin( 2*Theta) component is maximized, which will occur when 2*Theta = 90 
degrees since sin(90) = 1.0.
	
	RangeMax = speed^2 / g
*/

static final function float GetMaxRange( Actor SourceActor, class<Actor> ProjectileClass, float ProjectileSpeed )
{
	return ProjectileSpeed * ProjectileSpeed / GetGravityConstant( SourceActor, ProjectileClass );
}

/*-----------------------------------------------------------------------------
The best reference for this is probably "Inverse Trajectory Determination" from
Game Programming Gems 2 (Aaron Nicholls).

If we have

V = initial velocity
X = target distance from start
Y = target elevation relative to start elevation
G = gravity

the angle needed to have the fired projectile pass through X,Y is given by

	Theta = invtan[ V^2[ -X +/- sqrt( (X^2 - G^2*X^4/V^4 + 2G*X^2*Y/V^2) / G*X^2 ) ]]

and the time to the target is given by

	T = X / (V * cos(Theta))

Returns the number of solutions found:

	0: target is outside of projectile's range (try 45 degrees?)
	1: target is at projectile's range
	2: target is inside projectile's range (high and low solutions)
	
Note that if the target is inside the projectile'salways be 2 solutions, one
using a lower/flatter trajectory, the other using a higher/more arcing 
trajectory. In general, the lower trajectory is more desirable as it will get
the projectile to the target more quickly, but there are cases where the higher
trajectory may be desired, e.g. to "mix up" shots or to shoot over an 
obstruction.

Use VerifyTrajectory to check whether the trajectory is likely to intersect
with any geometry.
*/

static final function int GetInverseTrajectory( 
	Actor SourceActor, 
	class<Actor> ProjectileClass, 
	float ProjectileSpeed, 
	vector StartLocation, 
	vector TargetLocation, 
	out float ThetaLow, 
	out float ThetaHigh, 
	out float InterceptTimeLow, 
	out float InterceptTimeHigh )
{
	local float V;
	local float G;
	local float X, Y;
	local float Root, SquareRoot;
	local float XSquared, VSquared, GXSquared;
	local float TempFloat;
	local int NumSolutions;

	if( ProjectileSpeed ~= 0.0 )
		return 0;

	V = ProjectileSpeed;
	X = VSize2D( TargetLocation - StartLocation );
	Y = -(TargetLocation.Z - StartLocation.Z);
	
	G = GetGravityConstant( SourceActor, ProjectileClass );

	//SourceActor.DMTNS( "GetInveseTrajectory BEGIN" );
	//SourceActor.DMTNS( "  TargetDistance:  " $ VSize( TargetLocation - StartLocation ) );
	//SourceActor.DMTNS( "  ProjectileSpeed: " $ ProjectileSpeed );
	//SourceActor.DMTNS( "  Gravity:         " $ G );
	//SourceActor.DMTNS( "  MaxRange (flat): " $ GetMaxRange( SourceActor, ProjectileClass, ProjectileSpeed ) );
	
	XSquared = X*X;		
	VSquared = V*V;
	
	Root = XSquared - (G*G*XSquared*XSquared/(VSquared*VSquared)) + (2*G*XSquared*Y/VSquared);
	
	//SourceActor.DMTNS( "  V:    " $ V );
	//SourceActor.DMTNS( "  G:    " $ G );
	//SourceActor.DMTNS( "  X:    " $ X );
	//SourceActor.DMTNS( "  Y:    " $ Y );
	//SourceActor.DMTNS( "  Root: " $ Root );
	
	if( Root < 0 )
	{
		NumSolutions = 0;
	}
	else
	{
		GXSquared = G*XSquared;
			
		if( Root ~= 0 )
		{
			ThetaLow = ATan( -X / G*XSquared );
			ThetaHigh = ThetaLow;

			InterceptTimeLow = X / (V * Cos( ThetaLow ));
			InterceptTimeHigh = InterceptTimeLow;
			
			NumSolutions = 1;
		}
		else
		{
			SquareRoot = Sqrt( Root );
			
			ThetaLow = ATan( VSquared*(-X + SquareRoot) / GXSquared );
			ThetaHigh = ATan( VSquared*(-X - SquareRoot) / GXSquared );
			
			if( Abs( ThetaHigh ) < Abs( ThetaLow ) )
			{
				//SourceActor.DMT( "  swapping ThetaLo and ThetaHi" );
				TempFloat = ThetaHigh;
				ThetaHigh = ThetaLow;
				ThetaLow = TempFloat;
			}
			
			InterceptTimeLow = X / (V * Cos( ThetaLow ));
			InterceptTimeHigh = X / (V * Cos( ThetaHigh ));
			
			NumSolutions = 2;
		}
	}
	
	//SourceActor.DMTNS( "  ThetaLow:  " $ ThetaLow $  " Time: " $ InterceptTimeLow );
	//SourceActor.DMTNS( "  ThetaHigh: " $ ThetaHigh $ " Time: " $ InterceptTimeHigh );
	//SourceActor.DMTNS( "GetInveseTrajectory END  NumSolutions: " $ NumSolutions );
	
	return NumSolutions;
}

/*-----------------------------------------------------------------------------
Return false if any of several lines along trajectory are blocked by anything
apart from the target actor. Also return false if the projectile won't arive 
before it expires (non-zero LifeSpan).

The location of the projectile at time T is given by:

	X = X0 + Vx * t
	Y = Y0 + Vy * t + 1/2 * gt^2

or, if we shift the projectile start to the origin:

	X = Vx * t
	Y = Vy * t + 1/2 * gt^2	
	
where

X0 = starting X position
Y0 = starting Y position
Vx = horizontal component of initial velocity
Vy = vertical component of initial velocity
G  = gravity

and
	
	Vx = V * cos( Theta )
	Vy = V * sin( Theta )
*/

static final function bool VerifyTrajectory( 
	Actor SourceActor, 
	class<Actor> ProjectileClass, 
	float ProjectileSpeed, 
	vector StartLocation, 
	vector TargetLocation, 
	Actor TargetActor, 
	float Theta, 
	optional float InterceptTime, 
	optional vector Extents, 
	optional float MinTimeOutDistance )
{
	local float G;
	local float X, Y;
	local float VX, VY;
	local float SampleTime, TimeIncrement;
	local int ii;
	local vector SampleLocation, PreviousLocation, ProjectileDirection;
	local Actor HitActor;
	local vector HitNormal, HitLocation;
	local bool bValid;
	
	//SourceActor.DMTNS( "VerifyTrajectory BEGIN" );
	//SourceActor.DMTNS( "  Theta: " $ Theta );
	
	//AddCylinder( StartLocation, 4, 4, ColorWhite() );
	//AddCylinder( TargetLocation, 4, 4, ColorWhite() );

	bValid = true;

	if( InterceptTime <= 0.0 )
	{
		if( ProjectileSpeed ~= 0.0 )
		{
			bValid = false;
		}
		else
		{
			// caller wants us to determine the intercept time
			InterceptTime = VSize2D( TargetLocation - StartLocation) / (ProjectileSpeed * cos( Theta ) );
			//SourceActor.DMTNS( "  InterceptTime: " $ InterceptTime );
		}
	}
	
	VX = ProjectileSpeed * cos( Theta );
	VY = ProjectileSpeed * sin( Theta );

	G = GetGravityConstant( SourceActor, ProjectileClass );

	ProjectileDirection = TargetLocation - StartLocation;
	ProjectileDirection.Z = 0;
	ProjectileDirection = Normal( ProjectileDirection );

	// return false if the projectile be within X units of the target before it expires
	if( ProjectileClass != None && ProjectileClass.default.LifeSpan > 0.0 && InterceptTime > ProjectileClass.default.LifeSpan )
	{
		//SourceActor.DMTNS( "  Projectile LifeSpan too short checking timeout distance  InterceptTime: " $ InterceptTime );
		
		SampleTime = ProjectileClass.default.LifeSpan;
		
		X = VX * SampleTime;
		Y = VY * SampleTime + 0.5 * G * SampleTime*SampleTime;

		SampleLocation = StartLocation + X * ProjectileDirection;
		SampleLocation.Z = SampleLocation.Z - Y;
		if( VSize( SampleLocation - TargetLocation ) > MinTimeOutDistance )
			bValid = false;
	}

	if( bValid )
	{
		SampleTime = 0.0;
		TimeIncrement = InterceptTime / default.VerifyTrajectorySamples;

		//AddCylinder( StartLocation, 4, 4, ColorYellow() );
		
		//SourceActor.DMTNS( "  TargetActor: " $ TargetActor $ " Gravity: " $ G $ " target distance: " $ VSize( TargetLocation - StartLocation ) $ " TargetHeight: " $ TargetLocation.Z );
		
		PreviousLocation = StartLocation;
		PreviousLocation.Z += default.VerifyTrajectoryVerticalExtentPadding; // so first trace doesn't hit level below source
		
		// needed since the predicted trajectory isn't exactly what we'll get (should be dead-on in X/Y though)
		Extents.X += default.VerifyTrajectoryHorizontalExtentPadding;
		Extents.Y += default.VerifyTrajectoryHorizontalExtentPadding;
		Extents.Z += default.VerifyTrajectoryVerticalExtentPadding;
		
		for( ii=0; ii<default.VerifyTrajectorySamples; ii++ )
		{
			//!!hack: if "projectile" is a pawn, back up the last sample somewhat
			//if( ii == (default.VerifyTrajectorySamples-1) && ClassIsChildOf( ProjectileClass, class'Pawn' ) )
			//	TimeIncrement *= 0.5;

			SampleTime += TimeIncrement;
			
			X = VX * SampleTime;
			Y = VY * SampleTime + 0.5 * G * SampleTime*SampleTime;

			SampleLocation = StartLocation + X * ProjectileDirection;
			SampleLocation.Z = SampleLocation.Z - Y;

			// for the last sample, shift the location up by vertical padding or else 
			// we'll pbly trace into the world geometry below the target locationa
			if( ii == (default.VerifyTrajectorySamples-1) )
			{
				//SourceActor.DMTNS( "  Shifting SampleLocation up by " $ default.VerifyTrajectoryVerticalExtentPadding );
				SampleLocation.Z += default.VerifyTrajectoryVerticalExtentPadding;
			}
			//SourceActor.DMTNS( "  X: " $ X $ " Y: " $ Y $ " Height: " $ SampleLocation.Z );
			
			//!!mdf-tbd: should we worry about (dynamic) actors when tracing?
			// yes, so we'll hit XMP items?
			HitActor = SourceActor.Trace( HitLocation, HitNormal, SampleLocation, PreviousLocation, false, Extents, , TRACE_AllBlocking );
			//HitActor = SourceActor.Trace( HitLocation, HitNormal, SampleLocation, PreviousLocation, false, Extents, , TRACE_World );
			
			if( HitActor == None )
			{
				//!!mdf-tbd: static meshes don't generally block extent traces so try a no-extent trace
				//this might catch some cases but without proper extent collision it won't be perfect
				//this check can be removed if we assume that levels with the GL used by NPCs or
				//leaping NPCs will have extent collision added as needed.
				//!!mdf-tbd: possible optimization, especially in areas with low ceilings
				// check the entire trajectory with single line traces first
				HitActor = SourceActor.Trace( HitLocation, HitNormal, SampleLocation, PreviousLocation, false, vect(0,0,0), , TRACE_World );
				
				//if( HitActor != None && HitActor != TargetActor )
				//	SourceActor.DMTNS( "  no-extent trace hit " $ HitActor );
			}
			
			if( HitActor != None && HitActor != TargetActor && Theta ~= -Radians45 )
			{
				//SourceActor.DMTNS( "  checking for max range hit" );
				//SourceActor.DMTNS( "    SampleLocation.Z: " $ SampleLocation.Z );
				//SourceActor.DMTNS( "    TargetLocation.Z: " $ TargetLocation.Z );
				// hack for using maximum range -- allow a hit below or past target location
				if( SampleLocation.Z < TargetLocation.Z )
					HitActor = TargetActor;
			}
		
			//!!tbd: call OKToHit on HitActor instead of just checking if we hit TargetActor?
			if( HitActor != None && HitActor != TargetActor )
			{
				//SourceActor.DMTNS( "  failed - hit: " $ HitActor $ " instead of " $ TargetActor );
				//AddArrow( PreviousLocation, SampleLocation, ColorRed() );
				//AddCylinder( SampleLocation, Extents.X, Extents.Z, ColorRed() );
				bValid = false;
				break;
			}
			else
			{
				//AddArrow( PreviousLocation, SampleLocation, ColorYellow() );
			}
			
			if( HitActor == TargetActor )
				break;
						
			PreviousLocation = SampleLocation;
		}
	}
	
	//SourceActor.DMTNS( "VerifyTrajectory END: " $ bValid );
	
	return bValid;
}

/*-----------------------------------------------------------------------------
Wrapper for GetInverseTrajectory / VerifyTrajectory. Calculates solution for
specified trajectory (low and/or high) then verifies that the trajector is 
valid.
*/

static final function bool GetVerifiedInverseTrajectory( 
	Actor SourceActor, 
	class<Actor> ProjectileClass, 
	float ProjectileSpeed, 
	vector StartLocation, 
	vector TargetLocation, 
	Actor TargetActor, 
	ETrajectoryType TrajectoryType, 
	out float Theta, 
	out float InterceptTime, 
	optional vector Extents, 
	optional float MinTimeOutDistance )
{
	local int NumSolutions;
	local float ThetaLow, ThetaHigh, InterceptTimeLow, InterceptTimeHigh;
	local bool bTriedHi;
	local bool bSuccess;
		
	//SourceActor.DMTNS( "GetVerifiedInverseTrajectory BEGIN" );
	NumSolutions = GetInverseTrajectory( SourceActor, ProjectileClass, ProjectileSpeed, StartLocation, TargetLocation, ThetaLow, ThetaHigh, InterceptTimeLow, InterceptTimeHigh );

	//SourceActor.DMTNS( "  NumSolutions: " $ NumSolutions );
	if( NumSolutions == 1 )
	{
		// only one trajectory (45 degrees)
		//SourceActor.DMTNS( "  checking only solution (45 degrees)" );
		if( VerifyTrajectory( SourceActor, ProjectileClass, ProjectileSpeed, StartLocation, TargetLocation, TargetActor, ThetaLow, InterceptTimeLow, Extents, MinTimeOutDistance ) )
		{
			Theta = ThetaLow;
			InterceptTime = InterceptTimeLow;
			bSuccess = true;
		}
	}
	else if( NumSolutions == 2 )
	{
		// 2 possible trajectories
		if( TrajectoryType == TRAJ_High || TrajectoryType == TRAJ_PreferHigh )
		{
			// try high first
			//SourceActor.DMTNS( "  checking high solution" );
			Theta = ThetaHigh;
			InterceptTime = InterceptTimeHigh;
			bTriedHi = true;
		}
		else
		{
			// try low first
			//SourceActor.DMTNS( "  checking low solution" );
			Theta = ThetaLow;
			InterceptTime = InterceptTimeLow;
			bSuccess = true;
		}

		bSuccess = VerifyTrajectory( SourceActor, ProjectileClass, ProjectileSpeed, StartLocation, TargetLocation, TargetActor, Theta, InterceptTime, Extents, MinTimeOutDistance );
		
		if( !bSuccess && TrajectoryType != TRAJ_High && TrajectoryType != TRAJ_Low )
		{
			if( bTriedHi )
			{
				// now check low
				//SourceActor.DMTNS( "  checking low solution" );
				Theta = ThetaLow;
				InterceptTime = InterceptTimeLow;
			}
			else
			{
				// now check high
				//SourceActor.DMTNS( "  checking high solution" );
				Theta = ThetaHigh;
				InterceptTime = InterceptTimeHigh;
			}
			
			bSuccess = VerifyTrajectory( SourceActor, ProjectileClass, ProjectileSpeed, StartLocation, TargetLocation, TargetActor, Theta, InterceptTime, Extents, MinTimeOutDistance );
		}
	}
	
	//SourceActor.DMTNS( "GetVerifiedInverseTrajectory END  bSuccess: " $ bSuccess );
	return bSuccess;		
}
		
//-----------------------------------------------------------------------------

static final function ELeapResult VerifyLeapParameters( 
	Actor SourceActor, 
	class<Actor> ProjectileClass, 
	float ProjectileSpeed, 
	vector TargetLocation, 
	vector StartLocation, 
	Actor TargetActor, 
	ETrajectoryType TrajectoryType, 
	out float Theta, 
	optional vector Extents )
{
	local float InterceptTime;
	local ELeapResult Result;

	// don't bother with trajectory calculation if predicted location isn't within range 
	if( VSize( TargetLocation - SourceActor.Location ) > GetMaxRange( SourceActor, ProjectileClass, ProjectileSpeed ) )
	{
		Result = LR_OutOfRange;
	}
	else if( !GetVerifiedInverseTrajectory( 
		SourceActor, 
		ProjectileClass, 
		ProjectileSpeed, 
		SourceActor.Location, 
		TargetLocation, 
		TargetActor, 
		TrajectoryType, 
		Theta, 
		InterceptTime, 
		Extents ) )
	{
		Result = LR_None;
	}
	else if( Normal( TargetLocation - SourceActor.Location ) dot vector( SourceActor.Rotation ) < 0.707 )
	{
		Result = LR_OutOfAngle;
	}
	else
	{
		Result = LR_Success;
	}
	
	//SourceActor.DMTNS( "  VerifyLeapParameters returning " $ EnumStr( enum'ELeapResult', Result ) );
	return Result;
}
	
//=============================================================================
//@ Aiming
//=============================================================================

static final function vector GetRotatedFireStart( Pawn SourcePawn, vector SourceLocation, rotator TargetRotation, vector FireOffset )
{
	local vector X, Y, Z;
	local vector ReturnedFireStart;
	
	GetAxes( TargetRotation, X, Y, Z );
	
	ReturnedFireStart = SourceLocation + SourcePawn.EyePosition() + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z;
	
	// prone NPCs are getting a fire start that is in the ground?
	ReturnedFireStart.Z = FMax( SourceLocation.Z - 0.5*SourcePawn.CollisionHeight, ReturnedFireStart.Z );
	
	//SourcePawn.DMTNS( "GetRotatedFireStart returning " $ ReturnedFireStart );
	//SourcePawn.DMTNS( "  TargetRotation: " $ TargetRotation );
	//SourcePawn.DMTNS( "  EyePosition:    " $ TargetPawn.EyePosition() );
	return ReturnedFireStart;
}

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

static final function bool TryToHit( 
	Actor AimingActor,
	Actor TargetActor, 
	float TargetDistance,
	float SpreadDegrees,						// weapon firing spread -- increases trytohit odds with increasing distance
	float LastHitTime,
	float MaxAffectedByHitTime,
	float LastAcquisitionTime,
	float MaxAffectedByAcquisitionTime,
	float TryToHitBaseOddsMin, 
	float TryToHitBaseOddsMax, 
	float TryToHitBaseDistance, 
	float TryToHitMinMissDistance, 
	float TryToHitMaxHitDistance,
	optional float TryToHitBaseSpeed,
	optional float TryToHitBaseSpeedOdds )
{
	local float TryToHitOdds;
	local float SizeRelativeVelocity;
	local float TimeSinceLastHit;
	local float TimeSinceLastAcquired;
	
	TryToHitOdds = TryToHitBaseOddsMin + (TryToHitBaseOddsMax - TryToHitBaseOddsMin) * AimingActor.GetSkill();

	#debugbegin
	//AimingActor.DMT( "TryToHit (" $ AimingActor.GetStateName() $ ")" );
	//AimingActor.DMT( "  Initial Odds:         " $ TryToHitOdds );
	//AimingActor.DMT( "  Relative Velocity:    " $ VSize( TargetActor.Velocity - AimingActor.Velocity ) );
	//AimingActor.DMT( "  TimeSinceLastHit:     " $ AimingActor.Level.TimeSeconds - LastHitTime );
	//AimingActor.DMT( "  TimeSinceLastAcquired: " $ AimingActor.Level.TimeSeconds - LastAcquisitionTime );
	#debugend
	
	// modify base odds depending on distance
	if( TargetDistance > TryToHitMaxHitDistance )
		TryToHitOdds = 0.0;
	else if( TargetDistance < TryToHitMinMissDistance )
		TryToHitOdds = 1.0;
	else if( TargetDistance < TryToHitBaseDistance )
		TryToHitOdds += (1.0 - TryToHitOdds) * ((TryToHitBaseDistance - TargetDistance) / (TryToHitBaseDistance - TryToHitMinMissDistance));
	else if( TargetDistance > TryToHitBaseDistance )
		TryToHitOdds += -TryToHitOdds * ((TargetDistance - TryToHitBaseDistance) / (TryToHitMaxHitDistance - TryToHitBaseDistance));

	//#debug AimingActor.DMT( "  TryToHitOdds (distance): " $ TryToHitOdds );
	
	if( SpreadDegrees > 0.0 && TargetDistance > default.MinModifyForSpreadDistance )
	{
		//#debug AimingActor.DMT( "  SpreadDegrees:" $ SpreadDegrees );
		// if weapon has a spread (e.g. the AR primary) increase odds of trying to hit
		// with distance wrt spread at targetdistance vs target radius (i.e. small
		// target at great distance will be missed most of the time even if aiming
		// right at the target).
		TryToHitOdds = TryToHitOdds * TargetDistance * sin( 0.5*DegreesToRadians*SpreadDegrees ) / TargetActor.CollisionRadius;
	}
	
	//#debug AimingActor.DMT( "  TryToHitOdds (spread): " $ TryToHitOdds );
	
	//!!mdf-tbd used to control this with bUsePhysics param but uc doesn't allow > 16 
	// params so just do this if AimingActor is a Pawn for now.
	if( Pawn(AimingActor) != None )
	{
		// aiming actor should have aim affected by target's physics
		if( TryToHitOdds > 0.0 && TryToHitBaseSpeed > 0.0 && TryToHitBaseSpeedOdds > 0.0 )
		{
			// decrease odds of hit with increasing relative velocity
			SizeRelativeVelocity = VSize( TargetActor.Velocity - AimingActor.Velocity );
			
			if( SizeRelativeVelocity <= TryToHitBaseSpeed )
				TryToHitOdds *= 1.0 - (1.0-TryToHitBaseSpeedOdds)*(SizeRelativeVelocity / TryToHitBaseSpeed);
			else
				TryToHitOdds *= TryToHitBaseSpeedOdds*(TryToHitBaseSpeed / SizeRelativeVelocity);
				
			//#debug AimingActor.DMT( "  TryToHitOdds (velocity): " $ TryToHitOdds );
		}

		if( TryToHitOdds > 0.0 )
		{
			TimeSinceLastHit = AimingActor.Level.TimeSeconds - LastHitTime;
			if( TimeSinceLastHit < MaxAffectedByHitTime )
			{
				// decrease odds of hit due to being hit recently
				TryToHitOdds *= TimeSinceLastHit / MaxAffectedByHitTime;
				//#debug AimingActor.DMT( "  TryToHitOdds (hit): " $ TryToHitOdds );
			}
			
			TimeSinceLastAcquired = AimingActor.Level.TimeSeconds - LastAcquisitionTime;
			if( TimeSinceLastAcquired < MaxAffectedByAcquisitionTime )
			{
				// decrease odds of hit due to target being acquired recently
				TryToHitOdds *= TimeSinceLastAcquired / MaxAffectedByAcquisitionTime;
				//#debug AimingActor.DMT( "  TryToHitOdds (acquisition): " $ TryToHitOdds );
			}

			if( AimingActor.Physics == PHYS_Falling )
			{
				// decrease odds of hit due to NPC falling (note: relative velocity considered above instead of here)
				TryToHitOdds *= 0.5;
				//#debug AimingActor.DMT( "  TryToHitOdds (NPC falling): " $ TryToHitOdds );
			}
		
			if( TargetActor.Physics == PHYS_Falling )
			{
				// decrease odds of hit due to target falling (note: relative velocity considered above instead of here)
				TryToHitOdds *= 0.5;
				//#debug AimingActor.DMT( "  TryToHitOdds (target falling): " $ TryToHitOdds );
			}
		}
	}

	//!!mdf-tbd: maybe increase odds of hitting stationary non-Pawn targets?	
	//#debug AimingActor.DMT( "TryToHit  Final Odds: " $ TryToHitOdds );
	
	TryToHitOdds = FClamp( TryToHitOdds, 0.0, 1.0 );

	return ( FRand() <= TryToHitOdds );
}

/*-----------------------------------------------------------------------------
Determine a good vector along which to intentionally miss the given target
actor based on the direction that the actor is facing. If the actor is an NPC
or if the actor (player) is generally facing the NPC, the NPC shouldn't favor 
missing in either direction (ReverseOdds ~0.50), otherwise, the NPC should try 
to miss along the given vector (ReverseOdds < 0.50) so that the player sees the
shots pass in front of him for greater effect.
*/

static final function vector GetMissVector( 
	Actor AimingActor,
	Actor TargetActor, 
	float LastHitTime,
	float MaxAffectedByHitTime,
	float MaxHitMissMultiplier,
	float MinHitPitchError,
	float MaxHitPitchError,	
	float LastAcquisitionTime,
	float MaxAffectedByAcquisitionTime,
	float MaxAcquireMissMultiplier,
	float MinAcquirePitchError,
	float MaxAcquirePitchError,
	bool bTargetObscured,					// true ==> don't have LOS to target (e.g. smoke in way)
	out int PitchError )
{
	local vector TargetVector;
	local vector TargetFacingVector;
	local vector MissVector;
	local float CosFacingAngle;
	local float ReverseOdds;
	local float TimeSinceLastHit;
	local float TimeSinceLastAcquired;
	local float PitchAdjustMultiplier;
	local int AddedPitchError;
	
	TargetVector = Normal( AimingActor.Location - TargetActor.Location );
	TargetFacingVector = vector(TargetActor.Rotation);
	CosFacingAngle = TargetVector dot TargetFacingVector;
	//DMTNS( "angle: " $ RadiansToDegrees * ACos( CosFacingAngle ) $ "(" $ CosFacingAngle $ ")" );
	
	if( TargetActor.IsRealPlayer() && Abs( CosFacingAngle ) < 0.866 )
	{
		//DMTNS( "target not facing NPC" );
//		ReverseOdds = 0.25; // player generally facing across firing direction -- favor shots in front 
		ReverseOdds = 0.0; // player generally facing across firing direction -- favor shots in front 
	}
	else
	{
		//DMTNS( "target facing NPC" );
		ReverseOdds = 0.50; // player generally facing along firing direction -- don't favor shots in front 
	}

	//DMTNS( "ReverseOdds: " $ ReverseOdds );
	
	MissVector = Normal( TargetVector cross vect(0,0,1) ); // vector across firing direction
	
	if( (MissVector dot TargetFacingVector) < 0 )
		MissVector = -MissVector;
			
	if( FDecision( ReverseOdds ) )
		MissVector = -MissVector;

	// when missing, miss by more than usual if recently hit?
	TimeSinceLastHit = AimingActor.Level.TimeSeconds - LastHitTime;
	if( TimeSinceLastHit < MaxAffectedByHitTime )
	{
		MissVector *= MaxHitMissMultiplier*(MaxAffectedByHitTime - TimeSinceLastHit);
		AddedPitchError = (MaxHitPitchError - FRand()*(MaxHitPitchError - MinHitPitchError))*(MaxAffectedByHitTime - TimeSinceLastHit);
		PitchError += AddedPitchError;

		//AimingActor.DMTNS( "increased PitchError by " $ AddedPitchError $ " due to taking hit " $ TimeSinceLastHit $ " secs ago" );
	}
	
	// when missing, miss by more than usual if recently acquired?
	TimeSinceLastAcquired = AimingActor.Level.TimeSeconds - LastAcquisitionTime;
	if( TimeSinceLastAcquired < MaxAffectedByAcquisitionTime )
	{
		MissVector *= MaxAcquireMissMultiplier*(MaxAffectedByAcquisitionTime - TimeSinceLastAcquired);
		AddedPitchError = (MaxAcquirePitchError - FRand()*(MaxAcquirePitchError - MinAcquirePitchError))*(MaxAffectedByAcquisitionTime - TimeSinceLastAcquired);
		PitchError += AddedPitchError;
		
		//AimingActor.DMTNS( "increased PitchError by " $ AddedPitchError $ " due to acquired " $ TimeSinceLastAcquired $ " secs ago" );
	}
	
	if( bTargetObscured )
	{
		MissVector *= default.MinTargetBlockedMissMultiplier + default.MaxTargetBlockedMissMultiplier * FRand();
		AddedPitchError = default.MinTargetBlockedPitchError - FRand()*(default.MaxTargetBlockedPitchError - default.MinTargetBlockedPitchError);
		PitchError += AddedPitchError;
		
		//AimingActor.DMTNS( "increased PitchError by " $ AddedPitchError $ " due to target being obscured" );
	}
	
	// scale pitch error depending on how much target is facing aiming actor
	// so shots generally tend to pass in front of the target (more exciting)
	if( TargetActor.IsRealPlayer() )
	{
		// scale by 1.0 (target facing aiming actor) to 0.1 (target facing completely across firing direction or away from aiming actor)
		PitchAdjustMultiplier = FMax( 0.1, 0.9 * CosFacingAngle + 0.1 );
		PitchError *= PitchAdjustMultiplier;
	}
	
	PitchError = FClamp( PitchError, default.MinPitchError, default.MaxPitchError );
	
	//AddArrow( TargetActor.Location, TargetActor.Location + 64.0*MissVector, ColorCyan() );
	
	return MissVector;
}
			
//-----------------------------------------------------------------------------
// Returns false for cases where there is no solution, otherwise sets 
// AimingDestination to the location to move to/fire at to reach the target.
// NOTE: predicts where AimingActor and TargetActor might meet but doesn't
// check to see whether those locations are actually reachable.

static final function bool GetAimingDestination( 
	Actor AimingActor, 
	float AimingSpeed, 
	float DelayTime,					// optional additional delay before aiming actor will start moving
	Actor TargetActor,
	out vector AimingDestination )
{
	local vector TargetLocation;
	local vector InitialAimingVector;								// vector from target to actor
	local vector TargetVelocity;
	local float TargetSpeed, TargetSpeedSquared;					// speeds convenience vars
	local float InitialAimingDistance, cosY;						// intermediate calcs
	local float a, b, c;											// quadratic vars
	local float InterceptDistance1, InterceptDistance2;				// 2 possible solutions				
	local float BestInterceptDistance;
	local float InterceptTime;										// time 
	#debugbegin	
	// for testing the result
	local vector PredictedTargetActorLocation; 
	local vector PredictedAimingActorLocation;
	local float PredictedDistanceDelta;
	#debugend	
	local bool bResult;

	//AimingActor.DMTNS( "GetAimingDestination Actor: " $ AimingActor $ " Speed: " $ AimingSpeed $ " Target: " $ TargetActor $ " Target Speed: " $ VSize( TargetActor.Velocity ) );	
	if( AimingSpeed <= 0.0 )
		warn( "GetAimingDestination: AimingSpeed is <= 0.0!" );
		
	TargetSpeed = VSize( TargetActor.Velocity );
	if( TargetSpeed ~= 0.0 )
	{
		// special case: target isn't moving
		AimingDestination = TargetActor.Location;
		bResult = true;
	}
	//else if( TargetActor.Physics == PHYS_Falling && TargetActor.Velocity.Z > 0 )
	else if( TargetActor.Physics == PHYS_Falling && TargetActor.Velocity.Z > 0 )
	{
		// special case: target is "falling up"
		
		// hack "solution": predict where NPC will land and assume projectile
		// speed will always be high enough to intercept that location? 
		AimingDestination = TargetActor.FallLanding( TargetActor.Location, TargetActor.Velocity );
		bResult = true;
	}
	else 
	{
		/*!!mdf-tbd: current behavior good enough?
		if( TargetActor.Physics == PHYS_Falling )
		{
			// special case: target is falling (down)
			
			// predict where NPC will land, then use that location + 2D part of
			// current velocity to predict where target will end up? 
		}
		*/
		
		// Label a triangle XYZ with AimingActor's location, TargetActor's initial location, the Intercept location, respectively
		// Let the sides be defined as:
		//		x = TargetActor initial location <---> Intercept location
		//		y = AimingActor initial location <---> Intercept location
		//		z = AimingActor initial location <---> TargetActor initial location (=InitialAimingDistance)
		//
		// Algorithm:
		//	1. InitialAimingVector = AimingActorLocation - AimingTargetLocation   z = | InitialAimingVector |
		// 	2. cosY = Vm dot (z) / ( |Vm| |La-Lm|)
		//	3. The Cosine Law will give us a function of x and y (in terms of z and cosY)
		//		y^2 = x^2 + z^2 - 2*x*z*cos( Y )
		//	4. At the time of intercept:  y / AimingTargetSpeed = x / AimingSpeed
		//	5. Solve 4. for y and substitute back into 3:
		//	6. Simplify the quadratic into the form:  ax^2 + bx + c = 0
		//	7. Apply quadratic rule: x = -b +/- sqrt( b^2 - 4ac ) / 2a
		//	8. Intercept location is x units along the TargetActor's velocity vector
		//	9. Intercept direction = Intercept location - AimingActor location

		// shift target location back/forward in time depending on delay
		TargetLocation = TargetActor.Location + DelayTime * TargetActor.Velocity;

		#debugbegin
		if( DelayTime != 0.0 )
		{
			//AimingActor.DMTNS( "shifting target location to allow for a delay of " $ DelayTime $ " secs");
			//AddArrow( TargetActor.Location, TargetLocation, ColorOrange() );
		}
		#debugend
		
		TargetSpeedSquared = TargetSpeed * TargetSpeed;

		// vector and magnitude of initial location difference
		InitialAimingVector = AimingActor.Location - TargetLocation;
		InitialAimingDistance = VSize( InitialAimingVector );

		cosY = Normal( TargetActor.Velocity ) dot Normal( InitialAimingVector );

		a = AimingSpeed * AimingSpeed - TargetSpeedSquared;
		b = 2 * InitialAimingDistance * TargetSpeedSquared * cosY; 
		c = -TargetSpeedSquared * InitialAimingDistance * InitialAimingDistance;

		if( class'Util'.static.GetQuadraticSolutions( a, b, c, InterceptDistance1, InterceptDistance2 ) > 0 )
		{
			// choose smallest positive solution (so NPC doesn't back up to intercept location)
			if( InterceptDistance1 < 0 )
				BestInterceptDistance = InterceptDistance2;
			else if( InterceptDistance2 < 0 )
				BestInterceptDistance = InterceptDistance1;
			else
				BestInterceptDistance = FMin( InterceptDistance1, InterceptDistance2 );

			InterceptTime = BestInterceptDistance / TargetSpeed;
			
			#debugbegin
			//AimingActor.DMTNS( "  InterceptTime: " $ InterceptTime );
			#debugend
			if( InterceptTime >= 0 )
			{
				AimingDestination = TargetLocation + InterceptTime * TargetActor.Velocity;

				#debugbegin
				// enable this code to verify result
				PredictedTargetActorLocation = TargetLocation + InterceptTime * TargetActor.Velocity;
				PredictedAimingActorLocation = AimingActor.Location + InterceptTime * Normal(AimingDestination - AimingActor.Location) * AimingSpeed;
				PredictedDistanceDelta = VSize( PredictedTargetActorLocation - PredictedAimingActorLocation );
				
				//if( PredictedDistanceDelta > 1.0 )
				//	AimingActor.DMTNS( "WARNING: GetAimingDestination: Predicted intercept is off by:" @ PredictedDistanceDelta @ "units" );
				#debugend
					
				bResult = true;
			}
		}
	}

#debugbegin
	// afaict, as long as the aiming speed is > the speed of the target, there should always be a solution
	AimingActor.DMAssert( bResult || AimingSpeed <= TargetSpeed, GetContext() );
#debugend	
	//AddArrow( AimingActor.Location, AimingDestination );
	//AddCylinder( AimingDestination, 4, 4 );
	
	return bResult;
}

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

static final function GetBestPredictedLocation( 
	Actor AimingActor, 
	Actor TargetActor, 
	float ClosingSpeed, 
	float DelayTime,
	out vector PredictedLocation )
{
	local bool bResult;
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	
	// predict where Enemy is headed
	bResult = GetAimingDestination( AimingActor, ClosingSpeed, DelayTime, TargetActor, PredictedLocation );

	// tbd: need to do an extent trace and/or full reachability check?
	// reachability could be optional, e.g. dumb creatures might blindly attack enemy?
	// mdf-tbd: pointreachable should be in Actor?
	//if( !PointReachable( PredictedLocation ) || !TargetActor.PointReachable( PredictedLocation ) )
	//	PredictedLocation = TargetActor.Location;
	if( !bResult )
	{
		//AimingActor.DMTNS( "GetBestPredictedLocation no solution -- looking at where TargetActor will be blocked" );
		//PredictedLocation = TargetActor.Location;
		HitActor = class'Util'.static.TraceRecursive( AimingActor, HitLocation, HitNormal, TargetActor.Location, false, , TargetActor.Velocity, , , TRACE_World );
		if( HitActor != None )
		{
			//AddArrow( TargetActor.Location, HitLocation, ColorMagenta() );
			//AimingActor.DMTNS( "  GetBestPredictedLocation using blocked location" );
			PredictedLocation = HitLocation + AimingActor.CollisionRadius * HitNormal; // pull back enough for aiming actor to fit at target location
		}
		else
		{
			//AimingActor.DMTNS( "  GetBestPredictedLocation no solution using TargetActor location" );
			PredictedLocation = TargetActor.Location;
		}
	}
	else 
	{
		//AimingActor.DMTNS( "  GetBestPredictedLocation -- predicted location found" );
		
		// if target is blocked from PredictedLocation by geometry then back up the PredictedLocation
		HitActor = class'Util'.static.TraceRecursive( AimingActor, HitLocation, HitNormal, TargetActor.Location, false, , PredictedLocation - TargetActor.Location, VSize( PredictedLocation - TargetActor.Location ), , TRACE_World );

		if( HitActor != None )
		{		
			//AddArrow( HitLocation, HitLocation + 128.0 * HitNormal );
			//AimingActor.DMTNS( "GetBestPredictedLocation target will be blocked by geometry - adjusting predicted location" );
			PredictedLocation = HitLocation	+ AimingActor.CollisionRadius * HitNormal; // pull back enough for aiming actor to fit at target location 
			//AddCylinder( PredictedLocation, 4, 4, ColorMagenta() );
		}
		
		// if AimingActor. can't get to PredictedLocation, go right at target instead
		if( !AimingActor.FastTrace( AimingActor.Location, PredictedLocation ) )
		{
			//AimingActor.DMTNS( "GetBestPredictedLocation no trace - using TargetActor" );
			PredictedLocation = TargetActor.Location;
		}
	}
	
	//AddArrow( AimingActor.Location, PredictedLocation, ColorGreen() );
	//AddCylinder( PredictedLocation, 4, 4, ColorGreen() );
}

/*-----------------------------------------------------------------------------
Iterative approach to determining predicted location when using projectile
physics with a moving target. If the location can be predicted it is returned
in PredictedLocation, otherwise the given location is returned unmodified.

!!mdf-tbd: location prediction code should take geometry into account and try
to place the moving actor on the floor if walking (same thing with other
movement prediction code afaik).

!!mdf-tbd: this seems to work really well - is it worth trying to come up with 
a non-iterative equation?
*/

static final function GetBestPredictedProjectileLocation( 
	Actor AimingActor, 
	Actor TargetActor, 
	class<Actor> ProjectileClass, 
	float ProjectileSpeed, 
	float DelayTime,
	vector StartLocation,
	float TargetDistance,
	bool bUseHighTrajectory,
	out vector TargetLocation )
{
	local int NumSolutions;
	local float ThetaLow, ThetaHigh;
	local float InterceptTime, InterceptTimeLow, InterceptTimeHigh;
	local vector CurrentTargetLocation, CurrentPredictedLocation;
	local float DistanceDelta;
	local vector SavedLocation, PredictedMoveVector;
	local int Attempt;	
	
	// note: assumes we are heading towards target actor (e.g. as opposed to a last seen position)
	CurrentTargetLocation = TargetActor.Location;

	for( Attempt=0; Attempt<default.MaxPredictProjectileAttempts; Attempt++ )
	{
		// break when we get an acceptible result or determine that there is no solution?
		NumSolutions = GetInverseTrajectory( AimingActor, ProjectileClass, ProjectileSpeed, StartLocation, CurrentTargetLocation, ThetaLow, ThetaHigh, InterceptTimeLow, InterceptTimeHigh );
		
		//AddCylinder( CurrentTargetLocation, TargetActor.CollisionRadius, TargetActor.CollisionHeight, ColorBlue() );
		if( NumSolutions == 0 )
		{
			if( ProjectileSpeed ~= 0.0 )
			{
				TargetLocation = CurrentTargetLocation;
				return;
			}

			InterceptTime = TargetDistance / (0.5*ProjectileSpeed);
		}
		else if( bUseHighTrajectory )
		{
			InterceptTime = InterceptTimeHigh;
		}
		else
		{
			InterceptTime = InterceptTimeLow;
		}
		
		// use delay + trajectory intercept times to determine where target will be then
		PredictedMoveVector = (InterceptTime + DelayTime) * TargetActor.Velocity;
		
		// see how far target will be able to move in that direction
		SavedLocation = TargetActor.Location;
		TargetActor.Move( PredictedMoveVector, true );
		if( TargetActor.Location != (SavedLocation + PredictedMoveVector ) )
		{
			// target will hit a wall or something so aim for that location
			TargetLocation = TargetActor.Location;
			TargetActor.SetLocation( SavedLocation );
			return;
		}
		CurrentPredictedLocation = TargetActor.Location;
		TargetActor.SetLocation( SavedLocation );
		
		//AddCylinder( CurrentPredictedLocation, TargetActor.CollisionRadius, TargetActor.CollisionHeight, ColorCyan() );

		// how far off are we?
		DistanceDelta = VSize( CurrentTargetLocation - CurrentPredictedLocation );

		//AimingActor.DMTNS( "delta for attempt #" $ Attempt $ " is: " $ DistanceDelta );
		if( DistanceDelta <= default.PredictProjectileThreshold )
		{
			TargetLocation = CurrentTargetLocation;		
			return;
		}
		
		// try half way?
		CurrentTargetLocation += 0.5*(CurrentPredictedLocation - CurrentTargetLocation);
	}
}

//=============================================================================
//@ Searching
//=============================================================================

static final function bool VerifyNamedActor( Actor A, bool bAllowUnSafe )
{
	if( bAllowUnSafe || A.bEditorPlaced )
		return true;

	A.DMTNS( "Warning: GetFilteredActors used to find a named non-editor placed actor (this is unreliable): " $ A $ "!" );
	return false;
}

//-----------------------------------------------------------------------------
// Search for closest actor to InstanceActor which matches given ClassName 
// (bIsA=false) or IsA(ClassName) (bIsA=true). Returns None if no such actor
// found. Matches with InstanceActor are NOT filtered out.

static final function Actor GetClosestOfClass( Actor InstanceActor, name ClassName, bool bIsA )
{
	local Actor A;
	local float MinDist;
	local float Distance;
	local Actor Closest;

	// try to match closest actor with same class (not including super classes) as given name
	Closest = None;
	MinDist = 999999;

	foreach InstanceActor.AllActors( class'Actor', A )
	{
		if( A.Class.Name == ClassName || (bIsA && A.IsA(ClassName)) )
		{
			Distance = VSize( InstanceActor.Location - A.Location );
			if( Distance < MinDist )
			{
				Closest = A;
				MinDist = Distance;
			}
		}
	}

	return Closest;
}

//-----------------------------------------------------------------------------
// NOTE: if this is called with a target name that ends in a digit, we look for
// a matching actor in the level. But, this isn't safe if the actor was spawned
// in-game since there is no guarantee that the same name will be used each 
// time. Will normally return None for these cases, use bAllowUnSafe=true to
// allow such actors to be found, e.g. for testing purposes.

static final function Actor GetNamedActor( Actor InstanceActor, name N, optional bool bTryClassMatch, optional bool bAllowUnSafe )
{
	local Actor A;

	if( InstanceActor != None )
	{
		if( !bTryClassMatch || class'Util'.static.EndsInDigit( string(N) ) )
		{
			// first try to find an actor with the given name (can be at most one)
			//!!!			
			foreach InstanceActor.AllActors( class'Actor', A )
			//foreach InstanceActor.DynamicActors( class'Actor', A )
			{
				if( A.Name == N )
				{
					if( VerifyNamedActor( A, bAllowUnSafe ) )
						return A;
					else
						return None;
				}
			}
		}

		if( bTryClassMatch )
		{
			A = GetClosestOfClass( InstanceActor, N, false );		// try exact match
			if( A == None )
				A = GetClosestOfClass( InstanceActor, N, true );	// try IsA match
	
			return A;
		}
	}

	return None;
}

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

static final function Actor GetNamedOrHitActor( Controller C, optional name TargetName, optional bool bTraceVisibleNonColliding, optional bool bTryClassMatch )
{
	if( TargetName != '' )
	{
		return GetNamedActor( C, TargetName, bTryClassMatch, true );
	}
	else
	{
		return class'Util'.static.GetHitActor( C, bTraceVisibleNonColliding );
	}
}

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

static final function bool FindActorByName( Actor SearchingActor, Name ActorName, out Actor FoundActor )
{
	local Actor CurrentActor;
	local bool bFoundActor;
	
	foreach SearchingActor.AllActors( class'Actor', CurrentActor )
	{
		if( CurrentActor.Name == ActorName )
		{
			FoundActor = CurrentActor;
			bFoundActor = true;
			break;
		}
	}

	return bFoundActor;
}

/*-----------------------------------------------------------------------------
GetFilteredActors:

For now searches:
	navigation point list if given class is NavigationPoint (or a child class)
	dynamic actors if given class isn't static by default
	allactors (potentially sloow)

If TagetName ends in digits, assumes that goal is a named object, rather than a
class (searches all colliding actors for one with matching name). Otherwise
maps TargetName to a specific class.

When using VFT_Visible/VFT_FOV uses LineOfSightTo/CanSee if OriginActor is a Pawn
otherwise uses Trace.

Returns number of matching actors found (usually 0/1 unless Type=3 in which
case can return 0..MaxFilteredActorss).

!!mdf-tbd: collapse as many of the actor iterator classes as possible once 
generic lists support integrated.
*/

static final function int GetFilteredActors( 
	Actor OriginActor,									// actor to search from
	string TargetNameStr, 								// name of class or object to search for
	out Actor MatchingActors[ MaxFilteredActors ],		// array for returning matching actors
	float MinRadius,									// min considered distance around OriginActor
	float MaxRadius,									// max considered distance around OriginActor
	EDistanceFilterType DistanceFilterType,	 			// first/closest/furthest/all
	EVisibilityFilterType VisibilityFilterType,			// none/visible/fov
	int MaxMatches,										// when using DFT_Any, caps number of matches (to less than MaxFilteredActors )
	optional bool bAllowUnSafe,							// allow finding named non-level placed actors
	optional bool b2DDistanceCheck )					// consider 2D distance checks only
{
	local Actor A;
	local int NumMatchingActors;
	local name TargetName;
	local class<Actor> BaseClass;
	local float DistanceBetweenActors;
	local Pawn P;
	local Controller OriginController;
	local bool bPawnVisibleFilter, bPawnFOVFilter, bActorVisibleFilter;
	local float BestDistance;

	// !!mdf-tbr:
	local NavigationPoint TempN;
	local Controller TempC;
	
	if( DistanceFilterType == DFT_Closest )
		BestDistance =  999999.9;
	else
		BestDistance = -999999.9;

	if( class'Util'.static.EndsInDigit( TargetNameStr ) ) // !!mdf-tbd: this assumes no class names end in digits (bad anyway because of way engine creates object names)
	{
		BaseClass = class'Actor';
		TargetName = StringToName( TargetNameStr, true );
	}
	else
	{
		BaseClass = class<Actor>( DynamicLoadObject( TargetNameStr, class'class' ));
		TargetName = '';
	}

	if( MaxRadius <= 0.0 )
		MaxRadius = 999999.0;
	else if( MaxRadius > 999999.0 )
		MaxRadius = 999999.0;

	// prepare for any necessary visibility checks
	if( VisibilityFilterType != VFT_None )
	{
		P = Pawn(OriginActor);
		if( P != None )
		{
			OriginController = P.Controller;
			if( VisibilityFilterType == VFT_Visible )
				bPawnVisibleFilter = true;
			else
				bPawnFOVFilter = true;
		}
		else
		{
			bActorVisibleFilter = true;
		}
	}

	if( MaxMatches == 0 )
		MaxMatches = MaxFilteredActors;

	NumMatchingActors = -1;
	if( BaseClass != None && MaxRadius >= MinRadius )
	{
		NumMatchingActors = 0;

		// !!mdf-tbr: temp cut and paste job -- once MJL finishes actor lists support
		// we can go back to using a single AllActors loop. Factoring out the filter
		// and add code would be a complete waste of time (and slow) at this point..

		if( ClassIsChildOf( BaseClass, class'NavigationPoint' ) )
		{
			// use navigation point list
			for( TempN=OriginActor.Level.NavigationPointList; TempN!=None; TempN=TempN.NextNavigationPoint )
			{
				A = TempN;

				if( !ClassIsChildOf( A.Class, BaseClass ) )
					continue;
					
				if( b2DDistanceCheck )
					DistanceBetweenActors = VSize2D( A.Location - OriginActor.Location );	
				else
					DistanceBetweenActors = VSize( A.Location - OriginActor.Location );	
		
				if( DistanceBetweenActors < MinRadius )
					continue; // too close
	
				if( DistanceBetweenActors > MaxRadius )
					continue; // too far
	
				// in Min..Max
	
				if( TargetName != '' && A.Name != TargetName )
					continue; // wrong object name (if looking for a specific actor)
	
				// check any visibility constraints
	
				if( bPawnVisibleFilter && !OriginController.LineOfSightTo( A ) )
					continue; // Pawn has no LOS to A
	
				if( bPawnFOVFilter && !OriginController.CanSee( A ) )
					continue; // A not in Pawn's field of view (stronger test than LOS)
	
				if( bActorVisibleFilter && !SLCActorCanSeeActor( OriginActor, A ) )
					continue; // something is between OriginActor and A
	
				// this is a valid actor
	
				if( TargetName != '' )
				{
					// looking for a specific target actor
					if( A.Name == TargetName )
					{
						if( VerifyNamedActor( A, bAllowUnSafe ) )
							MatchingActors[ NumMatchingActors++ ] = A;
						break;
					}
				}
				else if( DistanceFilterType == DFT_First )
				{
					// done -- return first candidate
					MatchingActors[ NumMatchingActors++ ] = A;
					break;
				}
				else if( DistanceFilterType == DFT_Any )
				{
					// return first N candidates
					MatchingActors[ NumMatchingActors++ ] = A;
					if( NumMatchingActors == MaxMatches )
						break;
				}
				else if( DistanceFilterType == DFT_Closest )
				{
					// track closest
					if( DistanceBetweenActors < BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
				else
				{
					// track furthest
					if( DistanceBetweenActors > BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
			}
		}
		else if( ClassIsChildOf( BaseClass, class'Pawn' ) )
		{
			// use controller list
			for( TempC=OriginActor.Level.ControllerList; TempC!=None; TempC=TempC.NextController )
			{
				A = TempC.Pawn;

				if( A == None )
					continue;

				if( !ClassIsChildOf( A.Class, BaseClass ) )
					continue;

				DistanceBetweenActors = VSize( A.Location - OriginActor.Location );	
		
				if( DistanceBetweenActors < MinRadius )
					continue; // too close
	
				if( DistanceBetweenActors > MaxRadius )
					continue; // too far
	
				// in Min..Max

				if( TargetName != '' && A.Name != TargetName )
					continue; // wrong object name (if looking for a specific actor)

				// check any visibility constraints
	
				if( bPawnVisibleFilter && !OriginController.LineOfSightTo( A ) )
					continue; // Pawn has no LOS to A
	
				if( bPawnFOVFilter && !OriginController.CanSee( A ) )
					continue; // A not in Pawn's field of view (stronger test than LOS)
	
				if( bActorVisibleFilter && !SLCActorCanSeeActor( OriginActor, A ) )
					continue; // something is between OriginActor and A
	
				// this is a valid actor
	
				if( TargetName != '' )
				{
					// looking for a specific target actor
					if( A.Name == TargetName )
					{
						// found it
						if( VerifyNamedActor( A, bAllowUnSafe ) )
							MatchingActors[ NumMatchingActors++ ] = A;
						break;
					}
				}
				else if( DistanceFilterType == DFT_First )
				{
					// done -- return first candidate
					MatchingActors[ NumMatchingActors++ ] = A;
					break;
				}
				else if( DistanceFilterType == DFT_Any )
				{
					// return first N candidates
					MatchingActors[ NumMatchingActors++ ] = A;
					if( NumMatchingActors == MaxMatches )
						break;
				}
				else if( DistanceFilterType == DFT_Closest )
				{
					// track closest
					if( DistanceBetweenActors < BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
				else
				{
					// track furthest
					if( DistanceBetweenActors > BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
			}
		}
		else if( BaseClass.default.bStatic )
		{
			// use RadiusActors (sloow)
		  	foreach OriginActor.RadiusActors( BaseClass, A, MaxRadius )
			{
				DistanceBetweenActors = VSize( A.Location - OriginActor.Location );	
		
				if( DistanceBetweenActors < MinRadius )
					continue; // too close
	
				//!!mdf-tbr: shouldn't be needed with radius check in AllActors? if( DistanceBetweenActors > MaxRadius )
				//!!mdf-tbr:	continue; // too far
	
				// in Min..Max
	
				if( TargetName != '' && A.Name != TargetName )
					continue; // wrong object name (if looking for a specific actor)
	
				// check any visibility constraints
	
				if( bPawnVisibleFilter && !OriginController.LineOfSightTo( A ) )
					continue; // Pawn has no LOS to A
	
				if( bPawnFOVFilter && !OriginController.CanSee( A ) )
					continue; // A not in Pawn's field of view (stronger test than LOS)
	
				if( bActorVisibleFilter && !SLCActorCanSeeActor( OriginActor, A ) )
					continue; // something is between OriginActor and A
	
				// this is a valid actor
	
				if( TargetName != '' )
				{
					// looking for a specific target actor
					if( A.Name == TargetName )
					{
						// found it
						if( VerifyNamedActor( A, bAllowUnSafe ) )
							MatchingActors[ NumMatchingActors++ ] = A;
						break;
					}
				}
				else if( DistanceFilterType == DFT_First )
				{
					// done -- return first candidate
					MatchingActors[ NumMatchingActors++ ] = A;
					break;
				}
				else if( DistanceFilterType == DFT_Any )
				{
					// return first N candidates
					MatchingActors[ NumMatchingActors++ ] = A;
					if( NumMatchingActors == MaxMatches )
						break;
				}
				else if( DistanceFilterType == DFT_Closest )
				{
					// track closest
					if( DistanceBetweenActors < BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
				else
				{
					// track furthest
					if( DistanceBetweenActors > BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
			}
		}
		else
		{
			// use DynamicActors
		  	foreach OriginActor.DynamicActors( BaseClass, A, , MaxRadius )
			{
				DistanceBetweenActors = VSize( A.Location - OriginActor.Location );	

				if( DistanceBetweenActors < MinRadius )
					continue; // too close
	
				//!!mdf-tbr: shouldn't be needed with radius check in DynamicActors? if( DistanceBetweenActors > MaxRadius )
				//!!mdf-tbr:	continue; // too far
	
				// in Min..Max
	
				if( TargetName != '' && A.Name != TargetName )
					continue; // wrong object name (if looking for a specific actor)
	
				// check any visibility constraints
	
				if( bPawnVisibleFilter && !OriginController.LineOfSightTo( A ) )
					continue; // Pawn has no LOS to A
	
				if( bPawnFOVFilter && !OriginController.CanSee( A ) )
					continue; // A not in Pawn's field of view (stronger test than LOS)
	
				if( bActorVisibleFilter && !SLCActorCanSeeActor( OriginActor, A ) )
					continue; // something is between OriginActor and A
	
				// this is a valid actor
	
				if( TargetName != '' )
				{
					// looking for a specific target actor
					if( A.Name == TargetName )
					{
						// found it
						if( VerifyNamedActor( A, bAllowUnSafe ) )
							MatchingActors[ NumMatchingActors++ ] = A;
						break;
					}
				}
				else if( DistanceFilterType == DFT_First )
				{
					// done -- return first candidate
					MatchingActors[ NumMatchingActors++ ] = A;
					break;
				}
				else if( DistanceFilterType == DFT_Any )
				{
					// return first N candidates
					MatchingActors[ NumMatchingActors++ ] = A;
					if( NumMatchingActors == MaxMatches )
						break;
				}
				else if( DistanceFilterType == DFT_Closest )
				{
					// track closest
					if( DistanceBetweenActors < BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
				else
				{
					// track furthest
					if( DistanceBetweenActors > BestDistance )
					{
						MatchingActors[ 0 ] = A;
						BestDistance = DistanceBetweenActors;
						NumMatchingActors = 1; // ya -- this could be reset to 1 multiple times
					}
				}
			}
		}
	}

	return NumMatchingActors;
}

//-----------------------------------------------------------------------------
// GetClosestActor
//
// Returns the Actor of the specified class which is closest to the OriginActor
// and withing the specified MaxSearchRadius (if 0 any distance is valid).
//
// Optimized for NavigationPoints, Controllers and Projectiles (including 
// but this can still be a very slow call).
										 
static final function Actor GetClosestActor( Actor OriginActor, class<Actor> ClassToSearchFor, optional float MaxSearchRadius )
{
	local Controller C;
	local NavigationPoint NP;
	local Actor A;
	local float DistanceBetweenActors;

	local float ClosestDistance;
	local Actor ClosestActor;

	ClosestDistance = 999999.9;

	if( MaxSearchRadius ~= 0.0 )
		MaxSearchRadius = 999999.9;

	// optimize special cases
	if( ClassIsChildOf( ClassToSearchFor, class'Controller' ) )
	{
		// optimization for Controllers
	  	for( C=OriginActor.Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.IsA( ClassToSearchFor.Name ) )
			{
				DistanceBetweenActors = VSize( C.Pawn.Location - OriginActor.Location );	
	
				if( DistanceBetweenActors <= MaxSearchRadius && DistanceBetweenActors < ClosestDistance )
				{
					ClosestActor = C;
					ClosestDistance = DistanceBetweenActors;
				}
			}
		}
	}
	else if( ClassIsChildOf( ClassToSearchFor, class'NavigationPoint' ) )
	{
		// optimization for NavigationPoints
	  	for( NP=OriginActor.Level.NavigationPointList; NP!=None; NP=NP.NextNavigationPoint )
		{
			if( NP.IsA( ClassToSearchFor.Name )	)
			{
				DistanceBetweenActors = VSize( NP.Location - OriginActor.Location );	
	
				if( DistanceBetweenActors <= MaxSearchRadius && DistanceBetweenActors < ClosestDistance )
				{
					ClosestActor = NP;
					ClosestDistance = DistanceBetweenActors;
				}
			}
		}
	}
	else
	{
		//mjl-tbd: have this search the LevelInfo's ActorLists for a thing of the appropriate class, and use it
		// general case -- slooow
	  	foreach OriginActor.AllActors( ClassToSearchFor, A )
		{
			DistanceBetweenActors = VSize( A.Location - OriginActor.Location );	

			if( DistanceBetweenActors <= MaxSearchRadius && DistanceBetweenActors < ClosestDistance )
			{
				ClosestActor = A;
				ClosestDistance = DistanceBetweenActors;
			}
		}
	}

	return ClosestActor;
}

//=============================================================================
//@ Visibility
//=============================================================================

//-----------------------------------------------------------------------------
// Allows you to check if an object is in your view.
//-----------------------------------------------------------------------------
// ViewVec:	A vector facing "forward"						(relative to your location.)
// DirVec:	A vector pointing to the object in question.	(relative to your location.)
// FOVCos:	Cosine of how many degrees between ViewVec and DirVec to be seen.
//-----------------------------------------------------------------------------
// REQUIRE: FOVCos > 0
// NOTE: While normalization is not required for ViewVec or DirVec, it helps
// if both vectors are about the same size.
//-----------------------------------------------------------------------------

static final function bool IsInViewCos( vector ViewVec, vector DirVec, float FOVCos )
{
	local float CosAngle;		//cosine of angle from object's LOS to WP
    
    CosAngle = Normal( ViewVec ) dot  Normal( DirVec );

	//The first test makes sure the target is within the firer's front 180o view.
	//The second test might look backwards, but it isn't.  Since cos(0) == 1,
	//as the angle gets smaller, CosAngle *increases*, so an angle less than
	//the max will have a larger cosine value.
	
	return (0 <= CosAngle && FOVCos < CosAngle);
}

//-----------------------------------------------------------------------------
// Allows you to check if an object is in your view.
//-----------------------------------------------------------------------------
// ViewVec:	A vector facing "forward"						(relative to your location.)
// DirVec:	A vector pointing to the object in question.	(relative to your location.)
// FOV:		How many degrees the target must be within to be seen.
//-----------------------------------------------------------------------------
// REQUIRE: FOV < 90
// NOTE: While normalization is not required for ViewVec or DirVec, it helps
// if both vectors are about the same size.
//-----------------------------------------------------------------------------

static final function bool IsInView( vector ViewVec, vector DirVec, float FOV )
{
	return IsInViewCos( ViewVec, DirVec, cos( ( 2 * Pi ) / ( 360 / FOV ) ) );
}

//-----------------------------------------------------------------------------
// Returns true if the first Actor has an uninterrupted LOS to the second actor.

static final function bool SLCActorCanSeeActor( Actor SourceActor, Actor TargetActor )
{
	local vector TraceHitLocation, TraceHitNormal;

	// can we trace a line from the source actor to the target actor?
	return( SourceActor.Trace( 
		   		TraceHitLocation, 
		   		TraceHitNormal,		
		   		TargetActor.Location, 
		   		SourceActor.Location, 
		   		true ) == TargetActor );
}

//-----------------------------------------------------------------------------
// Returns true if Target is in within given FOVCos wrt SeeingActor.
//-----------------------------------------------------------------------------

static final function bool ActorLookingAt( Actor SeeingActor, Actor Target, float FOVCos )
{
	//2002.12.19 (mdf) warning fix
	if( Target == None || SeeingActor == None )
		return false;

	return IsInViewCos( vector(SeeingActor.Rotation), Target.Location - SeeingActor.Location, FOVCos );
}

//-----------------------------------------------------------------------------
// MLCActorCanSeeActor:
//-----------------------------------------------------------------------------
// TraceFromActor:	Actor to trace from
// TraceToActor:	Actor to trace to
// FOVCos:			(optional) cos of FOV to use (1/2 of the total FOV), 
//					If	<= -1, FOV not used.
//
//-----------------------------------------------------------------------------
// Returns true if Actor is not entirely occluded by geometry from the given
// TraceFromActor's point of view. If bTraceActors is true, other actors will 
// block the TraceFromActor's view of the TraceToActor.
//
// Determines whether an Actor can see another actor, i.e. whether any line from
// the TraceFroActor's center (+baseeyeheight if TraceFromActor is a Pawn) 
// to the TraceToActor exists which doesn't hit any geometry or another actor 
// (if bTraceActors is true) and is within the FOV relative to the TraceFromActor's
// ViewRotation.
//
//-----------------------------------------------------------------------------
// Notes:
// 
// There's got to be a better way to do this.  Tim has to do this when he 
// draws the actors on the screen.  Is there any way we can piggy-back off
// of that code?
//
// CanSee is fubar: reports true even if facing 180 degrees away, but close,
// could be related to the fact that CanSee also takes noises into account...
// LineOfSightTo is fubar: doesn't take actor's into account?
//
// Will return true if the TraceFromActor can see the bottom, center or top of 
// the given TraceToActor's collision cylinder. Currently only traces to the 
// horizontal center of the actor, doesn't currently check left and right sides.
//
// TBD: do left-left and right-right checks as well to handle case where 
// actors can only see each other's left/right side.
//
// Seems this can fail for small (fast?) actors e.g. tracing from a Pawn to a 
// dart projectile which was maybe 200 units in front consistently fails to
// hit the dart.
//-----------------------------------------------------------------------------

static final function bool ActorCanSeeActor( Actor TraceFromActor, Actor TraceToActor, float FOVCos, optional bool bTraceActors )
{
	local bool bCanSee;
	local vector StartPoint;
	local vector EndPoints[5];
	local int ii;
	local Actor HitActor;
	local vector HitLocation, HitNormal;
	
	// Is the Actor even in the Pawns FOV?
	if( FOVCos > -1.0 && !ActorLookingAt( TraceFromActor, TraceToActor, FOVCos ) )
	  	return false;

	// Can we trace a line from the Pawn's eyes to the actor without hitting geometry?
	StartPoint = TraceFromActor.Location;
	if( Pawn(TraceFromActor) != None )
		StartPoint.Z += Pawn(TraceFromActor).BaseEyeHeight;
		
	EndPoints[0] = TraceToActor.Location;												// eyes/center -> actor center
	EndPoints[1] = TraceToActor.Location + TraceToActor.CollisionHeight*vect(0,0,1);	// eyes/center -> actor top (head)
	EndPoints[2] = TraceToActor.Location - TraceToActor.CollisionHeight*vect(0,0,1);	// eyes/center -> actor bottom (feet)
	EndPoints[3] = TraceToActor.Location + TraceToActor.CollisionRadius*( Normal(vect(0,0,1) cross (TraceToActor.Location - TraceFromActor.Location)) );	// eyes/center -> actor left
	EndPoints[4] = TraceToActor.Location - TraceToActor.CollisionRadius*( Normal(vect(0,0,1) cross (TraceToActor.Location - TraceFromActor.Location)) );	// eyes/center -> actor right

	for( ii=0; ii<ArrayCount(EndPoints); ii++ )
	{
		HitActor = class'Util'.static.TraceRecursive(
				TraceFromActor,
				HitLocation,
				HitNormal,
				StartPoint,
				bTraceActors,,
				Normal(EndPoints[ii] - StartPoint),		// direction.
				VSize(EndPoints[ii] - StartPoint)		// limit.
			);

		// if bTraceActors is true, trace should hit TraceToActor if TraceFromActor can see TraceToActor
		// if bTraceActors is false, trace should hit nothing if TraceFromActor can see TraceToActor
		bCanSee = ( HitActor == None || HitActor == TraceToActor );

    	if( bCanSee )	
			break;		// No need to go on.
	}

	return bCanSee;
}

//-----------------------------------------------------------------------------
// Check for line of sight to target DeltaTime from now. Moved here from 
// Controller hierarchy but not called from anywhere currently (tbr?).

static final function bool CheckFutureSight( Pawn SourcePawn, Actor TargetActor, float DeltaTime )
{
	local vector FutureLoc;

	if( TargetActor == None )
		return false;

	if( VSize( SourcePawn.Velocity ) ~= 0.0 )
		FutureLoc = SourcePawn.Location;
	else
		FutureLoc = SourcePawn.Location + SourcePawn.GroundSpeed * Normal( SourcePawn.Velocity ) * DeltaTime;

	if( SourcePawn.Base != None ) 
		FutureLoc += SourcePawn.Base.Velocity * DeltaTime;

	//make sure won't run into something
	if( !SourcePawn.FastTrace( FutureLoc, SourcePawn.Location ) && ( SourcePawn.Physics != PHYS_Falling ) )
		return false;

	//check if can still see target actor
	if( SourcePawn.FastTrace( TargetActor.Location + TargetActor.Velocity * DeltaTime, FutureLoc ) )
		return true;

	return false;
}

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

defaultproperties
{
	VerifyTrajectorySamples=8
	VerifyTrajectoryVerticalExtentPadding=8.000000
	MaxPredictProjectileAttempts=16
	PredictProjectileThreshold=16.000000
	MaxTargetBlockedMissMultiplier=3.000000
	MinTargetBlockedPitchError=-1024.000000
	MaxTargetBlockedPitchError=4096.000000
	MinModifyForSpreadDistance=512.000000
	MinPitchError=-1024.000000
	MaxPitchError=4096.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}