U2AI.U2NPCControllerBot

//=============================================================================
// U2NPCControllerBot.uc
// Created By: Mike Fox
// Created On: 2/14/00
// $Author: Mfox $
// $Date: 12/16/02 10:31p $
// $Revision: 45 $
//=============================================================================

class U2NPCControllerBot extends U2NPCControllerAdvanced 
	abstract; // not implemented currently -- use U2NPCControllerBotOld

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

This is the AI Controller class for Unreal2's bots (player substitutes).

This class isn't currently implemented -- use U2NPCControllerBotOld.

Move here:
	teamgame code
	anything bIsPlayer related (unless it should be generalized to base/advanced classes

Afaik, all of the ReplicationInfo stuff should be moved down to the bot code. 
Unless we are going to need to replicate order-related info for basic NPCs in 
multiplayer games, or if we want clients to be able to see the internal orders
for basic NPCs this should only be needed for bots (when players want to see
what their bot teammates' orders are). The PRI also contains a bunch of other
stuff related to players' scores etc. which should be totally irrelevant for
basic NPCs.

+bots would be more fun if they would choose somewhat randomly among weapons
 which have more or less the same AIRating. Currently one weapon will tend
 to completely dominate.

+really need code (especially if above done) so that bot will prefer to
 keep current selection (high odds initially, decreasing with time, 
 possibly according to success vs current enemy). Currently, bot often
 rapidly switching between alt/pri fire for example.

+bots are too eager to attack without having much inventory and/or a good weapon.

Would be neat if players (bots) could destroy pickups which they don't use
(bPlayerOnly pickups etc.) but this would mean having support for damageable
pickups and maybe showing damage with smoke. This is pretty similar to how the
translocator worked in UT. 

*/

//mdf-tbd: remove all this stuff?

//mdf-tbd: not used? 
//var float Rating;
//var name RealState, RealLabel;
//var bool	bSpecialAmbush;
//var bool	bPowerPlay;
//var bool	bViewTarget;				// is being used as a viewtarget
//var AlternatePath AlternatePath;		// used by game AI for team games with bases

//mdf-tbd: remove all this stuff (not being used anywhere...):

/*
// base:
function SetRoamTarget( Actor NewRoamTarget )
{
	// should only ever be set in Roaming state
	DMAssert( false, GetContext() );
}

// bot: (roaming state)
	//-------------------------------------------------------------------------

	function SetRoamTarget( Actor NewRoamTarget )
	{
		RoamTarget = NewRoamTarget;
	}
*/

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

// AI properties
var float VictoryDanceOdds;

// AI flags
var bool bCamping;					
//var bool bCampOnlyOnce;
//var bool bGathering;
var bool bInitLifeMessage;
var bool bLeading;						// set when NPC attacking and has followers
//var bool bStayFreelance;				// in UT was used by assault to force bot to stay freelancing? Never true currently.

// helpers
var U2BotReplicationInfo BRI;

// internal
var bool	bBigJump;					// set while NPC is in falling state while executing a "special" jump (e.g. rocket jump)?
var float	CampTime;
var float	LastCampCheck;
var int		OldMessageID;
var name	OldMessageType;
var Actor	RoamTarget;					// current goal actor for roaming state if applicable

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

//-----------------------------------------------------------------------------
// mdf-tbd: take this out of WTDN -- have game check this when players
// join/leave game and handle selecting and destroying bots? In a way, though
// having this in WTDN makes sense because this is generally called when the 
// NPC no longer has an enemy or has been killed etc.)

function bool CheckDestroyNPC()
{
	local bool bRetVal;

	bRetVal = false;

	if( Level.NetMode != NM_Standalone && U2DeathMatch(Level.Game) != None && U2DeathMatch(Level.Game).TooManyBots() )
	{
		if( Pawn != None )
		{
			Pawn.Health = 0;
			Pawn.Died( Self, class'Suicided', Pawn.Location, vect(0,0,0) );
		}

		Destroy();
		bRetVal = true;
	}

	return bRetVal;
}

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

function bool CanRespawn()
{
	return true;
}

//-----------------------------------------------------------------------------
// Moved here from U2NPCControllerBase

function SetPeripheralVision()
{
	if( Pawn != None )
	{
		if( GetSkill() < 0.50 )
			Pawn.PeripheralVision = 0.7;
		else if( GetSkill() == 1.0 )
			Pawn.PeripheralVision = -0.2;
		else
			Pawn.PeripheralVision = 2.0 - 2.3 * GetSkill();
		
		Pawn.PeripheralVision = FMin( Pawn.PeripheralVision - U2PBasic.BaseAlertness, 0.9 );
		if( bSniping && ( AmbushSpot != None ) )
			Pawn.SetSightRadius( AmbushSpot.SightRadius );
		else
			Pawn.RestoreSightRadius();
	}
}

//-----------------------------------------------------------------------------
// Moved here from U2NPCControllerBase (mucks with peripheral vision).

function SetAlertness( float NewAlertness )
{
	if( Pawn.Alertness != NewAlertness )
	{
		Pawn.PeripheralVision += 0.707 * ( Pawn.Alertness - NewAlertness ); // used by engine for SeeEnemy()
		Pawn.Alertness = NewAlertness;
	}
}

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

function bool GetShouldUseDeviousTactics( float BaseSkill, float BaseOdds )
{
	return ( GetSkill() >= BaseSkill && 
			 !Level.Game.bTeamGame && 
			 (FDecision( BaseOdds - 0.15 * (Level.Game.NumBots + Level.Game.NumPlayers) )) );
}

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

function float AddedHumanThreat()
{
	if( Level.Game.bTeamGame )
		return -0.15;
	else
		return Super.AddedHumanThreat();
}

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

function InitPlayerReplicationInfo()
{
	Super.InitPlayerReplicationInfo();

	//mdf-tbd:
	if( PlayerReplicationInfo.VoiceType == None && VoiceType != "" )
		PlayerReplicationInfo.VoiceType = class<VoicePack>(DynamicLoadObject(VoiceType,class'Class'));
}

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

function Restart()
{
	#debug DMAI( "Restart" );
	//mdf-tbd: why/when would we want to clear the RealOrdersObject?
	//mdf-tbd: SetOrders( BRI.RealOrders, BRI.RealOrderGiver, None, false );
	#debug DMAI( "SetOrders " $ GetContext() );
	SetOrders( BRI.RealOrders, BRI.RealOrdersObject, 0.0, BRI.RealOrderGiver );
	Super.Restart();
}

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

event PostBeginPlay()
{
	Super.PostBeginPlay();

	// store pre-cast reference to BRI
	BRI = U2BotReplicationInfo(PlayerReplicationInfo);
}

//-----------------------------------------------------------------------------
// @ WhatToDoNext

#debug   function WhatToDoNext( string ContextStr )
#release function WhatToDoNext()
{
	if( !CheckDestroyNPC() )
	{
		RestoreRealOrders();
		#debug   Super.WhatToDoNext( ContextStr );
		#release Super.WhatToDoNext();
	}
	else
	{
		#debug DMAI( "WTDN -- NPC will be destroyed" );
	}
}

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

function bool ShouldFireWeapon( float Rating, bool bUseAltMode )
{
	return( Rating > U2Weapon.RatingIneffective );
}

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

function bool SplashJump()
{
	return Pawn.Weapon.SplashJump();
}

//-----------------------------------------------------------------------------
//@ MESSAGES
//-----------------------------------------------------------------------------

function CallForHelp()
{
	local Controller C;

	SendMessage( None, 'Other', 4, 15, 'TEAM' );
		
	#debug DMAI( "CallForHelp" );
	for ( C=Level.ControllerList; C!=None; C=C.NextController )
		if( C != Self && C.PlayerReplicationInfo.Team == PlayerReplicationInfo.Team && C.CanHelp() )
			C.HandleHelpMessageFrom( Self );
}

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

function HandleHelpMessageFrom( Controller Other )
{
	#debug DMAI( "HandleHelpMessageFrom " $ Other );
	if( ReadyForAction() && Other.ControllerEnemy != None && (VSize( Other.ControllerEnemy.Location - Pawn.Location ) < 800) )
	{
		if( Other.bIsPlayer )
			SendMessage( Other.PlayerReplicationInfo, 'OTHER', 10, 10, 'TEAM' );
		#debug DMAI( "HandleHelpMessageFrom -- calling MaybeSetEnemy" );
		MaybeSetEnemy( Other.ControllerEnemy );
		#debug   UpdateBehavior( false, GetContext() );
		#release UpdateBehavior( false );
	}
}

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

function SendMessage( PlayerReplicationInfo Recipient, name MessageType, byte MessageID, float Wait, name BroadcastType )
{
	// limit frequency of same message
	if( MessageType == OldMessageType && MessageID == OldMessageID && Level.TimeSeconds - OldMessageTime < Wait )
		return;

	// added for UW739
	if ( Level.Game.bGameEnded || Level.Game.bWaitingToStartMatch )
		return;

	OldMessageID = MessageID;
	OldMessageType = MessageType;

	SendVoiceMessage( PlayerReplicationInfo, Recipient, MessageType, MessageID, BroadcastType );
}

//-----------------------------------------------------------------------------
// //MWP/ARL (mdf) -- SendMessages are using hard-coded indices to messages 
// which pbly no longer apply in U2. Switch to using constants and/or cleanup.

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

function SendMessageAcknowledgeOrders( Controller OrderGiver, float Wait )
{
	SendMessage( OrderGiver.PlayerReplicationInfo, 
				 'ACK', 
				 0, //MWP/ARL-tbd: Rand( class<ChallengeVoicePack>( PlayerReplicationInfo.VoiceType ).default.NumAcks ), 
				 Wait, 
				 'TEAM' );
}

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

function SendMessageNearPoint( Pawn Point, float Wait )
{
	if( !bInitLifeMessage && Point.Health > 0 && VSize( Pawn.Location - Point.Location ) < 500 )
	{
		bInitLifeMessage = true;
		SendMessage( Point.PlayerReplicationInfo, 'OTHER', 3, Wait, 'TEAM' );
	}
}

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

function SendMessageInPosition( float Wait )
{
	if( !bInitLifeMessage )
	{
		bInitLifeMessage = true;
		SendMessage( None, 'OTHER', 9, Wait, 'TEAM' );
	}
}

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

function YellAt( Pawn Moron )
{
	local float Odds;

	if( ControllerEnemy == None )
		Odds = 0.7;
	else
		Odds = 0.3;

	if( FDecision( Odds ) )
	{
		SendMessage( 
			None, 
			'FRIENDLYFIRE', 
			0, //MWP/ARL Rand( class<ChallengeVoicePack>( PlayerReplicationInfo.VoiceType ).default.NumFFires ), 
			5, 
			'TEAM' );
	}
}	

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

function HandleHoldAtDestination()
{
	SendMessageInPosition( 45.0 );

	if( !bInitLifeMessage )
		bInitLifeMessage = true;
}

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

function bool DeferTo( Controller Other )
{
	return ( Super.DeferTo( Other ) || (Other.PlayerReplicationInfo != None && Other.PlayerReplicationInfo.HasFlag != None) );
}

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

function bool TestCanJump()
{
	return( MoveTarget != None && (MoveTarget.Physics != PHYS_Falling || Pickup(MoveTarget) == None) );
}

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

function AmbushPickSpot()
{
	local NavigationPoint N;

	for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
	{
		// find closest ambush spot which isn't already taken
		// mdf-tbd: this doesn't check for whether owner of ambush spot is an enemy
		if( AmbushPoint(N) != None && !N.Taken && 
			(AmbushSpot == None || VSize( Pawn.Location - AmbushSpot.Location ) > VSize( Pawn.Location - N.Location)) )
		{
				AmbushSpot = AmbushPoint( N );
		}
	}
}

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

function AmbushClearOtherSpots()
{
	local Controller C;

	if( Level.Game.bTeamGame )
	{
		for ( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.bIsBot && 
				C.Pawn != Pawn && 
				GetAttitudeTo( C.Pawn ) != ATTITUDE_Enemy && 
				U2NPCControllerBot(C).AmbushSpot == AmbushSpot )
			{
				U2NPCControllerBot(C).AmbushSpot = None;
			}
		}
	}
}

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

function bool AmbushFindSpot()
{
	if( AmbushSpot == None )
		AmbushPickSpot();

	// if none found, use current MoveTarget if possible mdf-tbd: this doesn't check for whether owner of ambush spot is an enemy
	if( AmbushSpot == None && AmbushPoint(MoveTarget) != None && !AmbushPoint(MoveTarget).Taken )
		AmbushSpot = AmbushPoint( MoveTarget );
					
	if( AmbushSpot != None )
	{
		if( VSize( AmbushSpot.Location - Pawn.Location ) < 2 * Pawn.CollisionRadius )
		{
			if( Orders == OrdersDefend )
				SendMessageInPosition( 60.0 );
			bSniping = ( Orders == OrdersDefend && AmbushSpot.bSniping );
			CampTime = 10.0;
			Pawn.SetSightRadius( AmbushSpot.SightRadius );
			GotoState( RoamingState, CampLongLabel ); //GS-tbd
		}
		else
		{	
			GetPathToActor( AmbushSpot, MoveTarget, true );
			if( MoveTarget == None )
				AmbushSpot = None;
		}

		if( AmbushSpot != None )
		{
			AmbushSpot.Taken = true;

			// make sure nobody else is after this spot
			AmbushClearOtherSpots();
		}
	}

	return( AmbushSpot != None );
}	

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

function bool ShouldDeferTo( Controller Other )
{
	return( (Other.PlayerReplicationInfo != None && Other.PlayerReplicationInfo.HasFlag != None) || Super.ShouldDeferTo( Other ) );
}

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

function bool UseTacticalJumps()
{
	// note(mdf): total guess that jumps during tactical moves are avoided for
	// RL and other splash damage weapons because of danger of damaging self?
	// Ideally, IMO, bots should be just as jump with RL etc.
	return ( !TrySplashDamageAttack() && (U2PBasic.bJumpy || (FRand()*GetSkill() > 2.3)) );
}

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

function float WeaponPreference( Weapon W )
{
	if( W.Class == U2Player(Pawn).FavoriteWeapon )
		return 0.22;
	return 0;
}

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

function float AdjustDesireFor( Pickup P )
{
	if( P.InventoryType == U2Player(Pawn).FavoriteWeapon )
		return 0.35;
	return 0;
}

//-----------------------------------------------------------------------------
// mdf-tbd: of no use in singleplayer since NPCs will have infinite ammo?

function bool AmmoReadyForAction( U2Weapon U2W )
{
	//#debug DMAI( "AmmoReadyForAction: " $ U2W != None && U2W.HasEnoughAmmo( 5 ) );
	// enough ammo for at least 5 uses for bots?
	return( U2W != None && U2W.HasEnoughAmmo( 5 ) );
}

//-----------------------------------------------------------------------------
// mdf-tbi: something like, on startup, look at the inventory in the level and 
// determine an "inventory score" which must be met before the bot will attack
// (like what was done for WoT bots). Also make sure that the bot has enough 
// ammo -- hook into HasEnougAmmo() (add to Weapon?).

function bool InventoryReadyForAction()
{
	local bool bRetVal;

	// NOTE: for speed we could "cache" this call as long as bot's inventory doesn't change
	// mdf-tbd: use each items's desireability?
	// mdf-tbd: for now encourage bot to get up to at least 1/3 of his potential offensive and defensive strength
	// mdf-tbd: what about other pickups?
	bRetVal = ( class'UtilGame'.static.GetInventoryCount( Pawn, Class'Weapon' )  >= 0.333*Level.Game.GetLevelRatingOffensive() &&
				class'UtilGame'.static.GetInventoryCount( Pawn, Class'Armor' ) >= 0.333*Level.Game.GetLevelRatingDefensive() );

	//#debug DMAI( "InventoryReadyForAction: " $ bRetVal );
	//DM( "InventoryReadyForAction WC:  " $ class'Util'.static.GetInventoryCount( Pawn, Class'Weapon' )  $ " RO: " $ 0.333*Level.Game.GetLevelRatingOffensive() );
	//DM( "InventoryReadyForAction PUC: " $ class'Util'.static.GetInventoryCount( Pawn, Class'Armor' ) $ " RD: " $ 0.333*Level.Game.GetLevelRatingDefensive());

	return bRetVal;
}

/*-----------------------------------------------------------------------------
Returns true if the NPC is "prepared", e.g. has a good enough weapon and 
enough inventory and Health to carry out the orders, go hunting etc. Returns 
true by default subclasses can override this as necessary.

mdf-tbd: add a "risk" parameter to indicate how "well-stocked" NPC should
be and scale return value accordingly in subclasses. Maybe also path in
a minimum  Health amount (percentage of max Health)?

mdf-tbd: should depend somewhat on inventory in level.
mdf-tbd: should this be used at all for singleplayer NPCs -- what about low 
health and energy if the NPC can't obtain any more in the current level --
run away and become less aggressive / ignore and keep attacking as if at 
full health / armor.
*/

function bool ReadyForAction()
{
	local bool bRetVal;

	bRetVal = ( Pawn != None &&
				Pawn.Weapon != None &&
				Pawn.Weapon.AIRating >= 0.4 &&
				AmmoReadyForAction( U2Weapon(Pawn.Weapon) ) && 
				Pawn.Health > 70 &&
				(U2PBase.GetPowerSuitMax() == -1.0 || U2PBase.GetPowerSuitPct() > 0.25 ) &&
				InventoryReadyForAction() );

	//#debug DMAI( "ReadyForAction: " $ bRetVal );
	//DM( "ReadyForAction: " $ Super.ReadyForAction() && InventoryReadyForAction() );
	return( bRetVal );
}

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

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

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

function bool ShouldGiveUpHunting()
{
	return( GetSkill() < 0.50 || (Level.Game.NumBots + Level.Game.NumPlayers) > 2 );
}

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

function bool PreparedToHunt()
{
	#debug DMAI( "PreparedToHunt" );
	return( ((GetSkill() >= 0.50) || (Level.Game.NumPlayers + Level.Game.NumBots == 2)) && ReadyForAction() );
}

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

function SetAttractionState()
{
	/* mdf-tbd:
	if( ControllerEnemy != None )
	{
		if( !IsInState( FallBackState ) )
		{
			//mdf-tbd: SetNoClearSpecial( true );
			GS( AttackFallBackState, MoveSpecialLabel ); //GS-tbd
		}
	}
	else if( !IsInState( RoamingState ) )
	{
		//mdf-tbd: SetNoClearSpecial( true );
		GS( RoamingState, MoveSpecialLabel ); //GS-tbd
	}
	*/
}

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

function bool FindSpecialAttraction()
{
	local Actor SpecialAttractionActor;

	// mdf-tbd: code stolen from UT version in CTFGame (seems hackish -- is it really needed?)
//	if( LastSpecialDestinationCheck == Level.TimeSeconds )
//		return false;
//	LastSpecialDestinationCheck = Level.TimeSeconds;

	if( SpecialGoal != None )
	{
		// build a path to it
		GetPathToActor( SpecialGoal, SpecialAttractionActor, true );

		// mdf-tbr:
		if( SpecialAttractionActor != None )
		{
			SetAttractionState();
		}
		else
		{
			//DMTNS( "Can't get to special goal actor: " $ SpecialGoal );
		}

		if( SpecialAttractionActor != None )
		   MoveTarget = SpecialAttractionActor;
	}

	return ( SpecialAttractionActor != None );
}

//-----------------------------------------------------------------------------
//@ ORDERS
//-----------------------------------------------------------------------------

function UpdateOrders( name NewOrders, Actor NewOrdersObject, float NewOrdersThreshold, Object NewOrderGiver )
{
	Super.UpdateOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver );

	// mdf-tbd: bLeading set if given attack orders & has followers
	bLeading = false;

	// mdf-tbd:
	if( NewOrders != GetRealOrders() && Pawn != None )
	{ 
		// mdf-tbd: resolve polymorphically by moving into appropriate states -- don't use IsInState!
		if( (IsInState( RoamingState ) && bCamping) || IsInState( WanderingState ) )
			GotoState( RoamingState, PreBeginLabel ); //GS-tbd
	}

	// mdf-tbd:
	//bStayFreelance = false;
}

