d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
414 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 2aa14bb24c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2aa14bb24c'
${ noResults }
source-engine/game/server/hl2/npc_cranedriver.cpp

788 lines
21 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "ai_network.h"
#include "ai_default.h"
#include "ai_schedule.h"
#include "ai_hull.h"
#include "ai_node.h"
#include "ai_task.h"
#include "ai_senses.h"
#include "ai_navigator.h"
#include "ai_route.h"
#include "entitylist.h"
#include "soundenvelope.h"
#include "gamerules.h"
#include "ndebugoverlay.h"
#include "soundflags.h"
#include "trains.h"
#include "globalstate.h"
#include "vehicle_base.h"
#include "npc_vehicledriver.h"
#include "vehicle_crane.h"
#include "saverestore_utlvector.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ConVar g_debug_vehicledriver;
//=========================================================
// Custom schedules
//=========================================================
enum
{
SCHED_CRANE_RANGE_ATTACK1 = LAST_VEHICLEDRIVER_SCHED,
SCHED_CRANE_FIND_LARGE_OBJECT,
SCHED_CRANE_PICKUP_OBJECT,
SCHED_CRANE_FORCED_GO,
SCHED_CRANE_CHASE_ENEMY,
SCHED_CRANE_FORCED_DROP,
};
//=========================================================
// Custom tasks
//=========================================================
enum
{
TASK_CRANE_GET_POSITION_OVER_ENEMY = LAST_VEHICLEDRIVER_TASK,
TASK_CRANE_GET_POSITION_OVER_LASTPOSITION,
TASK_CRANE_GET_POSITION_OVER_OBJECT,
TASK_CRANE_TURN_MAGNET_OFF,
TASK_CRANE_FIND_OBJECT_TO_PICKUP,
TASK_CRANE_DROP_MAGNET,
TASK_END_FORCED_DROP,
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CNPC_CraneDriver : public CNPC_VehicleDriver
{
DECLARE_CLASS( CNPC_CraneDriver, CNPC_VehicleDriver );
public:
DECLARE_DATADESC();
DEFINE_CUSTOM_AI;
void Spawn( void );
void Activate( void );
// AI
int RangeAttack1Conditions( float flDot, float flDist );
int TranslateSchedule( int scheduleType );
int SelectSchedule( void );
void StartTask( const Task_t *pTask );
void RunTask( const Task_t *pTask );
void SetDesiredPosition( const Vector &vecPosition );
// Driving
void DriveVehicle( void );
bool OverrideMove( float flInterval );
// Inputs
void InputForcePickup( inputdata_t &inputdata );
void InputForceDrop( inputdata_t &inputdata );
protected:
CHandle<CPropCrane> m_hCrane;
EHANDLE m_hPickupTarget;
float m_flDistanceToTarget;
CUtlVector< EHANDLE > m_PreviouslyPickedUpObjects;
bool m_bForcedPickup;
bool m_bForcedDropoff;
float m_flDropWait;
float m_flReleasePause;
float m_flReleaseAt;
// Outputs
COutputEvent m_OnPickedUpObject;
COutputEvent m_OnDroppedObject;
COutputEvent m_OnPausingBeforeDrop;
};
BEGIN_DATADESC( CNPC_CraneDriver )
// Inputs
DEFINE_INPUTFUNC( FIELD_STRING, "ForcePickup", InputForcePickup ),
DEFINE_INPUTFUNC( FIELD_STRING, "ForceDrop", InputForceDrop ),
//DEFINE_FIELD( m_hCrane, FIELD_EHANDLE ),
DEFINE_FIELD( m_hPickupTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_flDistanceToTarget, FIELD_FLOAT ),
DEFINE_UTLVECTOR( m_PreviouslyPickedUpObjects, FIELD_EHANDLE ),
DEFINE_FIELD( m_bForcedPickup, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bForcedDropoff, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flDropWait, FIELD_FLOAT ),
DEFINE_KEYFIELD( m_flReleasePause, FIELD_FLOAT, "releasepause" ),
DEFINE_FIELD( m_flReleaseAt, FIELD_FLOAT ),
// Outputs
DEFINE_OUTPUT( m_OnPickedUpObject, "OnPickedUpObject" ),
DEFINE_OUTPUT( m_OnDroppedObject, "OnDroppedObject" ),
DEFINE_OUTPUT( m_OnPausingBeforeDrop, "OnPausingBeforeDrop" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( npc_cranedriver, CNPC_CraneDriver );
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void CNPC_CraneDriver::Spawn( void )
{
BaseClass::Spawn();
CapabilitiesClear();
CapabilitiesAdd( bits_CAP_INNATE_RANGE_ATTACK1 );
m_flDistTooFar = 2048.0;
SetDistLook( 2048 );
m_PreviouslyPickedUpObjects.Purge();
m_hPickupTarget = NULL;
m_bForcedPickup = false;
m_bForcedDropoff = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::Activate( void )
{
BaseClass::Activate();
m_hCrane = dynamic_cast<CPropCrane*>((CBaseEntity*)m_hVehicleEntity);
if ( !m_hCrane )
{
Warning( "npc_cranedriver %s couldn't find his crane named %s.\n", STRING(GetEntityName()), STRING(m_iszVehicleName) );
UTIL_Remove( this );
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
int CNPC_CraneDriver::RangeAttack1Conditions( float flDot, float flDist )
{
if ( !HasCondition( COND_SEE_ENEMY ) )
return COND_NONE;
// Do our distance check in 2D
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
Vector2D vecEnemy2D( GetEnemy()->GetAbsOrigin().x, GetEnemy()->GetAbsOrigin().y );
flDist = (vecOrigin2D - vecEnemy2D).Length();
// Maximum & Minimum size of the crane's reach
if ( flDist > MAX_CRANE_FLAT_REACH )
return COND_TOO_FAR_TO_ATTACK;
// Crane can't reach any closer than this
if ( flDist < MIN_CRANE_FLAT_REACH )
return COND_TOO_CLOSE_TO_ATTACK;
return COND_CAN_RANGE_ATTACK1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_CraneDriver::SelectSchedule( void )
{
if ( HasSpawnFlags(SF_VEHICLEDRIVER_INACTIVE) )
return BaseClass::SelectSchedule();
// If we've got an object to pickup, so go get it
if ( m_hPickupTarget )
{
// Only clear the pickup target if we managed to pick something up
if ( m_hCrane->GetTotalMassOnCrane() > 0 )
{
if ( m_bForcedPickup )
{
m_OnPickedUpObject.FireOutput( m_hPickupTarget, this );
}
// Remember what we dropped so we go try something else if we can.
m_PreviouslyPickedUpObjects.AddToTail( m_hPickupTarget );
m_hPickupTarget = NULL;
}
else
{
if ( m_NPCState == NPC_STATE_IDLE )
{
SetIdealState( NPC_STATE_ALERT );
}
return SCHED_CRANE_PICKUP_OBJECT;
}
}
// If we're currently being forced to pickup something, do only that
if ( m_bForcedPickup )
{
if ( m_hPickupTarget )
return SCHED_CRANE_PICKUP_OBJECT;
// We've picked up our target, we're waiting to be told where to put it
return SCHED_IDLE_STAND;
}
// If we've been told to drop something off, do that
if ( m_bForcedDropoff )
return SCHED_CRANE_FORCED_DROP;
switch ( m_NPCState )
{
case NPC_STATE_IDLE:
break;
case NPC_STATE_ALERT:
break;
case NPC_STATE_COMBAT:
if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) )
{
// Do we have anything on the crane? If not, look for something
if ( m_hCrane->GetTotalMassOnCrane() == 0 )
return SCHED_CRANE_FIND_LARGE_OBJECT;
// We've got something on the crane, so try and drop it on the enemy
return SCHED_CRANE_RANGE_ATTACK1;
}
// We can't attack him, so if we don't have anything on the crane, grab something
if ( m_hCrane->GetTotalMassOnCrane() == 0 )
return SCHED_CRANE_FIND_LARGE_OBJECT;
}
return BaseClass::SelectSchedule();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_CraneDriver::TranslateSchedule( int scheduleType )
{
switch ( scheduleType )
{
case SCHED_COMBAT_FACE:
// Vehicles can't rotate, so don't try and face
return TranslateSchedule( SCHED_CHASE_ENEMY );
case SCHED_ALERT_FACE:
// Vehicles can't rotate, so don't try and face
return SCHED_ALERT_STAND;
case SCHED_FORCED_GO:
return SCHED_CRANE_FORCED_GO;
case SCHED_CHASE_ENEMY:
return SCHED_CRANE_CHASE_ENEMY;
}
return BaseClass::TranslateSchedule(scheduleType);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTask -
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::StartTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_WAIT_FOR_MOVEMENT:
break;
case TASK_CRANE_GET_POSITION_OVER_ENEMY:
{
if ( !GetEnemy() )
{
TaskFail(FAIL_NO_ROUTE);
return;
}
SetDesiredPosition( GetEnemy()->GetAbsOrigin() );
TaskComplete();
}
break;
case TASK_CRANE_GET_POSITION_OVER_OBJECT:
{
if ( !m_hPickupTarget )
{
TaskFail("No object to pickup!");
return;
}
SetDesiredPosition( m_hPickupTarget->GetAbsOrigin() );
TaskComplete();
}
break;
case TASK_CRANE_GET_POSITION_OVER_LASTPOSITION:
{
SetDesiredPosition( m_vecLastPosition );
TaskComplete();
}
break;
case TASK_CRANE_TURN_MAGNET_OFF:
{
// If we picked up something, and we were being forced to pick something up, fire our output
if ( m_hCrane->GetTotalMassOnCrane() > 0 && m_bForcedDropoff )
{
// Are we supposed to pause first?
if ( m_flReleasePause )
{
m_flReleaseAt = gpGlobals->curtime + m_flReleasePause;
m_OnPausingBeforeDrop.FireOutput( this, this );
return;
}
m_OnDroppedObject.FireOutput( this, this );
}
m_hCrane->TurnMagnetOff();
TaskComplete();
}
break;
case TASK_END_FORCED_DROP:
{
m_bForcedDropoff = false;
TaskComplete();
}
break;
case TASK_CRANE_FIND_OBJECT_TO_PICKUP:
{
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
// Find a large physics object within our reach to pickup
float flLargestMass = 0;
CBaseEntity *pLargestEntity = NULL;
CBaseEntity *pList[1024];
Vector delta( m_flDistTooFar, m_flDistTooFar, m_flDistTooFar*2 );
int count = UTIL_EntitiesInBox( pList, 1024, m_hCrane->GetAbsOrigin() - delta, m_hCrane->GetAbsOrigin() + delta, 0 );
for ( int i = 0; i < count; i++ )
{
if ( !pList[i] )
continue;
// Ignore the crane & the magnet
if ( pList[i] == m_hCrane || pList[i] == m_hCrane->GetMagnet() )
continue;
if ( m_PreviouslyPickedUpObjects.Find( pList[i] ) != m_PreviouslyPickedUpObjects.InvalidIndex() )
continue;
// Get the VPhysics object
IPhysicsObject *pPhysics = pList[i]->VPhysicsGetObject();
if ( pPhysics && pList[i]->GetMoveType() == MOVETYPE_VPHYSICS )
{
float flMass = pPhysics->GetMass();
if ( flMass > flLargestMass && (flMass < MAXIMUM_CRANE_PICKUP_MASS) && (flMass > MINIMUM_CRANE_PICKUP_MASS) )
{
// Biggest one we've found so far
// Now make sure it's within our reach
// Do our distance check in 2D
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
Vector2D vecEnemy2D( pList[i]->GetAbsOrigin().x, pList[i]->GetAbsOrigin().y );
float flDist = (vecOrigin2D - vecEnemy2D).Length();
// Maximum & Minimum size of the crane's reach
if ( flDist > MAX_CRANE_FLAT_REACH )
continue;
if ( flDist < MIN_CRANE_FLAT_REACH )
continue;
flLargestMass = flMass;
pLargestEntity = pList[i];
}
}
}
// If we didn't find anything new, clear our list of targets
if ( !pLargestEntity )
{
m_PreviouslyPickedUpObjects.Purge();
}
if ( !pLargestEntity )
{
TaskFail("Couldn't find anything to pick up!");
return;
}
m_hPickupTarget = pLargestEntity;
TaskComplete();
}
break;
case TASK_CRANE_DROP_MAGNET:
{
// Drop the magnet, but only end the task once the magnet's back up
m_pVehicleInterface->NPC_SecondaryFire();
// Don't check to see if drop's finished until this time is up.
// This is necessary because the crane won't start dropping this
// frame, and our cranedriver will think it's finished immediately.
m_flDropWait = gpGlobals->curtime + 0.5;
}
break;
default:
BaseClass::StartTask( pTask );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::RunTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_WAIT_FOR_MOVEMENT:
{
// Is the magnet over the target, and are we not moving too fast?
AngularImpulse angVel;
Vector vecVelocity;
CBaseEntity *pMagnet = m_hCrane->GetMagnet();
IPhysicsObject *pVehiclePhysics = pMagnet->VPhysicsGetObject();
pVehiclePhysics->GetVelocity( &vecVelocity, &angVel );
float flVelocity = 100;
float flDistance = 90;
// More accurate on forced drops
if ( m_bForcedPickup || m_bForcedDropoff )
{
flVelocity = 10;
flDistance = 30;
}
if ( m_flDistanceToTarget < flDistance && m_hCrane->GetTurnRate() < 0.1 && vecVelocity.Length() < flVelocity )
{
TaskComplete();
}
}
break;
case TASK_CRANE_DROP_MAGNET:
{
// Wait for the magnet to get back up
if ( m_flDropWait < gpGlobals->curtime && !m_hCrane->IsDropping() )
{
TaskComplete();
}
}
break;
case TASK_CRANE_TURN_MAGNET_OFF:
{
// We're waiting for the pause length before dropping whatever's on our magnet
if ( gpGlobals->curtime > m_flReleaseAt )
{
if ( m_bForcedDropoff )
{
m_OnDroppedObject.FireOutput( this, this );
}
m_hCrane->TurnMagnetOff();
TaskComplete();
}
}
break;
default:
BaseClass::RunTask( pTask );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CNPC_CraneDriver::OverrideMove( float flInterval )
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::SetDesiredPosition( const Vector &vecPosition )
{
m_vecDesiredPosition = vecPosition;
m_flDistanceToTarget = 999;
}
//-----------------------------------------------------------------------------
// Purpose: This takes the current place the NPC's trying to get to, figures out
// what keys to press to get the vehicle to go there, and then sends
// them to the vehicle.
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::DriveVehicle( void )
{
// No targets?
if ( !GetEnemy() && m_vecDesiredPosition == vec3_origin )
return;
Vector vecTarget = m_vecDesiredPosition;
// Track our targets
if ( m_hPickupTarget )
{
vecTarget = m_hPickupTarget->GetAbsOrigin();
}
else if ( !m_bForcedPickup && !m_bForcedDropoff && GetEnemy() )
{
vecTarget = GetEnemy()->GetAbsOrigin();
}
// Move the crane over the target
// Use the crane type as a targeting point
Vector vecCraneTip = m_hCrane->GetCraneTipPosition();
Vector2D vecCraneTip2D( vecCraneTip.x, vecCraneTip.y );
Vector2D vecTarget2D( vecTarget.x, vecTarget.y );
Vector2D vecOrigin2D( m_hCrane->GetAbsOrigin().x, m_hCrane->GetAbsOrigin().y );
if ( g_debug_vehicledriver.GetInt() )
{
NDebugOverlay::Box( vecTarget, -Vector(50,50,50), Vector(50,50,50), 0,255,0, true, 0.1 );
NDebugOverlay::Box( vecCraneTip, -Vector(2,2,5000), Vector(2,2,5), 0,255,0, true, 0.1 );
NDebugOverlay::Box( vecTarget, -Vector(2,2,5), Vector(2,2,5000), 0,255,0, true, 0.1 );
}
// Store off the distance to our target
m_flDistanceToTarget = (vecTarget2D - vecCraneTip2D).Length();
// First determine whether we need to extend / retract the arm
float flDistToTarget = (vecOrigin2D - vecTarget2D).LengthSqr();
float flDistToCurrent = (vecOrigin2D - vecCraneTip2D).LengthSqr();
float flDelta = fabs(flDistToTarget - flDistToCurrent);
// Slow down as we get closer, but do it based upon our current extension rate
float flMinDelta = 50 + (50 * fabs(m_hCrane->GetExtensionRate() / CRANE_EXTENSION_RATE_MAX));
flMinDelta *= flMinDelta;
if ( flDelta > flMinDelta )
{
if ( flDistToCurrent > flDistToTarget )
{
// Retract
m_pVehicleInterface->NPC_ThrottleReverse();
}
else if ( flDistToCurrent < flDistToTarget )
{
// Extend
m_pVehicleInterface->NPC_ThrottleForward();
}
}
else
{
m_pVehicleInterface->NPC_ThrottleCenter();
}
// Then figure out if we need to rotate. Do it all in 2D space.
Vector vecRight, vecForward;
m_hCrane->GetVectors( &vecForward, &vecRight, NULL );
vecRight.z = 0;
vecForward.z = 0;
VectorNormalize( vecRight );
VectorNormalize( vecForward );
Vector vecToTarget = ( vecTarget - m_hCrane->GetAbsOrigin() );
vecToTarget.z = 0;
VectorNormalize( vecToTarget );
float flDotRight = DotProduct( vecRight, vecToTarget );
float flDotForward = DotProduct( vecForward, vecToTarget );
// Start slowing if we're going to hit the point soon
float flTurnInDeg = RAD2DEG( acos(flDotForward) );
float flSpeed = m_hCrane->GetMaxTurnRate() * (flTurnInDeg / 15.0);
flSpeed = MIN( m_hCrane->GetMaxTurnRate(), flSpeed );
if ( fabs(flSpeed) < 0.05 )
{
// We're approaching the target, so stop turning
m_pVehicleInterface->NPC_TurnCenter();
}
else
{
if ( flDotRight < 0 )
{
// Turn right
m_pVehicleInterface->NPC_TurnRight( flSpeed );
}
else if ( flDotRight > 0 )
{
// Turn left
m_pVehicleInterface->NPC_TurnLeft( flSpeed );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Force the driver to pickup a specific entity
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::InputForcePickup( inputdata_t &inputdata )
{
string_t iszPickupName = inputdata.value.StringID();
if ( iszPickupName != NULL_STRING )
{
// Turn the magnet off now to drop anything we might have already on the magnet
m_hCrane->TurnMagnetOff();
m_hPickupTarget = gEntList.FindEntityByName( NULL, iszPickupName, NULL, inputdata.pActivator, inputdata.pCaller );
m_bForcedPickup = true;
m_bForcedDropoff = false;
SetCondition( COND_PROVOKED );
CLEARBITS( m_spawnflags, SF_VEHICLEDRIVER_INACTIVE );
}
}
//-----------------------------------------------------------------------------
// Purpose: Force the driver to drop his held entity at a specific point
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CNPC_CraneDriver::InputForceDrop( inputdata_t &inputdata )
{
string_t iszDropName = inputdata.value.StringID();
if ( iszDropName != NULL_STRING )
{
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, iszDropName, NULL, inputdata.pActivator, inputdata.pCaller );
if ( !pEntity )
{
Warning("Crane couldn't find entity named %s\n", STRING(iszDropName) );
return;
}
m_bForcedPickup = false;
m_bForcedDropoff = true;
SetDesiredPosition( pEntity->GetAbsOrigin() );
SetCondition( COND_PROVOKED );
CLEARBITS( m_spawnflags, SF_VEHICLEDRIVER_INACTIVE );
}
}
//-----------------------------------------------------------------------------
//
// Schedules
//
//-----------------------------------------------------------------------------
AI_BEGIN_CUSTOM_NPC( npc_cranedriver, CNPC_CraneDriver )
//Tasks
DECLARE_TASK( TASK_CRANE_GET_POSITION_OVER_ENEMY )
DECLARE_TASK( TASK_CRANE_GET_POSITION_OVER_LASTPOSITION )
DECLARE_TASK( TASK_CRANE_GET_POSITION_OVER_OBJECT )
DECLARE_TASK( TASK_CRANE_TURN_MAGNET_OFF )
DECLARE_TASK( TASK_END_FORCED_DROP )
DECLARE_TASK( TASK_CRANE_FIND_OBJECT_TO_PICKUP )
DECLARE_TASK( TASK_CRANE_DROP_MAGNET )
//Schedules
//==================================================
// SCHED_ANTLION_CHASE_ENEMY_BURROW
//==================================================
DEFINE_SCHEDULE
(
SCHED_CRANE_RANGE_ATTACK1,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CHASE_ENEMY"
" TASK_CRANE_GET_POSITION_OVER_ENEMY 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_CRANE_TURN_MAGNET_OFF 0"
" "
" Interrupts"
" COND_ENEMY_DEAD"
" COND_NEW_ENEMY"
" COND_ENEMY_OCCLUDED"
" COND_ENEMY_TOO_FAR"
" COND_PROVOKED"
)
DEFINE_SCHEDULE
(
SCHED_CRANE_FIND_LARGE_OBJECT,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CHASE_ENEMY"
" TASK_CRANE_FIND_OBJECT_TO_PICKUP 0"
" "
" Interrupts"
" COND_ENEMY_DEAD"
" COND_NEW_ENEMY"
" COND_ENEMY_OCCLUDED"
" COND_ENEMY_TOO_FAR"
)
DEFINE_SCHEDULE
(
SCHED_CRANE_PICKUP_OBJECT,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CHASE_ENEMY"
" TASK_CRANE_GET_POSITION_OVER_OBJECT 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_CRANE_DROP_MAGNET 0"
" "
" Interrupts"
" COND_ENEMY_DEAD"
" COND_NEW_ENEMY"
" COND_ENEMY_OCCLUDED"
" COND_ENEMY_TOO_FAR"
" COND_PROVOKED"
)
DEFINE_SCHEDULE
(
SCHED_CRANE_FORCED_GO,
" Tasks"
" TASK_CRANE_GET_POSITION_OVER_LASTPOSITION 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_CRANE_TURN_MAGNET_OFF 0"
" TASK_WAIT 2"
" "
" Interrupts"
)
DEFINE_SCHEDULE
(
SCHED_CRANE_CHASE_ENEMY,
" Tasks"
" TASK_CRANE_GET_POSITION_OVER_ENEMY 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_WAIT 5"
" "
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_ENEMY_UNREACHABLE"
" COND_CAN_RANGE_ATTACK1"
" COND_TOO_CLOSE_TO_ATTACK"
" COND_TASK_FAILED"
" COND_LOST_ENEMY"
" COND_PROVOKED"
)
DEFINE_SCHEDULE
(
SCHED_CRANE_FORCED_DROP,
" Tasks"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_CRANE_TURN_MAGNET_OFF 0"
" TASK_END_FORCED_DROP 0"
" TASK_WAIT 2"
" "
" Interrupts"
)
AI_END_CUSTOM_NPC()