Engine.AIController

//=============================================================================
// AIController, the base class of AI.
//
// Controllers are non-physical actors that can be attached to a pawn to control 
// its actions.  AIControllers implement the artificial intelligence for the pawns they control.  
//
// This is a built-in Unreal class and it shouldn't be modified.
//=============================================================================
//NEW
class AIController extends LicenseeController
/*OLD
class AIController extends Controller
*/
	native;

//NEW (mdf): renamed from EAttitude and moved here where it belongs
enum EReaction						// order in increasing "friendliness"
{
	REACTION_Fear,					// will try to run away
	REACTION_Attack,				// will attack enemy
//!!mdf-tbr?:	REACTION_Frenzy,		// will attack anything, indiscriminately
//!!mdf-tbd:	REACTION_Threaten,		// animations, but no attack
//!!mdf-tbd:	REACTION_Ignore,		// will ignore -- no reaction beyond maybe looking at target
//!!mdf-tbd:	REACTION_Friendly,		// will act especially friendly
//!!mdf-tbd:	REACTION_Follow 		// will follow accepts player as leader
};
//OLD
var		bool		bHunting;			// tells navigation code that pawn is hunting another pawn,
										//	so fall back to finding a path to a visible pathnode if none
										//	are reachable
var		bool		bAdjustFromWalls;	// auto-adjust around corners, with no hitwall notification for controller or pawn
										// if wall is hit during a MoveToXXX latent execution.

//NEW (mdf) not used with U2
/*OLD
var		AIScript MyScript;
*/

var(AI) private float Skill;				//NEW (mdf) NPC's base skill in 0.0..1.0

simulated //NEW
event PreBeginPlay()
{
	Super.PreBeginPlay();
	if ( bDeleteMe )
		return;

//NEW (mdf) not used with U2
/*OLD
	if ( Level.Game != None )
		Skill += Level.Game.Difficulty; 
	Skill = FClamp(Skill, 0, 3);
*/
}

/* Reset() 
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
	Super.Reset();

	// by default destroy bots (let game re-create)
	if ( bIsPlayer )
		Destroy();
}

//NEW (mdf)
/*OLD
function NotifyTakeHit( Pawn Instigator, vector HitLocation, int Damage, class<DamageType> DamageType, vector Momentum )
{
	if( Instigator != None && Instigator != Pawn )
		DamageAttitudeTo( Instigator, Damage );
} 
*/
//OLD

//NEW (mdf) not used with U2
/*OLD
function Trigger( actor Other, pawn EventInstigator )
{
	TriggerScript(Other,EventInstigator);
}
*/

//NEW (mdf) see GetInverseTrajectory
/*OLD
function float AdjustToss(Ammunition TossedAmmunition, vector Start, vector End)
{
	local vector RecommendedVector, Dir2D;
	local float ReachTime, Dist2D, StartVelZ, EndZ;

	// check for negative gravity
	if ( Pawn.PhysicsVolume.Gravity.Z >= 0 ) 
		return 0;

	RecommendedVector = TossedProjectileClass.Static.GetTossVelocity( Pawn, rot(0,0,0) );

	//determine how long I might be in the air 
	StartVelZ = RecommendedVector.Z;
	RecommendedVector.Z = 0;

	Dir2D = End - Start;
	//Dir2D.Z = 0;
	Dist2D = VSize(Dir2D);
	ReachTime = Dist2D/VSize(RecommendedVector); 	
	EndZ = StartVelZ/ReachTime - 0.25f * Pawn.PhysicsVolume.Gravity.Z * ReachTime;	

	return FMin( -1 * EndZ, Dist2D );
}
*/

/* TriggerScript()
trigger AI script (this may enable it)
*/
//NEW (mdf) not used with U2
/*OLD
function bool TriggerScript( actor Other, pawn EventInstigator )
{
	if ( MyScript != None )
	{
		MyScript.Trigger(EventInstigator,pawn);
		return true;
	}
	return false;
}
*/
	
/* DisplayDebug()
list important controller attributes on canvas
*/
function DisplayDebug(Canvas Canvas, out float YL, out float YPos)
{
	local int i;
	local string T;

	Super.DisplayDebug(Canvas,YL, YPos);

	Canvas.DrawColor.B = 255;	
	Canvas.DrawText("      NAVIGATION MoveTarget "$GetItemName(String(MoveTarget))$" PendingMover "$PendingMover$" MoveTimer "$MoveTimer, false);
	YPos += YL;
	Canvas.SetPos(4,YPos);

	Canvas.DrawText("      Destination "$Destination$" Focus "$GetItemName(string(Focus)), false);
	YPos += YL;
	Canvas.SetPos(4,YPos);

	Canvas.DrawText("      RouteGoal "$GetItemName(string(RouteGoal))$" RouteDist "$RouteDist, false);
	YPos += YL;
	Canvas.SetPos(4,YPos);

	for ( i=0; i<16; i++ )
	{
		if ( RouteCache[i] == None )
		{
			if ( i > 5 )
				T = T$"--"$GetItemName(string(RouteCache[i-1]));
			break;
		}
		else if ( i < 5 )
			T = T$GetItemName(string(RouteCache[i]))$"-";
	}

	Canvas.DrawText("RouteCache: "$T, false);
}