//-----------------------------------------------------------------------------
// mdf-tbd: could be useful in advanced?

function bool ProcessOrdersAttack()
{
	local Controller C;
	local U2NPCControllerBot B;

	U2PBasic.CampingRate = 0.0;

	// set bLeading if have supporters
	if( Level.Game.bTeamGame )
	{
		for( C=Level.ControllerList; C!=None; C=C.NextController )
		{
			if( C.bIsPlayer && C.PlayerReplicationInfo.Team == PlayerReplicationInfo.Team )
			{
				B = U2NPCControllerBot( C );

				if( B != None && 
					B.OrdersObject == Self && 
					B.BRI.RealOrders == OrdersFollow )
				{
					bLeading = true;
					break;
				}
			}
		}
	}

	return true;
}

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

function bool ProcessOrdersDefend( out Actor NewOrdersObject )
{
	NewOrdersObject = SetDefense();

	if( NewOrdersObject == None )
	{
		// mdf-tbd: send message?
		#debug DMAI( "ProcessOrdersDefend() failed (no defense object): " $ GetContext() );
		//SetOrders( OrdersNone, OrderGiver, None, false );
	}
	else
	{
		U2PBasic.CampingRate = 1.0;
	}

	return (NewOrdersObject != None);
}

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

function RestoreRealOrders()
{
	#debug DMAI( "RestoreRealOrders" );
	//mdf-tbd: why/when would we want to clear the RealOrdersObject?
	//SetOrders( BRI.RealOrders, BRI.RealOrderGiver, None, false );
	#debug DMAI( "SetOrders " $ GetContext() );
	SetOrders( BRI.RealOrders, BRI.RealOrdersObject, 0.0, BRI.RealOrderGiver );
}

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

