U2.U2NPCController

//=============================================================================
// U2NPCController.uc
// Created By: Mike Fox
// Created On: 8/01/00
// $Author: Mfox $
// $Date: 12/17/02 8:30p $
// $Revision: 56 $
//=============================================================================

class U2NPCController extends AIController
	abstract;

/*=============================================================================
Base interface class for all U2 NPCs. Also contains some debugging and error 
handling code, mainly just to keep the size of the U2AI classes under control.
=============================================================================*/

// orders (here so these are part of the interface for U2-level classes)

const OrdersNone	      			= '';					// NPC is free to make its own decisions
const OrdersAttack					= 'attack';				// NPC is on autonomous offense (will attack enemy)
const OrdersDefend					= 'defend';				// NPC is on autonomous defense (will defend base)
const OrdersFollow					= 'follow';				// NPC will stay close to order object
const OrdersGoto					= 'goto';				// NPC will stay at or near a specific location (still gathers inventory)
const OrdersHold					= 'hold';				// NPC will stay at or near a specific location (still gathers inventory)
const OrdersSquad					= 'squad';				// really just "placeholder" orders so NPC is counted as following orders if in a squad

const NotImplementedMessage			= "function not implemented";

const StyleCharge					=  10.0;
const StyleClose					=   1.6;
const StyleNeutral					=   0.0;
const StyleBackOff					=  -1.6;
const StyleRetreat  				=  -5.0;
const StyleRunaway					= -10.0;

// placed under Controller properties so easier to locate/set in-game
var(Controller) globalconfig bool bVisibleAI;	// show/hide AI destination actors, dormant NPCs, movement lines etc.

/* !!mdf-tbd: obsolete / or tbi?
function bool GetAdvancedTactics();
function AlternatePathInterf GetAlternatePath();
function float GetDefaultAggressiveness();
function bool GetInitialized();
function bool GetInitLifeMessage();
function bool GetIsNovice();
function float GetLastAttractCheck();
function bool GetNoClearSpecial();
function Pawn GetOldEnemy();
function float GetPointDied();
function bool GetPowerPlay();
function bool GetTacticalDir();
function bool GetNoTact();

function AddBaseAggressiveness( float Val );
function AddSkill( int AddSkill );
function SetBaseAggressiveness( float NewBaseAggressiveness );
function SetBaseAlertness( float NewBaseAlertness );
function SetCampingRate( float NewCampingRate );
function SetCampOnlyOnce( bool bVal );
function SetCampTime( float Val );
function SetInitialized( bool bVal );
function SetInitLifeMessage( bool bVal );
function SetIsJumpy( bool bVal );
function SetIsKamikaze( bool bVal );
function SetIsLeading( bool bVal );		
function SetIsNovice( bool bVal );		
function SetLastAttractCheck( float Val );	// !!mdf-tbr?
function SetNoClearSpecial( bool bVal );
function SetOldEnemy( Pawn P );
function SetPointDied( float Val );
function SetPowerPlay( bool bVal );
function SetStayFreelance( bool bVal );
function SetStrafingAbility( float NewStrafingAbility );
function SetThreePlus( bool bVal );

function StartMatch();					

function bool FindAmbushSpot();
*/

//!!mdf-tbr:
function NILog( coerce string ContextStr )
{
	DMTNS( "Warning -- " $ NotImplementedMessage $ "(Pawn=" $ Pawn $ ")" $ ": " $ ContextStr );
}

//!!mdf-tbd: called but not implemented!
//!!mdf-tbd: function AmbushPoint GetAmbushSpot()		{ NILog( GetContext(0) ); return None; }
function bool GetIsKamikaze()							{ NILog( GetContext(0) ); return false; }
function bool IsMeleeAttacking()						{ NILog( GetContext(0) ); return false; }
function bool GetIsSniping()							{ NILog( GetContext(0) ); return false; }
function bool GetQuickFire()							{ NILog( GetContext(0) ); return false; }
function bool ShouldBounceProjectile()					{ NILog( GetContext(0) ); return false; }
function float GetBounceLifespan()						{ NILog( GetContext(0) ); return 1.0; }
function bool MaybeSetEnemy( Pawn NewEnemy, optional bool bAlertingOthers )	{ NILog( GetContext(0) ); return false; }
function MaybeInheritEnemy( Pawn Other, Pawn NewEnemy, optional bool bCanSee ) { NILog( GetContext(0) ); }

