U2AIOld.U2NPCControllerBotOld

//=============================================================================
// U2NPCControllerBotOld.uc
// Created By: Steve Polge, Mike Fox
// Created On: 2/14/00
// $Author: Mfox $
// $Date: 2/21/03 3:20p $
// $Revision: 19 $
//=============================================================================

class U2NPCControllerBotOld extends U2NPCControllerAdvancedOld;

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

// mdf-tbd -- not used in UW?
//var float PointDied;

var U2BotReplicationInfo BRI; // helper

var name OldMessageType;
var int OldMessageID;
var float VictoryDanceOdds;

//mdf-tbd:
var float LastAttractCheck;

//-----------------------------------------------------------------------------
//@ 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 );
		GotoState( AttackingState );
	}
}

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

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 Threshold;

	if( ControllerEnemy == None )
		Threshold = 0.3;
	else
		Threshold = 0.7;
	if( FRand() < Threshold )
		return;

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

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

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

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

function AmbushClearOtherSpots()
{
	if( Level.Game.bTeamGame )
		Super.AmbushClearOtherSpots();
}

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

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( 0 ) );
	SetOrders( BRI.RealOrders, BRI.RealOrdersObject, 0.0, BRI.RealOrderGiver );
	Super.Restart();
}

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

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

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

event PostBeginPlay()
{
	Super.PostBeginPlay();

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

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

function bool CanRespawn()
{
	return true;
}

//-----------------------------------------------------------------------------
// Moved here from U2NPCControllerBaseOld

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 U2NPCControllerBaseOld (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 && 
			 (FRand() < BaseOdds - (0.15 * (Level.Game.NumBots+Level.Game.NumPlayers))) );
}

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

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 ( IsMobile() && (Pawn.Weapon == None || !Pawn.Weapon.bRecommendSplashDamage) && (U2PBasic.bJumpy || (FRand()*GetSkill() > U2PBasic.JumpyOdds)) );

}

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

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;
}

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

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'UtilGame'.static.GetInventoryCount( Pawn, Class'Weapon' )  $ " RO: " $ 0.333*Level.Game.GetLevelRatingOffensive() );
	//DM( "InventoryReadyForAction PUC: " $ class'UtilGame'.static.GetInventoryCount( Pawn, Class'Armor' ) $ " RD: " $ 0.333*Level.Game.GetLevelRatingDefensive());

	return bRetVal;
}

//-----------------------------------------------------------------------------
// mdf-tbd: should depend somewhat on inventory in level.

function bool ReadyForAction()
{
	local bool bRetVal;

	bRetVal = ( Super.ReadyForAction() && 
				Pawn.Health > 70 &&
				(U2Pawn(Pawn).GetPowerSuitMax() == -1.0 || U2Pawn(Pawn).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() );
}

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

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( 0 ) );
	SetOrders( BRI.RealOrders, BRI.RealOrdersObject, 0.0, BRI.RealOrderGiver );
}

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

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

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

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

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

// mdf-tbd: could be useful in advanced?
function HandleOrdersAttack()
{
	local Controller C;
	local U2NPCControllerBotOld B;

	Super.HandleOrdersAttack();

	// 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 = U2NPCControllerBotOld( C );

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

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

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

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

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

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

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

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

function bool FindSpecialAttraction()
{
	local Actor SpecialAttractionActor;

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

	if( IsMobile() && SpecialGoal != None )
	{
		// build a path to it
		FindPathToActor( SpecialGoal, SpecialAttractionActor );

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

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

	return ( SpecialAttractionActor != None );
}

//-----------------------------------------------------------------------------
//@ UW BOT CODE 
//-----------------------------------------------------------------------------

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

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

function bool ShouldDestroyNPC()
{
	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 HandleEnemyKilledSafe( Controller Killer, Pawn KilledEnemy )
{
	if( Killer == Self )
	{
		// I was the killer
		if( FRand() < VictoryDanceOdds && Orders != OrdersAttack )
		{
			#debug   SetControllerTarget( KilledEnemy, GetContext() );
			#release SetControllerTarget( KilledEnemy );
			GotoState( VictoryDanceState );
		}
		else
		{
			GotoState( AttackingState ); 
		}
	}
	else
	{
		// mdf-tbd: bots who has KilledEnemy as an enemy could sometimes say "hey, that one was mine" etc.)
		// or, in team games, "nice kill" etc.
		GotoState( AttackingState ); 
	}
}

//-----------------------------------------------------------------------------
// mdf-tbd: clean up this crap -- just override NotifyKilled.

function GameRelatedKilled( Controller Killer, Controller Killed, Pawn KilledPawn, class<DamageType> DamageType )
{
	if( 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!!!
		}
	}
}

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

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 );
		}
	}
}

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

state @ AttackRetreatState
{
	ignores EnemyNotVisible;

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

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

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

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

	//-------------------------------------------------------------------------
	// 2003.02.21 (mdf) fix from Jason Yu for bots sometimes not respawning in 
	// botmatch.
	
	#debug   function WhatToDoNext( string ContextStr );
	#release function WhatToDoNext();
	
	//-------------------------------------------------------------------------

	event BeginState()
	{
		//mdf-tbd: is this check even needed (can we get here without going through same check in WhatToDoNext?
		if( !ShouldDestroyNPC() )
		{
			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 )
		GotoState( GameEndedState );
	Sleep(0.2);

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

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

@ WaitingForStartLabel:
}

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

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( 0 ) );
				SetOrders( BRI.RealOrders, BRI.RealOrdersObject, 0.0, BRI.RealOrderGiver );
			}
			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 )
	{
		FindPathToActor( TargetActor, MoveTarget );
		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;
				GotoLabel( CampLabel );
			}
		}
	}

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

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

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

defaultproperties
{
	VictoryDanceOdds=0.250000
	RateCurrentWeaponChecks=0.500000
	RateBestWeaponChecks=1.000000
	RateBestWeaponChecksEnemy=0.500000
	MaxAffectedByHitTime=0.250000
	MaxAffectedByAcquisitionTime=0.500000
	TryToHitInstantBaseOddsMin=0.250000
	TryToHitInstantBaseOddsMax=1.000000
	TryToHitProjectileBaseOddsMin=0.500000
	TryToHitTossedBaseOddsMin=0.500000
	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"
}