function bool ProcessOrders( name NewOrders, Actor NewOrdersObject, out float NewOrdersThreshold, out Object NewOrderGiver )
{
	local bool bResult;

	OrdersThreshold = NewOrdersThreshold;
	switch( NewOrders )
	{
		case OrdersAttack:
			bResult = ProcessOrdersAttack();
			break;

		case OrdersDefend:
			bResult = ProcessOrdersDefend( NewOrdersObject );
			break;

		default:
			bResult = Super.ProcessOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver );
			break;
	}

	return bResult;
}

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

function bool SetOrders( optional name NewOrders, optional Actor NewOrdersObject, optional float NewOrdersThreshold, optional Object NewOrderGiver, optional bool bAcknowledge )
{
	local bool bResult;

	bResult = Super.SetOrders( NewOrders, NewOrdersObject, NewOrdersThreshold, NewOrderGiver, bAcknowledge );

	if( bAcknowledge && Controller(OrderGiver) != None )
		SendMessageAcknowledgeOrders( Controller(OrderGiver), 5.0 );

	SetRealOrders( Orders, OrdersObject, OrderGiver );

	return bResult;
}

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

function name GetOrders()
{
	return BRI.RealOrders;
}

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

function Actor GetOrdersObject()
{
	return BRI.RealOrdersObject;
}

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