function HearPickup(Pawn Other);

function float AdjustDesireFor(Pickup P)
{
	return 0;
}

//NEW (mdf) 

//let NPC block switching if desired
function bool AllowPickupWeaponSwitch( Weapon Self, float CurrentRating, float PendingRating )
{
	return true;
}

// default implementation
exec function bool SwitchToBestWeapon( optional out float Rating, optional out byte bUseAltMode )	
{ 
	return false; 
}
//OLD

/* GetFacingDirection()
returns direction faced relative to movement dir

0 = forward
16384 = right
32768 = back
49152 = left
*/

//NEW (mdf) not used currently...
/*
...and would need to be changed to work with new serpentine code
need to know whether doing / about to do move with strafing... 
and currently GetTacticalMove returns random results in some cases...

	if ( bAdvancedTactics && !bNoTact )

-->

	if( GetTacticalMoveType() != TMT_None && !bNoTact )
*/	
/*OLD	
function int GetFacingDirection()
{
	local float strafeMag;
	local vector Focus2D, Loc2D, Dest2D, Dir, LookDir, Y;

	if ( (FocalPoint == Destination) || ((MoveTarget != None) && (MoveTarget == Focus)) )
		return 0;

	if ( bAdvancedTactics && !bNoTact )
	{
		if ( bTacticalDir )
			return 49152;
		else
			return 16384;
			
		return 0;
	}

	// check for strafe or backup
	Focus2D = FocalPoint;
	Focus2D.Z = 0;
	Loc2D = Pawn.Location;
	Loc2D.Z = 0;
	Dest2D = Destination;
	Dest2D.Z = 0;
	lookDir = Normal(Focus2D - Loc2D);
	Dir = Normal(Dest2D - Loc2D);
	strafeMag = lookDir dot Dir;
	Y = (lookDir Cross vect(0,0,1));
	if ((Y Dot (Dest2D - Loc2D)) < 0)
		return ( 49152 + 16384 * strafeMag );	
	else
		return ( 16384 - 16384 * strafeMag );
}
*/

/* 
UpdateTactics() - called every 0.5 seconds if TacticalMoveType is TMT_Basic
and is performing a latent MoveToActor() 
*/
event UpdateTactics()
{
	//DMTNS( "UpdateTactics!" );

	if ( bTacticalDir )
	{
		bTacticalDir = false;
		bNoTact = ( FRand() < 0.3 );
	}
	else
	{
		bTacticalDir = true;
		bNoTact = ( FRand() < 0.3 );
	}
}

// UpdateEyeHeight() called if Controller's pawn is viewtarget of a player
function AdjustView(float DeltaTime)
{
	local float TargetYaw, TargetPitch;
	local rotator OldViewRotation,ViewRotation;

	//NEW (mdf) 829 fix pending reply from stevep
	Super.AdjustView( DeltaTime );
	if( !Pawn.bUpdateEyeHeight )
		return;
	//OLD

	// update viewrotation
	ViewRotation = Rotation;
	OldViewRotation = Rotation;			

	//NEW (mdf)
	if ( ControllerEnemy == None )
	/*OLD
	if ( Enemy == None )
	*/
	{
		ViewRotation.Roll = 0;
		if ( DeltaTime < 0.2 )
		{
			OldViewRotation.Yaw = OldViewRotation.Yaw & 65535;
			OldViewRotation.Pitch = OldViewRotation.Pitch & 65535;
			TargetYaw = float(Rotation.Yaw & 65535);
			if ( Abs(TargetYaw - OldViewRotation.Yaw) > 32768 )
			{
				if ( TargetYaw < OldViewRotation.Yaw )
					TargetYaw += 65536;
				else
					TargetYaw -= 65536;
			}
			TargetYaw = float(OldViewRotation.Yaw) * (1 - 5 * DeltaTime) + TargetYaw * 5 * DeltaTime;
			ViewRotation.Yaw = int(TargetYaw);

			TargetPitch = float(Rotation.Pitch & 65535);
			if ( Abs(TargetPitch - OldViewRotation.Pitch) > 32768 )
			{
				if ( TargetPitch < OldViewRotation.Pitch )
					TargetPitch += 65536;
				else
					TargetPitch -= 65536;
			}
			TargetPitch = float(OldViewRotation.Pitch) * (1 - 5 * DeltaTime) + TargetPitch * 5 * DeltaTime;
			ViewRotation.Pitch = int(TargetPitch);
			SetRotation(ViewRotation);
		}
	}
}