function DyingRestart()									{ NILog( GetContext(0) ); }

function bool ReadyForAction()							{ return true; }
function bool ReadyForOrders()							{ return true; }

//!!mdf-tbd: function SetAlternatePath( AlternatePath AP )	{ GetContext(0) ); }
//!!mdf-tbd: function SetAmbushSpot( AmbushPoint AP )		{ GetContext(0) ); }
//!!mdf-tbd: function SetVerbose( bool bVal )				{ GetContext(0) ); }

function int GetNumWeapons()							{ return -1; }

//-----------------------------------------------------------------------------
// misc
//-----------------------------------------------------------------------------

function BigJump( Actor JumpDest );
function HandleIncoming( Actor IncomingActor, vector IncomingDirection, float IncomingSpeed );
function HearPickup( Pawn Other );		
function ReflectNotify( name NotifyName );
function YellAt( Pawn Moron );
function SetRandomSoundTimer();
								
//-----------------------------------------------------------------------------
// orders
//-----------------------------------------------------------------------------

function bool SetOrders( optional name NewOrders, optional Actor NewOrdersObject, optional float NewOrdersThreshold, optional Object NewOrderGiver, optional bool bAcknowledge );
function SetSpecialGoal( Actor NewSpecialGoal, optional float NewSpecialGoalDistance, optional bool bFaceSpecialGoalNew );
function name GetOrders() {	return OrdersNone; }
function Actor GetOrdersObject() { return None; }
function float GetOrdersThreshold() { return 0.0; }
function Object GetOrderGiver();
function SetExecuteOrders( bool bVal );

function SetDormant( bool bVal, optional bool bStayDormantVal );

function Actor GetSpecialGoal();
function float GetSpecialGoalDistance();
function bool GetFaceSpecialGoal();
								
//-----------------------------------------------------------------------------
// Weapons
//-----------------------------------------------------------------------------

//!!mdf-tbr?: function SetAccuracy( float NewAccuracy );
//!!mdf-tbr?: function SetFavoriteWeapon( class<Weapon> W );
function bool SupportsWeaponFire( Weapon W )	{ return true; }
function bool SupportsWeaponAltFire( Weapon W )	{ return true; }
function RefreshWeapon( name WeaponName );

//-----------------------------------------------------------------------------
// Scripting
//-----------------------------------------------------------------------------

function EnableProbeEvent( name EventName, bool bVal );
function ReloadScriptController();
function SetScript( string NewCommandFileName, optional string NewStartLabel );
function Shutdown( bool bVal );
function bool HasScript() { return false; }
function bool UnderScriptControl() { return false; }

//-----------------------------------------------------------------------------
// Debugging
//-----------------------------------------------------------------------------

function string GetExtendedStateInformation() { return ""; }
function GetExtendedInformation( out array<string> ReturnedStrings );
function string GetMetaStateName() { return "NA"; }
function string GetMetaStateNameShort() { return "NA"; }

function DumpAIEvents();
function NPCErrorExternal( coerce string Msg );
function NPCErrorInternal( coerce string Msg );
function bool SetTestMoveTarget( Actor TargetActor, optional float MoveSpeed, optional ETacticalMoveType TMT );
function bool IsFiring() { return false; }
function bool CanFire( bool bTest ) { return true; }
function bool CheckTargetInAttackRange( bool bTest ) { return false; }

function ForceNavigationError( bool bScriptedStateMoves, bool bMoveTarget, bool bMinZ );

//-----------------------------------------------------------------------------
//@ _DEBUGGING CODE -- !!mdf-tbr: remove any calls this stuff before shipping!
//-----------------------------------------------------------------------------

function SetDebugAI( bool bVal )
{
	if( bVal )
		AddDebugFlag( Debug_AI );
	else
		RemoveDebugFlag( Debug_AI );
}

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

function SetDebugAIEvents( bool bVal )
{
	if( bVal )
		AddDebugFlag( Debug_AIEvents );
	else
		RemoveDebugFlag( Debug_AIEvents );
}

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

function SetDebugAIMovement( bool bVal )
{
	if( bVal )
		AddDebugFlag( Debug_AIMovement );
	else
		RemoveDebugFlag( Debug_AIMovement );
}

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