function SetRealOrders( name NewOrders, Actor NewOrdersObject, Object NewOrderGiver )
{
	BRI.RealOrders = NewOrders;
	BRI.RealOrdersObject = NewOrdersObject;
	BRI.SetRealOrderGiver( NewOrderGiver );
}

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

function name GetRealOrders()
{
	return BRI.RealOrders;
}

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

function bool PickLocalInventoryDestination( float MaxDist, float MinDistraction )
{
	local Pickup LocalPickup, BestPickup;
	local float NewWeight, BestWeight;
	local float DistanceToPickup;
	local bool bResult;

	#debug DMAIM( "PickLocalInventoryDestination -- MaxDist: " $ MaxDist $ " MinDistraction: " $ MinDistraction );
	bResult = false;
	if( Pawn.bCanPickupInventory )
	{
		// first look at nearby inventory < MaxDist (mdf: use 2*MaxDist for weapons)
			//!!mdf-tbd: VCA seems to be really slow -- should it be avoided/fixed?
		foreach VisibleCollidingActors( class'Pickup', LocalPickup, 2*MaxDist, Pawn.Location, true )
		{
			DistanceToPickup = VSize( LocalPickup.Location - Pawn.Location );

			// only look for weapons at 2xMaxDist
			if( WeaponPickup(LocalPickup) == None && DistanceToPickup > MaxDist )
				continue;

			// mdf-tbd: check for PHYS_Falling means bots very unlikely to after
			// weapon tossed by immediate victim since it will take a while to
			// land. Ideally, bots would wait for the weapon to land but we don't
			// want them going after weapons that are going to fall a long way and/or
			// far away.
			if( LocalPickup.ReadyToPickup( 0.0 ) && 
				LocalPickup.MaxDesireability/60 > BestWeight && 
				LocalPickup.Physics != PHYS_Falling && 
				LocalPickup.Location.Z < (Pawn.Location.Z + Pawn.MaxStepHeight + Pawn.CollisionHeight) )
			{
				// mdf-tbd: BotDesireability not too good about encouraging bot to take
				// weapon even if it already has one as a defensive measure.
				
				NewWeight = LocalPickup.BotDesireability( Pawn );

				if( (NewWeight > MinDistraction) || 
					(LocalPickup.Inventory != None && WeaponPickup(LocalPickup) != None && (DistanceToPickup < 0.6*MaxDist)) )
				{
					NewWeight = NewWeight/DistanceToPickup;
					if( NewWeight > BestWeight )
					{
						BestWeight = NewWeight;
						BestPickup = LocalPickup;
					}
				}
			}
		}

		// mdf-tbd: add support for trying for next N best from above if can't reach best one (not more than 2/3 though)
	    if( BestPickup != None )
		{
			Pawn.bCanJump = ( BestPickup.Location.Z > Pawn.Location.Z - Pawn.CollisionHeight - Pawn.MaxStepHeight );
			if( ActorReachable( BestPickup ) )
			{
				MoveTarget = BestPickup;
				bResult = true;
			}
			Pawn.bCanJump = true;
		}
	}

	#debug DMAIM( "PickLocalInventoryDestination returning MoveTarget: " $ MoveTarget );
	return bResult;
}

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

function BigJump( Actor JumpDest )
{
	Pawn.SetPhysics( PHYS_Falling );
	Pawn.Velocity = Pawn.GroundSpeed * Normal( JumpDest.Location - Pawn.Location );
	if( JumpSpot(JumpDest) != None && JumpSpot(JumpDest).bAlwaysAccel )
	{
		bBigJump = true;
		Pawn.Acceleration = Pawn.AccelRate * Normal( Destination - Pawn.Location );
	}
	else 
	{
		StopMovement( true, false );
	}
	
	if( Pawn.bCountJumps )
		Pawn.Inventory.OwnerEvent( 'Jumped' );
	Pawn.Velocity.Z = Pawn.JumpZ;
	Pawn.Velocity = EAdjustJump( Destination, Pawn.Velocity.Z, Pawn.GroundSpeed );
	bSpecialJump = true;
	Pawn.DesiredRotation = rotator( JumpDest.Location - Pawn.Location );
	FocalPoint = JumpDest.Location + 100 * (JumpDest.Location - Pawn.Location);
	if ( Pawn.PhysicsVolume.Gravity == Pawn.PhysicsVolume.default.Gravity )
		MoveTarget = None;
	
	Pawn.bBlockAdjustJump = true;
	SetFall();
}

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

function Actor SetDefense()
{
	return None;
}

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

function bool HandleFriendlyBumps()
{
	// mdf-tbd: just return true so any friendly creatures in non-teamgame (?) handled?
	return Level.Game.bTeamGame;
}

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

function bool WanderAfterFriendlyBumpExtra()
{
	return (
		AllowFriendlyBumpStateChanges() &&
		Pawn.Health > 0 && 
		ControllerEnemy == None && 
		(bCamping ||
	 	 (Orders == OrdersFollow && 
	 	  MoveTarget == Controller(OrdersObject).Pawn && 
	 	  MoveTarget.Acceleration == vect(0,0,0))) );
}

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

function HandleEnemyKilledSafe( Controller Killer, Pawn KilledEnemy )
{
	if( Killer == Self )
	{
		// I was the killer
		if( FDecision( VictoryDanceOdds ) && Orders != OrdersAttack )
		{
			#debug   SetControllerTarget( KilledEnemy, GetContext() );
			#release SetControllerTarget( KilledEnemy );
			GotoState( VictoryDanceState ); //GS-tbd
		}
		else
		{
			#debug   BehaviorController.Update( BC_UpdateInactive, GetContext() );
			#release BehaviorController.Update( BC_UpdateInactive );
		}
	}
	else
	{
		// mdf-tbd: bots who have KilledEnemy as an enemy could sometimes say "hey, that one was mine" etc.)
		// or, in team games, "nice kill" etc.
		#debug   BehaviorController.Update( BC_UpdateInactive, GetContext() );
		#release BehaviorController.Update( BC_UpdateInactive );
	}
}

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

function NotifyKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType )
{
	Super.NotifyKilled( Killer, Killed, KilledPawn, DamageType );

	if( ControllerEnemy == None && Level.Game.bTeamGame )
	{
		// mdf-tbd -- not used in UW?
		// if( Orders == OrdersFollow && Other.Controller == OrdersObject )
		// PointDied = Level.TimeSeconds;

		// did bot witness teammate's death?
		if( KilledPawn != Pawn &&
			(VSize( Pawn.Location - KilledPawn.Location ) < 1400) && 
			LineOfSightTo( KilledPawn ) )
		{
			SendMessage( None, 'OTHER', 5, 10, 'TEAM' ); //FIXME - ONLY IF ON SAME TEAM!!!
		}
	}
}

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

state @ AttackCloseState
{
    ignores SeeFriend, SeeOther, SeeAlertFriend, HearNoise;

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

	function ETacticalMoveType GetTacticalMoveType()
	{
		if( !Level.Game.bTeamGame )
			return Super.GetTacticalMoveType();
		else
			return TMT_None;
	}
}	

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

