//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "cbase.h"

#include "ai_behavior_police.h"
#include "ai_navigator.h"
#include "ai_memory.h"

#include "npc_metropolice.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

BEGIN_DATADESC( CAI_PolicingBehavior )

	DEFINE_FIELD( m_bEnabled,			FIELD_BOOLEAN ),
	DEFINE_FIELD( m_bStartPolicing,		FIELD_BOOLEAN ),
	DEFINE_FIELD( m_hPoliceGoal,		FIELD_EHANDLE ),
	DEFINE_FIELD( m_flNextHarassTime,	FIELD_TIME ),
	DEFINE_FIELD( m_flAggressiveTime,	FIELD_TIME ),
	DEFINE_FIELD( m_nNumWarnings,		FIELD_INTEGER ),
	DEFINE_FIELD( m_bTargetIsHostile,	FIELD_BOOLEAN ),
	DEFINE_FIELD( m_flTargetHostileTime,FIELD_TIME ),

END_DATADESC();

CAI_PolicingBehavior::CAI_PolicingBehavior( void )
{
	m_bEnabled = false;
	m_nNumWarnings = 0;
	m_bTargetIsHostile = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PolicingBehavior::TargetIsHostile( void )
{
	if ( ( m_flTargetHostileTime < gpGlobals->curtime ) && ( !m_bTargetIsHostile ) )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pGoal - 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::Enable( CAI_PoliceGoal *pGoal )
{
	m_hPoliceGoal = pGoal;
	m_bEnabled = true;

	m_bStartPolicing = true;

	// Update ourselves immediately
	GetOuter()->ClearSchedule();
	//NotifyChangeBehaviorStatus( GetOuter()->IsInAScript() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::Disable( void )
{
	m_hPoliceGoal = NULL;
	m_bEnabled = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PolicingBehavior::CanSelectSchedule( void )
{
	// Must be activated and valid
	if ( IsEnabled() == false || !m_hPoliceGoal || !m_hPoliceGoal->GetTarget() )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : false - 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::HostSetBatonState( bool state )
{
	// If we're a cop, turn the baton on
	CNPC_MetroPolice *pCop = dynamic_cast<CNPC_MetroPolice *>(GetOuter());

	if ( pCop != NULL )
	{
		pCop->SetBatonState( state );
		pCop->SetTarget( m_hPoliceGoal->GetTarget() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : false - 
//-----------------------------------------------------------------------------
bool CAI_PolicingBehavior::HostBatonIsOn( void )
{
	// If we're a cop, turn the baton on
	CNPC_MetroPolice *pCop = dynamic_cast<CNPC_MetroPolice *>(GetOuter());
	if ( pCop )
		return pCop->BatonActive();

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::HostSpeakSentence( const char *pSentence, SentencePriority_t nSoundPriority, SentenceCriteria_t nCriteria )
{
	// If we're a cop, turn the baton on
	CNPC_MetroPolice *pCop = dynamic_cast<CNPC_MetroPolice *>(GetOuter());

	if ( pCop != NULL )
	{
		CAI_Sentence< CNPC_MetroPolice > *pSentences = pCop->GetSentences();

		pSentences->Speak( pSentence, nSoundPriority, nCriteria );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::BuildScheduleTestBits( void )
{
	if ( IsCurSchedule( SCHED_IDLE_STAND ) || IsCurSchedule( SCHED_ALERT_STAND ) )
	{
		if ( m_flNextHarassTime < gpGlobals->curtime )
		{
			GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_POLICE_TARGET_TOO_CLOSE_HARASS ) );
		}

		GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::GatherConditions( void )
{
	BaseClass::GatherConditions();

	// Mapmaker may have removed our goal while we're running our schedule
	if ( !m_hPoliceGoal )
	{
		Disable();
		return;
	}

	ClearCondition( COND_POLICE_TARGET_TOO_CLOSE_HARASS );
	ClearCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );

	CBaseEntity *pTarget = m_hPoliceGoal->GetTarget();

	if ( pTarget == NULL )
	{
		DevMsg( "ai_goal_police with NULL target entity!\n" );
		return;
	}

	// See if we need to knock out our target immediately
	if ( ShouldKnockOutTarget( pTarget ) )
	{
		SetCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );
	}

	float flDistSqr = ( m_hPoliceGoal->WorldSpaceCenter() - pTarget->WorldSpaceCenter() ).Length2DSqr();
	float radius = ( m_hPoliceGoal->GetRadius() * PATROL_RADIUS_RATIO );
	float zDiff = fabs( m_hPoliceGoal->WorldSpaceCenter().z - pTarget->WorldSpaceCenter().z );

	// If we're too far away, don't bother
	if ( flDistSqr < (radius*radius) && zDiff < 32.0f )
	{
		SetCondition( COND_POLICE_TARGET_TOO_CLOSE_HARASS );

		if ( flDistSqr < (m_hPoliceGoal->GetRadius()*m_hPoliceGoal->GetRadius()) )
		{
			SetCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );
		}
	}

	// If we're supposed to stop chasing (aggression over), return
	if ( m_bTargetIsHostile && m_flAggressiveTime < gpGlobals->curtime && IsCurSchedule(SCHED_CHASE_ENEMY) )
	{
		// Force me to re-evaluate my schedule
		GetOuter()->ClearSchedule();
	}
}

//-----------------------------------------------------------------------------
// We're taking cover from danger
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::AnnouncePolicing( void )
{
	// We're policing
	static const char *pWarnings[3] = 
	{
		"METROPOLICE_MOVE_ALONG_A",
		"METROPOLICE_MOVE_ALONG_B",
		"METROPOLICE_MOVE_ALONG_C",
	};

	if ( m_nNumWarnings <= 3 )
	{
		HostSpeakSentence( pWarnings[ m_nNumWarnings - 1 ], SENTENCE_PRIORITY_MEDIUM, SENTENCE_CRITERIA_NORMAL );
	}
	else 
	{
		// We loop at m_nNumWarnings == 4 for players who aren't moving 
		// but still pissing us off, and we're not allowed to do anything about it. (i.e. can't leave post)
		// First two sentences sound pretty good, so randomly pick one of them.
		int iSentence = RandomInt( 0, 1 );
		HostSpeakSentence( pWarnings[ iSentence ], SENTENCE_PRIORITY_MEDIUM, SENTENCE_CRITERIA_NORMAL );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : scheduleType - 
// Output : int
//-----------------------------------------------------------------------------
int CAI_PolicingBehavior::TranslateSchedule( int scheduleType )
{
	if ( scheduleType == SCHED_CHASE_ENEMY )
	{
		if ( m_hPoliceGoal->ShouldRemainAtPost() && !MaintainGoalPosition() )
			return BaseClass::TranslateSchedule( SCHED_COMBAT_FACE );
	}

	return BaseClass::TranslateSchedule( scheduleType );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : newActivity - 
// Output : Activity
//-----------------------------------------------------------------------------
Activity CAI_PolicingBehavior::NPC_TranslateActivity( Activity newActivity )
{
	// See which harassment to play
	if ( newActivity == ACT_POLICE_HARASS1 )
	{
		switch( m_nNumWarnings )
		{
		case 1:
			return (Activity) ACT_POLICE_HARASS1;
			break;

		default:
		case 2:
			return (Activity) ACT_POLICE_HARASS2;
			break;
		}
	}

	return BaseClass::NPC_TranslateActivity( newActivity );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : CBaseEntity
//-----------------------------------------------------------------------------
CBaseEntity *CAI_PolicingBehavior::GetGoalTarget( void )
{
	if ( m_hPoliceGoal == NULL )
	{
		//NOTENOTE: This has been called before the behavior is actually active, or the goal has gone invalid
		Assert(0);
		return NULL;
	}

	return m_hPoliceGoal->GetTarget();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : time - 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::SetTargetHostileDuration( float time )
{
	m_flTargetHostileTime = gpGlobals->curtime + time;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pTask - 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::StartTask( const Task_t *pTask )
{
	switch (pTask->iTask)
	{
	case TASK_POLICE_GET_PATH_TO_HARASS_GOAL:
		{
			Vector	harassDir = ( m_hPoliceGoal->GetTarget()->WorldSpaceCenter() - WorldSpaceCenter() );
			float	flDist = VectorNormalize( harassDir );

			// See if we're already close enough
			if ( flDist < pTask->flTaskData )
			{
				TaskComplete();
				break;
			}

			float	flInter1, flInter2;
			Vector	harassPos = GetAbsOrigin() + ( harassDir * ( flDist - pTask->flTaskData ) );

			// Find a point on our policing radius to stand on
			if ( LineSphereIntersection( m_hPoliceGoal->GetAbsOrigin(), m_hPoliceGoal->GetRadius(), GetAbsOrigin(), harassDir, &flInter1, &flInter2 ) )
			{
				Vector vPos = m_hPoliceGoal->GetAbsOrigin() + harassDir * ( max( flInter1, flInter2 ) );

				// See how far away the default one is
				float testDist = UTIL_DistApprox2D( m_hPoliceGoal->GetAbsOrigin(), harassPos );
				
				// If our other goal is closer, choose it
				if ( testDist > UTIL_DistApprox2D( m_hPoliceGoal->GetAbsOrigin(), vPos ) )
				{
					harassPos = vPos;
				}
			}

			if ( GetNavigator()->SetGoal( harassPos, pTask->flTaskData ) )
			{
				GetNavigator()->SetMovementActivity( (Activity) ACT_WALK_ANGRY );
				GetNavigator()->SetArrivalDirection( m_hPoliceGoal->GetTarget() );
				TaskComplete();
			}
			else
			{
				TaskFail( FAIL_NO_ROUTE );
			}
		}
		break;
	
	case TASK_POLICE_GET_PATH_TO_POLICE_GOAL:
		{
			if ( GetNavigator()->SetGoal( m_hPoliceGoal->GetAbsOrigin(), pTask->flTaskData ) )
			{
				GetNavigator()->SetArrivalDirection( m_hPoliceGoal->GetAbsAngles() );
				TaskComplete();
			}
			else
			{
				TaskFail( FAIL_NO_ROUTE );
			}
		}
		break;

	case TASK_POLICE_ANNOUNCE_HARASS:
		{
			AnnouncePolicing();

			// Randomly say this again in the future
			m_flNextHarassTime = gpGlobals->curtime + random->RandomInt( 4, 6 );

			// Scatter rubber-neckers
			CSoundEnt::InsertSound( SOUND_MOVE_AWAY, GetAbsOrigin(), 256.0f, 2.0f, GetOuter() );
		}
		TaskComplete();
		break;

	case TASK_POLICE_FACE_ALONG_GOAL:
		{
			// We may have lost our police goal in the 2 seconds we wait before this task
			if ( m_hPoliceGoal )
			{
				GetMotor()->SetIdealYaw( m_hPoliceGoal->GetAbsAngles().y );
				GetOuter()->SetTurnActivity(); 
			}
		}
		break;

	default:
		BaseClass::StartTask( pTask );
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::RunTask( const Task_t *pTask )		
{ 
	switch ( pTask->iTask )
	{
	case TASK_POLICE_FACE_ALONG_GOAL:
		{
   			GetMotor()->UpdateYaw();
   
   			if ( GetOuter()->FacingIdeal() )
   			{
   				TaskComplete();
   			}
   			break;
		}

	default:
		BaseClass::RunTask( pTask);
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PolicingBehavior::MaintainGoalPosition( void )
{
	Vector vecOrg = GetAbsOrigin();
	Vector vecTarget = m_hPoliceGoal->GetAbsOrigin();

	// Allow some slop on Z
	if ( fabs(vecOrg.z - vecTarget.z) > 64 )
		return true;

	// Need to be very close on X/Y
	if ( (vecOrg - vecTarget).Length2D() > 16 )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_PolicingBehavior::ShouldKnockOutTarget( CBaseEntity *pTarget )
{
	if ( m_hPoliceGoal == NULL )
	{
		//NOTENOTE: This has been called before the behavior is actually active, or the goal has gone invalid
		Assert(0);
		return false;
	}

	bool bVisible = GetOuter()->FVisible( pTarget );
	return m_hPoliceGoal->ShouldKnockOutTarget( pTarget->WorldSpaceCenter(), bVisible );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pTarget - 
//-----------------------------------------------------------------------------
void CAI_PolicingBehavior::KnockOutTarget( CBaseEntity *pTarget )
{
	if ( m_hPoliceGoal == NULL )
	{
		//NOTENOTE: This has been called before the behavior is actually active, or the goal has gone invalid
		Assert(0);
		return;
	}

	m_hPoliceGoal->KnockOutTarget( pTarget );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int CAI_PolicingBehavior::SelectSuppressSchedule( void )
{
	CBaseEntity *pTarget = m_hPoliceGoal->GetTarget();

	m_flAggressiveTime = gpGlobals->curtime + 4.0f;

	if ( m_bTargetIsHostile == false )
	{
		// Mark this as a valid target
		m_bTargetIsHostile = true;
		
		// Attack the target
		GetOuter()->SetEnemy( pTarget );
		GetOuter()->SetState( NPC_STATE_COMBAT );
		GetOuter()->UpdateEnemyMemory( pTarget, pTarget->GetAbsOrigin() );

		HostSetBatonState( true );
		
		// Remember that we're angry with the target
		m_nNumWarnings = POLICE_MAX_WARNINGS;

		// We need to let the system pickup the new enemy and deal with it on the next frame
		return SCHED_COMBAT_FACE;
	}

	// If we're supposed to stand still, then we need to show aggression
	if ( m_hPoliceGoal->ShouldRemainAtPost() )
	{
		// If we're off our mark, fight to it
		if ( MaintainGoalPosition() )
		{
			return SCHED_CHASE_ENEMY;
		}

		//FIXME: This needs to be a more aggressive warning to the player
		if ( m_flNextHarassTime < gpGlobals->curtime )
		{
			return SCHED_POLICE_WARN_TARGET;
		}
		else
		{
			return SCHED_COMBAT_FACE;
		}
	}

	return SCHED_CHASE_ENEMY;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int CAI_PolicingBehavior::SelectHarassSchedule( void )
{
	CBaseEntity *pTarget = m_hPoliceGoal->GetTarget();

	m_flAggressiveTime = gpGlobals->curtime + 4.0f;

	// If we just started to police, make sure we're on our mark
	if ( MaintainGoalPosition() )
		return SCHED_POLICE_RETURN_FROM_HARASS;
	
	// Look at the target if they're too close
	GetOuter()->AddLookTarget( pTarget, 0.5f, 5.0f );

	// Say something if it's been long enough
	if ( m_flNextHarassTime < gpGlobals->curtime )
	{
		// Gesture the player away
		GetOuter()->SetTarget( pTarget );
		
		// Send outputs for each level of warning
		if ( m_nNumWarnings == 0 )
		{
			m_hPoliceGoal->FireWarningLevelOutput( 1 );
		}
		else if ( m_nNumWarnings == 1 )
		{
			m_hPoliceGoal->FireWarningLevelOutput( 2 );
		}

		if ( m_nNumWarnings < POLICE_MAX_WARNINGS )
		{
			m_nNumWarnings++;
		}

		// If we're over our limit, just suppress the offender
		if ( m_nNumWarnings >= POLICE_MAX_WARNINGS )
		{
			if ( m_bTargetIsHostile == false )
			{
				// Mark the target as a valid target
				m_bTargetIsHostile = true;

				GetOuter()->SetEnemy( pTarget );
				GetOuter()->SetState( NPC_STATE_COMBAT );
				GetOuter()->UpdateEnemyMemory( pTarget, pTarget->GetAbsOrigin() );
				HostSetBatonState( true );
				
				m_hPoliceGoal->FireWarningLevelOutput( 4 );

				return SCHED_COMBAT_FACE;
			}

			if ( m_hPoliceGoal->ShouldRemainAtPost() == false )
				return SCHED_CHASE_ENEMY;
		}
			
		// On our last warning, approach the target
		if ( m_nNumWarnings == (POLICE_MAX_WARNINGS-1) )
		{
			m_hPoliceGoal->FireWarningLevelOutput( 3 );

			GetOuter()->SetTarget( pTarget );
			
			HostSetBatonState( true );

			if ( m_hPoliceGoal->ShouldRemainAtPost() == false )
				return SCHED_POLICE_HARASS_TARGET;
		}

		// Otherwise just verbally warn him
		return SCHED_POLICE_WARN_TARGET;
	}

	return SCHED_NONE;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int CAI_PolicingBehavior::SelectSchedule( void )
{
	CBaseEntity *pTarget = m_hPoliceGoal->GetTarget();

	// Validate our target
	if ( pTarget == NULL )
	{
		DevMsg( "ai_goal_police with NULL target entity!\n" );
		
		// Turn us off
		Disable();
		return SCHED_NONE;
	}

	// Attack if we're supposed to
	if ( ( m_flAggressiveTime >= gpGlobals->curtime ) && HasCondition( COND_CAN_MELEE_ATTACK1 ) )
	{
		return SCHED_MELEE_ATTACK1;
	}

	// See if we should immediately begin to attack our target
	if ( HasCondition( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS ) )
	{
		return SelectSuppressSchedule();
	}
	
	int newSchedule = SCHED_NONE;

	// See if we're harassing
	if ( HasCondition( COND_POLICE_TARGET_TOO_CLOSE_HARASS ) )
	{
		newSchedule = SelectHarassSchedule();
	}

	// Return that schedule if it was found
	if ( newSchedule != SCHED_NONE )
		return newSchedule;

	// If our enemy is set, fogeda'bout it!
	if ( m_flAggressiveTime < gpGlobals->curtime )
	{
		// Return to your initial spot
		if ( GetEnemy() )
		{
			GetOuter()->SetEnemy( NULL );
			GetOuter()->SetState( NPC_STATE_ALERT );
			GetOuter()->GetEnemies()->RefreshMemories();
		}

		HostSetBatonState( false );
		m_bTargetIsHostile = false;
	}	

	// If we just started to police, make sure we're on our mark
	if ( MaintainGoalPosition() )
		return SCHED_POLICE_RETURN_FROM_HARASS;

	// If I've got my baton on, keep looking at the target
	if ( HostBatonIsOn() )
		return SCHED_POLICE_TRACK_TARGET;

	// Re-align myself to the goal angles if I've strayed
	if ( fabs(UTIL_AngleDiff( GetAbsAngles().y, m_hPoliceGoal->GetAbsAngles().y )) > 15 )
		return SCHED_POLICE_FACE_ALONG_GOAL;

	return SCHED_IDLE_STAND;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CAI_PolicingBehavior::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
{
	if ( failedSchedule == SCHED_CHASE_ENEMY )
	{
		// We've failed to chase our enemy, return to where we were came from
		if ( MaintainGoalPosition() )
			return SCHED_POLICE_RETURN_FROM_HARASS;

		return SCHED_POLICE_WARN_TARGET;
	}
	
	return BaseClass::SelectFailSchedule( failedSchedule, failedTask, taskFailCode );
}

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

AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER( CAI_PolicingBehavior )

	DECLARE_CONDITION( COND_POLICE_TARGET_TOO_CLOSE_HARASS );
	DECLARE_CONDITION( COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS );

	DECLARE_TASK( TASK_POLICE_GET_PATH_TO_HARASS_GOAL );
	DECLARE_TASK( TASK_POLICE_GET_PATH_TO_POLICE_GOAL );
	DECLARE_TASK( TASK_POLICE_ANNOUNCE_HARASS );
	DECLARE_TASK( TASK_POLICE_FACE_ALONG_GOAL );

	DEFINE_SCHEDULE
	(
		SCHED_POLICE_WARN_TARGET,

		"	Tasks"
		"		TASK_STOP_MOVING		0"
		"		TASK_FACE_TARGET					0"
		"		TASK_POLICE_ANNOUNCE_HARASS	0"
		"		TASK_PLAY_SEQUENCE					ACTIVITY:ACT_POLICE_HARASS1"
		""
		"	Interrupts"
		"		COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS"
	);

	DEFINE_SCHEDULE
	(
		SCHED_POLICE_HARASS_TARGET,

		"	Tasks"
		"		TASK_STOP_MOVING							0"
		"		TASK_FACE_TARGET							0"
		"		TASK_POLICE_GET_PATH_TO_HARASS_GOAL			64"
		"		TASK_WAIT_FOR_MOVEMENT						0"
		"		TASK_POLICE_ANNOUNCE_HARASS			0"
		"		TASK_PLAY_SEQUENCE							ACTIVITY:ACT_POLICE_HARASS1"
		""
		"	Interrupts"
		"		COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS"
	);

	DEFINE_SCHEDULE
	(
		SCHED_POLICE_SUPPRESS_TARGET,

		"	Tasks"
		"		TASK_STOP_MOVING					0"
		"		TASK_FACE_TARGET					0"
		"		TASK_POLICE_ANNOUNCE_HARASS	0"
		"		TASK_PLAY_SEQUENCE					ACTIVITY:ACT_POLICE_HARASS1"
		""
		"	Interrupts"
	);

	DEFINE_SCHEDULE
	(
		SCHED_POLICE_RETURN_FROM_HARASS,

		"	Tasks"
		"		TASK_STOP_MOVING							0"
		"		TASK_POLICE_GET_PATH_TO_POLICE_GOAL			16"
		"		TASK_WALK_PATH								0"
		"		TASK_WAIT_FOR_MOVEMENT						0"
		"		TASK_STOP_MOVING							0"
		""
		"	Interrupts"
		"		COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS"
	);

	DEFINE_SCHEDULE
	(
		SCHED_POLICE_TRACK_TARGET,

		"	Tasks"
		"		TASK_FACE_TARGET					0"
		""
		"	Interrupts"
		"		COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS"
	);

	DEFINE_SCHEDULE
	(
		SCHED_POLICE_FACE_ALONG_GOAL,

		"	Tasks"
		"		TASK_WAIT_RANDOM							2"
		"		TASK_POLICE_FACE_ALONG_GOAL					0"
		""
		"	Interrupts"
		"		COND_POLICE_TARGET_TOO_CLOSE_SUPPRESS"
	);

AI_END_CUSTOM_SCHEDULE_PROVIDER()