function SetDebugAIAttacks( bool bVal )
{
	if( bVal )
		AddDebugFlag( Debug_AIAttacks );
	else
		RemoveDebugFlag( Debug_AIAttacks );
}

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

function SetDebugAIFlags( int Value )
{
	SetDebugFlags( Value );
}

//tbd #debugbegin
//-----------------------------------------------------------------------------
// generic AI messages

function AIMessage( string Prefix, coerce string Msg, optional bool bSkipLine )
{
	class'UtilGame'.static.LogAIDebugMessage( Self, Prefix, Msg, GetMetaStateName() $ "." $ GetStateName(), bSkipLine );
}

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

function DMAI( coerce string Msg, optional bool bForce )
{
	if( (bForce && DebugAIForced()) || DebugAI() )
		AIMessage( "DMAI", Msg );
}

//-----------------------------------------------------------------------------
// attack related messages

function DMAIA( coerce string Msg, optional bool bForce )
{
	if( (bForce && DebugAIForced()) || DebugAIAttacks() )
		AIMessage( "DMAIA", Msg );
}

//-----------------------------------------------------------------------------
// event related messages

function DMAIE( coerce string Msg, optional bool bForce )
{
	// !!mdf-tbd: 
	// if( DebugAIEventHandling() )
	if( (bForce && DebugAIForced()) || DebugAIEvents() )
		AIMessage( "DMAIE", Msg );
}

//-----------------------------------------------------------------------------
// label reached messages

function DMAIL( coerce string Msg, optional bool bForce )
{
	if( (bForce && DebugAIForced()) || DebugAI() )
		AIMessage( "DMAIL", Msg );
}

//-----------------------------------------------------------------------------
// navigation related messages

function DMAIM( coerce string Msg, optional bool bForce )
{
	if( (bForce && DebugAIForced()) || DebugAIMovement() )
		AIMessage( "DMAIM", Msg );
}
//tbd #debugend

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

function DMAssert( bool bTestCondition, coerce string Msg, optional coerce string PreFix )
{
	if( Prefix != "" )
		Prefix = Prefix @ class'UtilGame'.static.GetAIDebugMessage( Self, "", "" ) @ " ";
	else
		Prefix = class'UtilGame'.static.GetAIDebugMessage( Self, "", "" ) @ " ";
		
	Super.DMAssert( bTestCondition, Msg, Prefix  );
}

#debugbegin
//-----------------------------------------------------------------------------
// Can be used during development/testing to catch invalid state transitions.
// Only called (via NotifyStateChange) if bTrackStateChanges=true. Subclasses 
// can override/extend this to perform their own verifications.
// !!mdf-tbd make sure not used in release builds

function VerifyStateChange( name OldState, name NewState, name Label, bool bGoto, string ContextNameStr, int ContextLineNum );

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

event NotifyStateChange( name OldState, name NewState, name Label, bool bGoto, string ContextNameStr, int ContextLineNum )
{
	local string ContextStr;

	if( DebugAI() )
	{
		ContextStr = "  CONTEXT=" $ ContextNameStr $ " Line=" $ ContextLineNum;
		
		if( bGoto )
		{
			// goto
			AIMessage( "Goto", Label $ ContextStr, false );
		}
		else
		{
			// gotostate
			// this should catch all GotoStates and Gotos (since all state changes also call GotoLabel)
			AIMessage( "GotoS", OldState $ " --> " $ NewState $ "," $ Label $ ContextStr, NewState != OldState );
		}
	}

	VerifyStateChange( OldState, NewState, Label, bGoto, ContextNameStr, ContextLineNum );

	Super.NotifyStateChange( OldState, NewState, Label, bGoto, ContextNameStr, ContextLineNum );
}
#debugend

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

function HideActor( Actor A )
{
	if( A != None )
	{
		A.bHidden = A.default.bHidden;
		A.SetDrawScale( A.default.DrawScale );
	}
}

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

function ShowActor( Actor A, optional float NewDrawScale, optional ERenderStyle NewStyle )
{
	if( A != None )
	{
		A.bHidden   = false;

		if( NewDrawScale ~= 0.0 )
			NewDrawScale = A.default.DrawScale;
		A.SetDrawScale( NewDrawScale );

		if( NewStyle == STY_None )
			NewStyle = A.default.Style;
		A.Style = NewStyle;
	}
}

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