state @ AttackFallbackState
{
	ignores EnemyNotVisible;

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

	function bool OverrideSpecialAttraction()
	{
		local bool bResult;
		local byte TeamPriority;

		// prefer local inventory depending on priority of special attraction
		TeamPriority = PriorityObjective();
		if( TeamPriority > 16 )
   			bResult = PickLocalInventoryDestination( 160, 1.8 );
   		else if( TeamPriority > 1 )
   			bResult = PickLocalInventoryDestination( 200, 1.0 );
   		else if( TeamPriority > 0 )
   			bResult = PickLocalInventoryDestination( 200, 0.55 );
		else
	   		bResult = PickLocalInventoryDestination( 400, 0.5 );

		return bResult;
	}
}

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

state @ AttackHuntState
{
	ignores EnemyNotVisible; 

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

	function bool SpecialHuntDestination()
	{
		local float MaxDist;

		if( Level.TimeSeconds - LastInvFind > 4 - 3.0 * GetSkill() )
		{
			LastInvFind = Level.TimeSeconds;
			MaxDist = 600 + 250 * GetSkill();

			return PickLocalInventoryDestination( MaxDist, 0.6/MaxDist );
		}
	}
}

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

state @ AttackRetreatState
{
	ignores EnemyNotVisible;

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

	function bool FindRetreatDestination()
	{
		local float MaxDist, BestWeight;
		local Actor BestPath;

		// first look at nearby inventory < 500 Dist
		MaxDist = 500 + 280 * GetSkill();

		if( !PickLocalInventoryDestination( MaxDist, 0.001 ) )
		{
			// look for long distance inventory 
			BestWeight = FindBestInventoryPath( BestPath, 0.0, false );

			if( Level.Game.bTeamGame && BestWeight < 0.0002 )
			{
				if( StationaryPawn(ControllerEnemy) == None && (ControllerEnemy.Location.Z < Pawn.Location.Z + 500) )
				{
					bKamikaze = true;
					if( LineOfSightTo( ControllerEnemy ) )
					{
						LastInvFind = Level.TimeSeconds;
						GotoState( AttackTacticalMoveState, DontCloseLabel ); //GS-tbd
						return true;
					}
				}
			}
		}

		if( BestPath != None )
			MoveTarget = BestPath;

		return( BestPath != None );
	}

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

	function bool StopFearingEnemy()
	{
		return ( Super.StopFearingEnemy() || (Level.Game.bTeamGame && (GetTimeSinceEnemyLastDetected() > 8)) );
	}

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

@ FaceTargetLabel:

	if( InventorySpot(MoveTarget) != None && 
		InventorySpot(MoveTarget).markedItem != None && 
		InventorySpot(MoveTarget).markedItem.ReadyToPickup(0.0) && 
		Desireability( InventorySpot(MoveTarget).markedItem ) > 0 )
	{
	 	MoveTarget = InventorySpot( MoveTarget ).markedItem;
	}
}

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

state @ AttackStakeOutState
{
	ignores EnemyNotVisible; 

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

	function bool RandomizeStakeOutDir()
	{
		return Level.Game.bTeamgame;
	}
}