//NEW (mdf) not used
/*OLD
function SetOrders(name NewOrders, Controller OrderGiver);

function actor GetOrdersObject()
{
	return None;
} 

function name GetOrders()
{
	return ''; //NEW (mdf)
	//OLD return 'None';
}
*/

/* PrepareForMove()
Give controller a chance to prepare for a move along the navigation network, from
Anchor (current node) to Goal, given the reachspec for that movement.

Called if the reachspec doesn't support the pawn's current configuration.
By default, the pawn will crouch when it hits an actual obstruction. However,
Pawns with complex behaviors for setting up their smaller collision may want
to call that behavior from here
*/
event PrepareForMove(NavigationPoint Goal, ReachSpec Path);

/* WaitForMover()
Wait for Mover M to tell me it has completed its move
*/
function WaitForMover(Mover M)
{
    PendingMover = M;
	bPreparingMove = true;
//NEW (mdf)
	StopMovement( true, false );
/*OLD
	Pawn.Acceleration = vect(0,0,0);
*/
}

/* MoverFinished()
Called by Mover when it finishes a move, and this pawn has the mover
set as its PendingMover
*/
function MoverFinished()
{
	if ( PendingMover.MyMarker.ProceedWithMove(Pawn) )
	{
		PendingMover = None;
		bPreparingMove = false;
	}
}

/* UnderLift()
called by mover when it hits a pawn with that mover as its pendingmover while moving to its destination
*/
function UnderLift(Mover M)
{
	local NavigationPoint N;

	bPreparingMove = false;
	PendingMover = None;

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

//NEW (mdf)
//-----------------------------------------------------------------------------
// ADDITIONAL INTERFACE FUNCTIONS 
//-----------------------------------------------------------------------------

function ETacticalMoveType GetTacticalMoveType()
{
	if( GetTimeSinceEnemyLastSeen() < 1.0 && GetSkill() > (1.25*FRand()-1) )
		return Pawn.TacticalMoveType;
	else
		return TMT_None;
}
	
//-----------------------------------------------------------------------------
	
function bool GetAimingLocation( out vector TargetLocation )
{
	local Actor TargetActor;
	local bool bValid;
	local Pawn CurrentEnemy;
	local Actor CurrentTarget;
	
	TargetActor = GetTarget();	
	if( TargetActor != None )
	{
		CurrentEnemy = ControllerEnemy;
		
		if( TargetActor == CurrentEnemy )
		{
			if( GetTimeSinceEnemyLastSeen() > 0.5 )
			{
				// aim at last seen location
				TargetLocation = GetLastEnemySeenLocation();
			}
			else
			{
				TargetLocation = CurrentEnemy.Location;
			}
			
			TargetLocation.Z += 0.90*CurrentEnemy.CollisionHeight;
			bValid = true;
		}
		else 
		{
			CurrentTarget = ControllerTarget;
			if( CurrentTarget != None )
			{
				if( Pawn(CurrentTarget) != None )
					TargetLocation = CurrentTarget.Location + vect(0,0,1)*0.9*CurrentTarget.CollisionHeight;
				else
					TargetLocation = CurrentTarget.Location + vect(0,0,1)*0.5*CurrentTarget.CollisionHeight;
				bValid = true;
			}
		}
	}
	
	//if( bValid )	
	//	DMTNS( "GetAimingLocation Actor: " $ TargetActor $ " returning " $ bValid );
	
	return bValid;
}

/*-----------------------------------------------------------------------------
NOTE: an NPC's skill is in the range 0.0..1.0. The skill returned by GetSkill
has the game's difficulty level added to it (clamped into 0.0..1.0). This 
allows for having NPCs of varying skill within the same game difficulty level,
although it is unlikely that this will be used for singleplayer (this is really
more useful for having customized bots in multiplayer games). Game code that
makes use of an NPC's skill probably shouldn't assume anything about the number 
of skill levels although we may need to do this in some cases where values 
don't scale well linearly.
*/

function SetSkill( float NewSkill )
{
	Skill = FClamp( NewSkill, 0.0, 1.0 );
}

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

function float GetSkill()
{
	return FClamp( Skill + Level.Game.GetNormalizedDifficulty(), 0.0, 1.0 );
}

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

function DisableSenses( optional bool bIncludingBumps )
{
	Disable( Event_HearNoise );
	Disable( Event_SeeEnemy );
	//!!mdf-tbr? if( bIncludingBumps )
	Disable( Event_NotifyBump );
}

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

function EnableSenses( optional bool bIncludingBumps )
{
	Enable( Event_HearNoise );
	Enable( Event_SeeEnemy );
	//!!mdf-tbr? if( bIncludingBumps )
	Enable( Event_NotifyBump );
}
//OLD

defaultproperties
{
	bAdjustFromWalls=true
	bShouldPossess=true
	MinHitWall=-0.500000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}