function string GetAIEventInfo()
{
	return( "AEnd "			$ byte(IsProbing( Event_AnimEnd )) @
			"Tick "			$ byte(IsProbing( Event_Tick )) @
			"Timer "		$ byte(IsProbing( Event_Timer )) @
			"Trigger "		$ byte(IsProbing( Event_Trigger )) @
			"EInvalid "	    $ byte(IsProbing( Event_EnemyInvalid )) @
			"EMRange "	    $ byte(IsProbing( Event_EnemyInMeleeRange )) @
			"ENotMRange "	$ byte(IsProbing( Event_EnemyNotInMeleeRange )) @
			"ENotVis "		$ byte(IsProbing( Event_EnemyNotVisible )) @
			"ERangeT "	    $ byte(IsProbing( Event_EnemyRangeTransition )) @
			"Bump "			$ byte(IsProbing( Event_NotifyBump )) @
			"Hear "			$ byte(IsProbing( Event_HearNoise )) @
			"RT "			$ byte(IsProbing( Event_ActorRangeTransition )) @
			"SeeEnemy "		$ byte(IsProbing( Event_SeeEnemy )) @
			"SeeFriend "	$ byte(IsProbing( Event_SeeFriend )) @
			"SeeAlert "		$ byte(IsProbing( Event_SeeAlertFriend )) );
			//tbd: "SeeOther "		$ byte(IsProbing( Event_SeeOther )) );
}

//-----------------------------------------------------------------------------
//@ _ERROR HANDLING CODE
//-----------------------------------------------------------------------------

// !!mdf-tbd: remove this stuff before shipping (or earlier) and add code for
// handling navigation problems as gracefully as possible (might still want to
// flag an error if the NPC is scripted up until ship time...).

function NPCError( U2Pawn.EErrorType ErrorType, coerce string Msg )
{
	U2Pawn(Pawn).ErrorGeneral( ErrorType, Msg );
}

//-----------------------------------------------------------------------------
// Appends closest navigation point to NCP to given error message.

function NavigationError( U2Pawn.EErrorType ErrorType, string ErrorMessage )
{
	local NavigationPoint NP, ClosestNP;
	local float Dist, ClosestDist;

	ClosestDist = 9999999.9;
	for( NP=Level.NavigationPointList; NP!=None; NP=NP.nextNavigationPoint )
	{
		Dist = VSize( Pawn.Location - NP.Location );
		if( Dist < ClosestDist )
		{
			ClosestNP	= NP;
			ClosestDist = Dist;
		}
	}

	//AddArrow( Pawn.Location, ClosestNP.Location, ColorRed() );
	ErrorMessage = ErrorMessage $ " (State: " $ GetStateName() $ " MoveTarget:" $ MoveTarget $ " Location: " $ class'Util'.static.GetVectorString(Pawn.Location) $ " Destination:" $ class'Util'.static.GetVectorString(Destination) $ " Closest NP:" $ ClosestNP.Name $ " Distance:" $ class'Util'.static.GetFloatString(ClosestDist) $ ")";
	NPCError( ErrorType, ErrorMessage );
}

//-----------------------------------------------------------------------------
// Return true if the given actor is a valid target for an attack. Return true
// if the target is an enemy even if the target's health is < 0.

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

	if( HitActor == None )
		return true;
		
	if( Pawn(HitActor) == None )
		return HitActor.CanHit( Self );

	if( HitActor == ControllerEnemy )
		return true;

	return ( GetAttitudeTo( Pawn(HitActor) ) != ATTITUDE_Friend );
}

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

function bool CanKnockdown( Pawn Instigator, vector HitLocation, float Damage, class<DamageType> DamageType, vector Momentum )
{
	if( !UnderScriptControl() )
		return true;
		
	if( Pawn != None && !Pawn.SameTeam( Instigator ) )
		return true;
		
	return false;
}

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

function bool CanPanic( Pawn Instigator, vector HitLocation, float Damage, class<DamageType> DamageType, vector Momentum )
{
	if( !UnderScriptControl() )
		return true;
		
	if( Pawn != None && !Pawn.SameTeam( Instigator ) )
		return true;
	
	return false;
}

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

function bool CanDoRagdollHit() { return true; }

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

defaultproperties
{
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}