/*
state @ AttackTacticalMoveState
{
	ignores HearNoise, NotifyBump, SeeFriend, SeeOther, SeeAlertFriend;

	function PickDestination( bool bCanCharge )
	{
		local float MaxDist;

		#debug DMAI( "TacticalMove.PickDestination: " $ bCanCharge );
		// possibly Pick nearby inventory
		// higher skill bots will always strafe, lower skill
		// both do this less, and strafe less

		bGathering = false;
		if( (Level.TimeSeconds - LastInvFind) < (5 - 3.5 * GetSkill()) )
		{
			Super.PickDestination( bCanCharge );
		}
		else
		{
			LastInvFind = Level.TimeSeconds;
			MaxDist = 700 + 210 * GetSkill();
			if( PickLocalInventoryDestination( MaxDist, 0.5/MaxDist ) )
				bGathering = true;
			else
				Super.PickDestination( bCanCharge );
		}
	}

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

	function eventEnemyNotVisible()
	{
		if( !bGathering )
			Super.eventEnemyNotVisible();
		Disable( 'EnemyNotVisible' );
	}
} // AttackTacticalMoveState

//-----------------------------------------------------------------------------
// mdf-tbd: seems that TookDamage is getting called even though eventTakeDamage
// is ignored (so I had to add ignores DamageAttitudeTo also). Why?

state @ DeadState
{
	ignores EnemyInLeapRange, EnemyInMeleeRange, SeeEnemy, SeeFriend, SeeOther, SeeAlertFriend, eventTakeDamage, DamageAttitudeTo, EnemyNotVisible, HearNoise, ShotFiredNotification, NotifyLanded, NotifyPhysicsVolumeChange,  NotifyHeadVolumeChange, NotifyLanded, NotifyHitWall, NotifyBump;

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

	event BeginState()
	{
		//mdf-tbd: is this check even needed (can we get here without going through same check in WTDN?
		if( !CheckDestroyNPC() )
		{
			Super.BeginState();
	
			SetSharedTimer( 0, false );
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
			if ( bSniping && (AmbushSpot != None) )
				AmbushSpot.Taken = false;
	
			AmbushSpot = None;
			// mdf-tbd -- not used in UW?
			// PointDied = -1000;

			ResetGlobalAISettings();
	
			bSniping = false;
			bInitLifeMessage = false;
		}
	}

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

@ BeginLabel:
	if ( Level.Game.bGameEnded )
		GS( GameEndedState ); //GS-tbd
	Sleep(0.2);

@ TryAgainLabel:
	Sleep( 0.25 + U2GameInfo(Level.Game).SpawnWait( Self ) );

	Level.Game.ReStartPlayer( Self );
	Goto( TryAgainLabel );

@ WaitingForStartLabel:
} // DeadState

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

state @ AttackHuntState
{
	ignores EnemyNotVisible; 

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

	function MaybeClearHuntingEnemy()
	{
		// If no enemy, or I should see him but don't, then give up		
		if( GetTimeSinceEnemyLastDetected() > 26 - Level.Game.NumPlayers - Level.Game.NumBots )
			#debug   SetControllerEnemy( None, GetContext() );
			#release SetControllerEnemy( None );
	}
} // AttackHuntState

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

state @ AttackRetreatState
{
	ignores EnemyNotVisible;

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

	event BeginState()
	{
		if( Level.Game.bTeamGame && ControllerEnemy.IsMobile() )
			CallForHelp();

		Super.BeginState();
	}
} // AttackRetreatState

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

// ==> WAS BOT
// I'd like to kill off roaming completely for anything but bots but it may still
// be need to support orders for base/basic/advanced NPCs (tbd)

// merge this with advanced, basic, base, versions below and maybe pull some of this into basic/advanced?

state @ RoamingState
{
	ignores EnemyNotVisible;

	function ShareWith( Pawn Other )
	{
		if( !Other.PlayerReplicationInfo.bIsSpectator )
			Super.ShareWith( Other );
	}

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

	function bool CanHelp()
	{
		return true;
	}

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

	function HandleTeamGameStuff()
	{
		if( Level.Game.bTeamGame )
		{
			if( Orders == OrdersNone && !bStayFreelance &&	Orders != BRI.RealOrders ) 
			{
				//mdf-tbd: why/when would we want to clear the RealOrdersObject?
				//SetOrders( BRI.RealOrders, BRI.RealOrderGiver, None, true );
				#debug DMAI( "SetOrders " $ GetContext() );
				SetOrders( BRI.RealOrders, BRI.RealOrderGiver, BRI.RealOrdersObject );
			}
			if( FRand() < 0.5 )
				bStayFreelance = false;
		}
	}

	//-------------------------------------------------------------------------
	// Calls FindSpecialAttraction which (in UT) was used to identify a special
	// destination, such as a flag lying on the ground. If there is a special
	// attraction, checks for local (directly reachable) inventory in a radius
	// which decreases with the priority of the special attraction. Not too
	// sure yet how this will fit in with U2 approach. Note that the version of
	// FindSpecialAttraction in CTFBot is a mess -- setting up lots of global
	// stuff and possibly switching the bot's state, e.g. to attack an enemy
	// carrying the flag.

	function bool PickSpecialDestination()
	{
		local byte TeamPriority;
		local bool bSpecialAttraction;

		//!!! collapse with similar (almost identical) code in Base
		bSpecialAttraction = false;
		if( FindSpecialAttraction() )
		{
			// special attraction but see if we should go after local inventory
			// mdf-tbd: I'm not sure this works correctly much of the time since
			// in some cases FindSpecialAttraction will have caused a state change
			// which will take us out of the Roaming state regardless of whether
			// or not some local inventory is selected, no?
			TeamPriority = PriorityObjective();
			if( TeamPriority > 16 )
				PickLocalInventoryDestination( 160, 1.8 );
			else if( TeamPriority > 1 )
				PickLocalInventoryDestination( 200, 1.0 );
			else if( TeamPriority > 0 )
				PickLocalInventoryDestination( 280, 0.55 );
			else
				PickLocalInventoryDestination( 400, 0.5 );

			bSpecialAttraction = true;
		}

		return bSpecialAttraction;
	}

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

	function bool SetHuntDestination( Actor TargetActor )
	{
		GetPathToActor( TargetActor, MoveTarget, true );
		return( MoveTarget != None );
	}

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

	function bool PickHuntDestination()
	{
		local bool bResult;
		local Controller C;

		bResult = false;
		if( PreparedToHunt() )
		{
			if( Pawn(RoamTarget) != None && !LineOfSightTo( RoamTarget ) )
			{
				// continue hunting RoamTarget
				bResult = SetHuntDestination( RoamTarget );
			}
			else
			{
				// high skill bots go hunt player
				// mdf-tbd: 
				//  #1 isn't this "cheating" since  this lets the NPC make a beeline for the selected player -- do we care?
				// 	#2 shouldn't this also target AIControllers (i.e. any players, not just real ones)?
				//  #3 
				for( C=Level.ControllerList; C!=None; C=C.NextController )
				{
					if( C.IsRealPlayer() && ((VSize( C.Location - Pawn.Location ) > 1500) || !LineOfSightTo( C )) )
					{
						if( SetHuntDestination( C ) )
						{
							RoamTarget = C;
							bResult = true;
							break;
						}
					}
				}
			}

			if( !bResult )
			{
				// mdf-tbd: I don't understand this comment -- seems backwards
	 			bWantsToCamp = true; // don't camp if couldn't go to player
			}
		}

		return bResult;
	}

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

	function PickDestination()
	{
		HandleTeamGameStuff();

		// mdf-tbd:
		Super.PickDestination();
	}

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

	function ModifyInventorySpotMoveTarget()
	{
		local InventorySpot InventorySpotTarget;

		#debug DMAIM( "MoveTarget is InventorySpot: " $ MoveTarget );

		InventorySpotTarget = InventorySpot( MoveTarget );
		if( ( PriorityObjective() == 0 )
			&& ( InventorySpotTarget.markedItem != None )
			&& ( Desireability( InventorySpotTarget.markedItem ) > 0) )
		{
			if( InventorySpotTarget.markedItem.ReadyToPickup( 0.0 ) )
			{
				MoveTarget = InventorySpot( MoveTarget ).markedItem;
			}
			else if( InventorySpotTarget.markedItem.ReadyToPickup( 5.0 ) && Pawn.NearSpot( MoveTarget.Location ) )	
			{
				CampTime = FMin( 5, InventorySpotTarget.markedItem.LatentFloat + 0.5 );
				bCampOnlyOnce = true;
				GL( CampLabel );
			}
		}
	}

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

	function ModifyMoveTarget()
	{
		if( InventorySpot(MoveTarget) != None )
		{
			ModifyInventorySpotMoveTarget();
		}
		else if( Pickup(MoveTarget) != None && Level.Game.bTeamGame )
		{
			ModifyPickupMoveTarget();
		}
	}
} // RoamingState

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

// ==> WAS ADVANCED:
state @ RoamingState
{
	ignores EnemyNotVisible;

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

	function HearPickup( Pawn Other )
	{
		if( GetSkill() < FRand() - 0.125 )
			return;

		if( (Pawn.Health > 70) && (Pawn.Weapon.AIRating > 0.6) && (RelativeStrength( Other ) < 0) )
			HearNoise( 0.5, Other );
	}

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

	function bool PickFarInventoryDestination()
	{
		// look for long distance inventory 
		FindBestInventoryPath( MoveTarget, 0.0, (GetSkill() >= 0.75) );
		#debug DMAIM( "PickFarInventoryDestination MoveTarget: " $ MoveTarget );
		return( MoveTarget != None );
	}

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

	function PickDestination()
	{
		// mdf-tbd:
		Super.PickDestination();
	}

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

	function ShareWith( Pawn Other )
	{
		local bool bHaveItem, bIsHealth, bOtherHas, bIsWeapon;

		#debug DMAIM( "ShareWith" );

		if( WeaponPickup(MoveTarget) != None )
		{
			if( ( Pawn.Weapon == None ) || ( Pawn.Weapon.AIRating < 0.5 ) || WeaponPickup(MoveTarget).bWeaponStay )
				return;

			bIsWeapon = true;
			bHaveItem = (Pawn.FindInventoryType( Pickup(MoveTarget).InventoryType ) != None );
		}
//
//		// mdf-tbd //MDF: no such thing as Health class should also handle energy etc.
//		else if( Health(MoveTarget) != None )
//		{
//			bIsHealth = true;
//			if( Pawn.Health < 80 )
//				return;
//		}

		if( (Other.Health <= 0) || 
			(VSize( Other.Location - Pawn.Location ) > 1250) || 
			!LineOfSightTo( Other ) )
			return;

		//decide who needs it more
		CampTime = 2.0;
		if( bIsHealth )
		{
			if( Pawn.Health > Other.Health + 10 )
			{
				GL( GiveWayLabel );
				return;
			}
		}
		else if( bIsWeapon && ( Other.Weapon != None ) && ( Other.Weapon.AIRating < 0.5 ) )
		{
			GL( GiveWayLabel );
			return;
		}
		else
		{
			bOtherHas = ( Other.FindInventoryType( Pickup( MoveTarget ).InventoryType ) != None );
			if( bHaveItem && !bOtherHas )
			{
				GL( GiveWayLabel );
				return;
			}
		}
	}

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

	function bool ShouldRecamp()
	{
		return ( ((Orders != OrdersFollow) || 
				  ((Controller(OrdersObject).Pawn != None) && 
				   IsCloseToDynamicGoal( Controller(OrdersObject).Pawn ))) && 
				 (Pawn.Weapon != None) && 
				 (Pawn.Weapon.AIRating > 0.4) && 
				 (FRand() > GetSkill() + 0.125) );
	}

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

	function ModifyPickupMoveTarget()
	{
		#debug DMAIM( "MoveTarget is Pickup: " $ MoveTarget );
	
		if( Orders == OrdersFollow )
		{
			ShareWith( Controller( OrdersObject ).Pawn );
		}
		//
		//mdf-tbd: 
		//
		//Could be made more general -- is there any teammate [in the area] that 
		//needs this pickup more than the NPC?
		//
		//The old code only worked if the NPC had point and had a SupportingPlayer
		//but, really, there is no reason to check for sharing with any teammate.
		//
		//This would also potentially eliminate the above call to sharewith.
		//else if( bHasPoint )
		//{
		//	// ShareWith( SupportingPlayer.Pawn );
		//}
		//
	}

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

	function MaybeHandleSpecialDestination()
	{
		if( Pickup(MoveTarget) != None )
		{
			ModifyPickupMoveTarget();
		}
	}

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

	event BeginState()
	{
		Super.BeginState();
		bNoShootDecor = false;
	}
} // RoamingState

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

// ==> WAS BASIC
// mdf-tbr: if not needed (do basic NPCs need any roaming behavior?)

state @ RoamingState
{
	ignores EnemyNotVisible;

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

	event BeginState()
	{
		// mdf-tbd: any need for roaming by basic NPCs?
		// mdf-tbd: if not, move roaming into U2NPCAdvanced?
		GS( WanderingState ); //GS-tbd
		DMAssert( false, "basic NPC in Roaming" );
	}
} // RoamingState

// ==> WAS BASE

//-----------------------------------------------------------------------------
// Move to a specific destination in the level, e.g. to pick up inventory or to
// carry out orders. NPC will not be in this state if there is an enemy.

// mdf-tbd: there's a strong case to be made for moving this into the Advanced
// Controller as almost all of the behavior in here implies advanced 
// intelligence.

state @ RoamingState
{
	ignores EnemyNotVisible;

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

	function FearThisSpot( Actor aSpot )
	{
		Destination = Pawn.Location + 120 * Normal( Pawn.Location - aSpot.Location ); 
		GS( WanderingState, MoveActiveLabel ); //GS-tbd
	}

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

	function bool SetOrders( optional name NewOrders, optional Actor NewOrdersObject, optional float NewOrdersThreshold, optional Object NewOrderGiver, optional bool bAcknowledge );
	{
		local bool bResult;

		#debug DMAI( "SetOrders " $ GetContext() );
		bResult = Global.SetOrders( NewOrders, OrderGiver, NewOrdersObject, bAcknowledge );
		if( bCamping && (Orders == OrdersHold || Orders == OrdersFollow) )
			GL( PreBeginLabel );
		return bResult;
	}

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

	event MayFall()
	{
		Pawn.bCanJump = TestCanJump();
	}
	
	//-------------------------------------------------------------------------
	// Return true to indicate special attraction destination set.

	function bool PickSpecialDestination()
	{
		return false;
	}

	//-------------------------------------------------------------------------
	// Return true to indicate that orders related destination set.

	function bool PickOrdersDestination()
	{
		local bool bTriedToPickFar;		// flag whether we tried for far (600 unit?) local inventory so we don't do it a 2nd time later
		local bool bNearPoint;
		local Pawn Leader;
		local bool bReadyForOrders;

		#debug DMAIM( "PickOrdersDestination #1  Orders: " $ Orders );

		//DMTNS( "PickOrdersDestination #1  Orders: " $ Orders );
		bReadyForOrders = ReadyForOrders();

		if( bStationary )
		{
			#debug DMAIM( "PickOrdersDestination -- NPC is stationary -- going to HoldState" );
			GS( DefaultImmobileState ); //GS-tbd
			return true;
		}

		if( Orders == OrdersFollow )
		{
			#debug DMAIM( "PickOrdersDestination #2 -- OrdersFollow" );
			if( Controller(OrdersObject) == None )
			{
				#debug DMAI( "SetOrders " $ GetContext() );
				SetOrders( OrdersNone );
			}
			else
			{
				Leader = Controller(OrdersObject).Pawn;
				if( Leader != None )
				{
					bNearPoint = IsCloseToDynamicGoal( Leader );
					if( !bNearPoint )
					{
						if( !bReadyForOrders )
						{
							// not ready -- pick inventory if possible
							bTriedToPickFar = true;
							//!!! advanced+ only
							if( PickLocalInventoryDestination( 600, 0.0 ) )
								return true;

							if( PlayerController(OrdersObject) != None )
							{
								if( FindBestInventoryPath( MoveTarget, 0.0, (GetSkill() >= 0.75) ) > 0.0 )
									return true;
							}
						}

						GetPathToActor( Leader, MoveTarget, true );

						if( AtDestinationActor( MoveTarget ) )
							return true;

						if( VSize( Leader.Location - Pawn.Location ) < 1600 && LineOfSightTo( Leader ) )
							bNearPoint = true;
						#debug DMAIM( " found no Path to " $ Leader );
					}
					else 
						SendMessageNearPoint( Leader, 10.0 );
				}
			}
		}

		#debug DMAIM( "PickOrdersDestination #3" );

		if( Orders == OrdersDefend && bReadyForOrders )
		{
			#debug DMAIM( "PickOrdersDestination #4 -- OrdersDefend" );

			//!!! advanced+ only
			if( PickLocalInventoryDestination( 300, 0.55 ) )
				return true;


			if( AmbushFindSpot() ) 
				return true;
			if( !LineOfSightTo( OrdersObject ) )
			{
				GetPathToActor( OrdersObject, MoveTarget, true );
				if( MoveTarget != None )
					return true;
			}
			else
				SendMessageInPosition( 10.0 );
		}

		#debug DMAIM( "PickOrdersDestination #5" );

		if( Orders == OrdersHold && bReadyForOrders && !LineOfSightTo( OrdersObject ) )
		{
			#debug DMAIM( "PickOrdersDestination #6" );
			#debug DMAI( "No LOS to OrdersObject -- going to HoldState" );
			GS( HoldState ); //GS-tbd
			return true;
		}

		#debug DMAIM( "PickOrdersDestination #7" );
		//!!! advanced+ only
		if( !bTriedToPickFar && PickLocalInventoryDestination( 600, 0.0 ) )
			return true;

		#debug DMAIM( "PickOrdersDestination #8" );
		if( Orders == OrdersHold && bReadyForOrders )
		{
			#debug DMAIM( "PickOrdersDestination #9" );
			if( VSize( Pawn.Location - OrdersObject.Location ) < 20 )
			{
				#debug DMAI( "going to HoldingState" );
				GS( HoldingState ); //GS-tbd
			}
			else
				GS( HoldState ); //GS-tbd
			return true;
		}

		#debug DMAIM( "PickOrdersDestination #10" );
		if( (Orders == OrdersFollow && bNearPoint) || 
			(Orders == OrdersDefend && bReadyForOrders && LineOfSightTo( OrdersObject )) )
		{
			#debug DMAIM( "PickOrdersDestination #11" );
			if( FRand() < 0.35 )
				GS( WanderingState ); //GS-tbd
			else
			{
				CampTime = 0.8;
				GL( CampLabel );
			}
			return true;
		}

		#debug DMAIM( "PickOrdersDestination #12 -- return false" );
		return false;
	}

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

	function bool HandleDecorationStuff()
	{
		local Decoration TargetDecocation;

		// if none found, check for decorations with inventory
		if( !bNoShootDecor )
		{
			//!!mdf-tbd: VCA seems to be really slow -- should it be avoided/fixed?
			foreach VisibleCollidingActors( class'Decoration', TargetDecocation, 500, Pawn.Location, true )
			{
				if( TargetDecocation.Contents != None )
				{
					bNoShootDecor = true;
					#debug   SetControllerTarget( TargetDecocation, GetContext() );
					#release SetControllerTarget( TargetDecocation );
					GL( ShootDecorationLabel );
					return true;
				}
			}
		}

		return false;
	}

	//-------------------------------------------------------------------------
	// Decide whether to hunt player. This isn't the same as going into the 
	// hunting state -- this function is used in the Roaming state to send the
	// NPC to the location of one of the players in the level and only really
	// applies to freelancing bots in dm. The hunting state on the other hand
	// is used to try to locate a current enemy which is no longer visible.

	function bool PickHuntDestination()
	{
		return false;
	}

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

	function bool PickFarInventoryDestination()
	{
		return false;
	}

	//-------------------------------------------------------------------------
	// mdf-tbd: this was a complete mess -- its a bit better now but still 
	// needs work.

	function PickDestination()
	{
		#debug DMAIM( "PickDestination #1 Orders: " $ Orders );

		// check for a special destination
		if( PickSpecialDestination() )
			return;

		#debug DMAIM( "PickDestination #2" );
		// check for destination due to orders
		if( PickOrdersDestination() )
			return;

		if( OrdersObject != None && AmbushPoint(OrdersObject) == None )
			bWantsToCamp = false;
		else if( Pawn.Weapon != None && Pawn.Weapon.AIRating > 0.5 && Pawn.Health > 90 && !Pawn.PhysicsVolume.bWaterVolume )
		{
			bWantsToCamp = (bWantsToCamp || (FRand() < U2PBasic.CampingRate * FMin( 1.0, Level.TimeSeconds - LastCampCheck )));
			LastCampCheck = Level.TimeSeconds;
		}
		else 
			bWantsToCamp = false;

		if( bWantsToCamp && AmbushFindSpot() )
			return;

		#debug DMAIM( "PickDestination #3" );

		// shoot decoration to get stuff?
		if( HandleDecorationStuff() )
			return;

		if( PickFarInventoryDestination() )
			return;

		// nothing around - maybe just wait a little
		if( ( FRand() < 0.35 ) && ( GetSkill() < 0.50 ) 
			&& ( Level.Game.NumPlayers + Level.Game.NumBots > 2 )  )
		{
			CampTime = 3.5 + FRand() - 8*GetSkill();
			GL( CampLabel );
		}

		// if roamed to ambush point, stay there maybe
		if( (AmbushPoint( RoamTarget ) != None) && 
			(VSize( Pawn.Location - RoamTarget.Location ) < 2*Pawn.CollisionRadius) && 
			(FRand() < 0.4) )
		{
			CampTime = 4.0;
			GL( CampLongLabel );
			return;
		}

		// maybe pick a player to hunt?
		if( PickHuntDestination() )
			return;
    	
		// look for ambush spot if didn't already try
		if( !bWantsToCamp && AmbushFindSpot() )
		{
			RoamTarget = AmbushSpot;
			return;
		}
		
		#debug DMAIM( "PickDestination #5 RoamTarget=" $ RoamTarget );

		// find a roamtarget
		if( RoamTarget == None )
			RoamTarget = SelectInventorySpotDestination();
			
		if( RoamTarget != None  )
		{
			// roam around
			if( RoamTarget != None )
			{
				#debug DMAIM( "PickDestination #7 -- calling FindPathToActor " $ RoamTarget );
				GetPathToActor( RoamTarget, MoveTarget , true );
				#debug DMAIM( "PickDestination #7 -- done Path= " $ MoveTarget );
				if( MoveTarget != None )
					return;
				else
					RoamTarget = None;
			}
		}
													
		// wander or camp
		if( FRand() < 0.35 )
		{
			#debug DMAIM( "PickDestination #8" );
			GS( WanderingState ); //GS-tbd
		}
		else
		{
			CampTime = 3.5 + FRand() - 3.5 * GetSkill();
			GL( CampLabel );
		}

		#debug DMAIM( "PickDestination End: " $ MoveTarget );
	}

	//-------------------------------------------------------------------------
	// mdf-tbd - use a timer (was going of of end of animation)
	//
	//function SomeTimer() 
	//{
 	//	if( bCamping )
 	//		SetPeripheralVision();
	//}
	//

	//-------------------------------------------------------------------------
	
	function bool ShouldRecamp()
	{
		return false;
	}

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

	function ModifyMoveTarget();
						 
	//-------------------------------------------------------------------------

	event BeginState()
	{
		bCamping = false;
	}

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

	event EndState()
	{
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
		SetPeripheralVision();
		if( !bSniping && ( AmbushSpot != None ) )
		{
			AmbushSpot.Taken = false;
			AmbushSpot = None;
		}
		bCamping = false;
	}

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

@ CampLongLabel:
	bCamping = true;
	StopMovement( true, false );
	Focus = None;
	FocalPoint = Pawn.Location + Ambushspot.lookdir;
	Sleep( CampTime );
	Goto( PreBeginLabel );

@ GiveWayLabel:
	//log( "sharing" );	
	bCamping = true;
	StopMovement( true, false );
	if( ViewObstructed( 200 ) )
		FinishRotation( DefaultRotationThreshold );
	Sleep( CampTime );
	Goto( PreBeginLabel );

@ CampLabel:
#debug DMAIL( CampLabel );

	bCamping = true;
	StopMovement( true, false );

@ CampAgainLabel:
	if( ViewObstructed( 200 ) )
		FinishRotation( DefaultRotationThreshold );
#debug DMAI( "Sleeping for CampTime=" $ CampTime );
	Sleep( CampTime );
#debug DMAI( "Done sleeping" );

	if( bLeading || bCampOnlyOnce )
	{
#debug DMAI( "goto PreBegin" );
		bCampOnlyOnce = false;
		Goto( PreBeginLabel );
	}
#debug DMAI( "checking recamp" );
	if( ShouldReCamp() )
	{
#debug DMAI( "camp again" );
		Goto( CampAgainLabel );
	}
#debug DMAI( "done checking recamp" );

@ PreBeginLabel:
	SetPeripheralVision();
	bCamping = false;
	
@ BeginLabel:
@ MovePickDestLabel:
	WaitForLanding();
	PickDestination();
	ModifyMoveTarget();

@ MoveSpecialLabel:
@ MoveActiveLabel:
	#debug DMAIM( "MoveTarget: " $ MoveTarget );

	if( MoveTarget == None )
	{
		#debug DMAIM( "MoveTarget is None" );
		StopMovement( true, false );
		Sleep( 0.0 );
		Goto( MovePickDestLabel );
	}

	bCamping = false;
	#debug DMAIM( "Calling MoveToActor: " $ MoveTarget );
	MoveToActor( MoveTarget, TMT_None );
	Goto( MovePickDestLabel );

@ ShootDecorationLabel:
	Focus = ControllerTarget;
	FinishRotation( DefaultRotationThreshold );
	if( ControllerTarget != None )
	{
		ShootAt( ControllerTarget );
		#debug   StopFiring( 0.5, SFI_Behavior, GetContext() );
		#release StopFiring( 0.5, SFI_Behavior );
		#debug SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
	}
	Goto( MovePickDestLabel );
} // RoamingState
*/

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

state @ VictoryDanceState extends @ EnemyKilledState
{
	ignores EnemyNotVisible; 

	function PlayRandomSound();

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

	event EndState()
	{
		#debug   SetControllerTarget( None, GetContext() );
		#release SetControllerTarget( None );
	}

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

@ BeginLabel:
	StopMovement( true, false );
	Focus = ControllerTarget;
	FinishRotation( DefaultRotationThreshold );
	Focus = None;
	FocalPoint.Z = Pawn.Location.Z;
	U2P.AnimationController.SpecialAnimationVictoryDance();
	FinishAnim();
	#debug   UpdateBehavior( false, GetContext() );
	#release UpdateBehavior( false );
} // VictoryDanceState

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

state @ WanderingState
{
	ignores EnemyNotVisible;

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

	function WanderPauseSpecialHandling()
	{
		if( Level.Game.bTeamGame && (bLeading || (Orders == OrdersFollow && !IsCloseToDynamicGoal( Controller(OrdersObject).Pawn ))) )
			GotoState( RoamingState ); //GS-tbd
	}

	//-------------------------------------------------------------------------
	
	function WanderDidMoveSpecialHandling()
	{
		GotoState( RoamingState ); //GS-tbd
	}
} // WanderingState

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

defaultproperties
{
	VictoryDanceOdds=0.250000
	DefaultState='Roaming'
	bIsPlayer=true
	bIsBot=true
	bShouldPossess=false
	PlayerReplicationInfoClass=Class'U2.U2BotReplicationInfo'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}