hl2_src-leak-2017/src/game/server/ai_motor.cpp

1034 lines
28 KiB
C++
Raw Normal View History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "animation.h" // for NOMOTION
#include "ai_motor.h"
#include "ai_navigator.h"
#include "ai_basenpc.h"
#include "ai_localnavigator.h"
#include "ai_moveprobe.h"
#include "saverestore_utlvector.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifdef DEBUG
ConVar ai_draw_motor_movement( "ai_draw_motor_movement","0" );
#endif
extern float GetFloorZ(const Vector &origin);
//-----------------------------------------------------------------------------
// Use these functions to set breakpoints to find out where movement is failing
#ifdef DEBUG
void DebugNoteMovementFailure()
{
}
// a place to put breakpoints
#pragma warning(push)
#pragma warning(disable:4189)
AIMoveResult_t DbgResult( AIMoveResult_t result )
{
if ( result < AIMR_OK )
{
int breakHere = 1;
}
switch ( result )
{
case AIMR_BLOCKED_ENTITY:
return AIMR_BLOCKED_ENTITY;
case AIMR_BLOCKED_WORLD:
return AIMR_BLOCKED_WORLD;
case AIMR_BLOCKED_NPC:
return AIMR_BLOCKED_NPC;
case AIMR_ILLEGAL:
return AIMR_ILLEGAL;
case AIMR_OK:
return AIMR_OK;
case AIMR_CHANGE_TYPE:
return AIMR_CHANGE_TYPE;
};
return AIMR_ILLEGAL;
};
#endif
//-----------------------------------------------------------------------------
//
// class CAI_Motor
//
BEGIN_SIMPLE_DATADESC( CAI_Motor )
// m_flMoveInterval (think transient)
DEFINE_FIELD( m_IdealYaw, FIELD_FLOAT ),
DEFINE_FIELD( m_YawSpeed, FIELD_FLOAT ),
DEFINE_FIELD( m_vecVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_vecAngularVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_nDismountSequence, FIELD_INTEGER ),
DEFINE_FIELD( m_vecDismount, FIELD_VECTOR ),
DEFINE_UTLVECTOR( m_facingQueue, FIELD_EMBEDDED ),
DEFINE_FIELD( m_bYawLocked, FIELD_BOOLEAN ),
// m_pMoveProbe
END_DATADESC()
//-----------------------------------------------------------------------------
CAI_Motor::CAI_Motor(CAI_BaseNPC *pOuter)
: CAI_Component( pOuter )
{
m_flMoveInterval = 0;
m_IdealYaw = 0;
m_YawSpeed = 0;
m_vecVelocity = Vector( 0, 0, 0 );
m_pMoveProbe = NULL;
m_bYawLocked = false;
}
//-----------------------------------------------------------------------------
CAI_Motor::~CAI_Motor()
{
}
//-----------------------------------------------------------------------------
void CAI_Motor::Init( IAI_MovementSink *pMovementServices )
{
CAI_ProxyMovementSink::Init( pMovementServices );
m_pMoveProbe = GetOuter()->GetMoveProbe(); // @TODO (toml 03-30-03): this is a "bad" way to grab this pointer. Components should have an explcit "init" phase.
}
//-----------------------------------------------------------------------------
// Step iteratively toward a destination position
//-----------------------------------------------------------------------------
AIMotorMoveResult_t CAI_Motor::MoveGroundStep( const Vector &newPos, CBaseEntity *pMoveTarget, float yaw, bool bAsFarAsCan, bool bTestZ, AIMoveTrace_t *pTraceResult )
{
// By definition, this will produce different results than GroundMoveLimit()
// because there's no guarantee that it will step exactly one step
// See how far toward the new position we can step...
// But don't actually test for ground geometric validity;
// if it isn't valid, there's not much we can do about it
AIMoveTrace_t moveTrace;
unsigned testFlags = AITGM_IGNORE_FLOOR;
if ( !bTestZ )
testFlags |= AITGM_2D;
#ifdef DEBUG
if ( ai_draw_motor_movement.GetBool() )
testFlags |= AITGM_DRAW_RESULTS;
#endif
GetMoveProbe()->TestGroundMove( GetLocalOrigin(), newPos, MASK_NPCSOLID, testFlags, &moveTrace );
if ( pTraceResult )
{
*pTraceResult = moveTrace;
}
bool bHitTarget = (moveTrace.pObstruction && (pMoveTarget == moveTrace.pObstruction ));
// Move forward either if there was no obstruction or if we're told to
// move as far as we can, regardless
bool bIsBlocked = IsMoveBlocked(moveTrace.fStatus);
if ( !bIsBlocked || bAsFarAsCan || bHitTarget )
{
#ifdef DEBUG
if ( GetMoveProbe()->CheckStandPosition( GetLocalOrigin(), MASK_NPCSOLID ) && !GetMoveProbe()->CheckStandPosition( moveTrace.vEndPosition, MASK_NPCSOLID ) )
{
DevMsg( 2, "Warning: AI motor probably given invalid instructions\n" );
}
#endif
// The true argument here causes it to touch all triggers
// in the volume swept from the previous position to the current position
UTIL_SetOrigin(GetOuter(), moveTrace.vEndPosition, true);
// check to see if our ground entity has changed
// NOTE: This is to detect changes in ground entity as the movement code has optimized out
// ground checks. So now we have to do a simple recheck to make sure we detect when we've
// stepped onto a new entity.
if ( GetOuter()->GetFlags() & FL_ONGROUND )
{
GetOuter()->PhysicsStepRecheckGround();
}
// skip tiny steps, but notify the shadow object of any large steps
if ( moveTrace.flStepUpDistance > 0.1f )
{
float height = clamp( moveTrace.flStepUpDistance, 0.f, StepHeight() );
IPhysicsObject *pPhysicsObject = GetOuter()->VPhysicsGetObject();
if ( pPhysicsObject )
{
IPhysicsShadowController *pShadow = pPhysicsObject->GetShadowController();
if ( pShadow )
{
pShadow->StepUp( height );
}
}
}
if ( yaw != -1 )
{
QAngle angles = GetLocalAngles();
angles.y = yaw;
SetLocalAngles( angles );
}
if ( bHitTarget )
return AIM_PARTIAL_HIT_TARGET;
if ( !bIsBlocked )
return AIM_SUCCESS;
if ( moveTrace.fStatus == AIMR_BLOCKED_NPC )
return AIM_PARTIAL_HIT_NPC;
return AIM_PARTIAL_HIT_WORLD;
}
return AIM_FAILED;
}
//-----------------------------------------------------------------------------
// Purpose: Motion for climbing
// Input :
// Output : Returns bits (MoveStatus_b) regarding the move status
//-----------------------------------------------------------------------------
void CAI_Motor::MoveClimbStart( const Vector &climbDest, const Vector &climbDir, float climbDist, float yaw )
{
// @Note (toml 06-11-02): the following code is somewhat suspect. It
// originated in CAI_BaseNPC::MoveClimb() from early June 2002
// At the very least, state should be restored to original, not
// slammed.
//
// -----Original Message-----
// From: Jay Stelly
// Sent: Monday, June 10, 2002 3:57 PM
// To: Tom Leonard
// Subject: RE:
//
// yes.
//
// Also, there is some subtlety to using movetype. I think in
// general we want to keep things in MOVETYPE_STEP because it
// implies a bunch of things in the external game physics
// simulator. There is a flag FL_FLY we use to
// disable gravity on MOVETYPE_STEP characters.
//
// > -----Original Message-----
// > From: Tom Leonard
// > Sent: Monday, June 10, 2002 3:55 PM
// > To: Jay Stelly
// > Subject:
// >
// > Should I worry at all that the following highlighted bits of
// > code are not reciprocal for all state, and furthermore, stomp
// > other state?
if ( fabsf( climbDir.z ) < .1 )
{
SetActivity( GetNavigator()->GetMovementActivity() );
}
else
{
SetActivity( (climbDir.z > -0.01 ) ? ACT_CLIMB_UP : ACT_CLIMB_DOWN );
}
m_nDismountSequence = SelectWeightedSequence( ACT_CLIMB_DISMOUNT );
if (m_nDismountSequence != ACT_INVALID)
{
GetOuter()->GetSequenceLinearMotion( m_nDismountSequence, &m_vecDismount );
}
else
{
m_vecDismount.Init();
}
GetOuter()->AddFlag( FL_FLY ); // No gravity
SetSolid( SOLID_BBOX );
SetGravity( 0.0 );
SetGroundEntity( NULL );
}
AIMoveResult_t CAI_Motor::MoveClimbExecute( const Vector &climbDest, const Vector &climbDir, float climbDist, float yaw, int climbNodesLeft )
{
if ( fabsf( climbDir.z ) > .1 )
{
if ( GetActivity() != ACT_CLIMB_DISMOUNT )
{
Activity desiredActivity = (climbDir.z > -0.01 ) ? ACT_CLIMB_UP : ACT_CLIMB_DOWN;
if ( GetActivity() != desiredActivity )
{
SetActivity( desiredActivity );
}
}
if ( GetActivity() != ACT_CLIMB_UP && GetActivity() != ACT_CLIMB_DOWN && GetActivity() != ACT_CLIMB_DISMOUNT )
{
DevMsg( "Climber not in a climb activity!\n" );
return AIMR_ILLEGAL;
}
if (m_nDismountSequence != ACT_INVALID)
{
if (GetActivity() == ACT_CLIMB_UP )
{
if (climbNodesLeft <= 2 && climbDist < fabs( m_vecDismount.z ))
{
// fixme: No other way to force m_nIdealSequence?
GetOuter()->SetActivity( ACT_CLIMB_DISMOUNT );
GetOuter()->SetCycle( GetOuter()->GetMovementFrame( m_vecDismount.z - climbDist ) );
}
}
}
}
float climbSpeed = GetOuter()->GetInstantaneousVelocity();
if (m_nDismountSequence != ACT_INVALID)
{
// catch situations where the climb mount/dismount finished before reaching goal
climbSpeed = MAX( climbSpeed, 30.0 );
}
else
{
// FIXME: assume if they don't have a dismount animation then they probably don't really support climbing.
climbSpeed = 100.0;
}
SetSmoothedVelocity( climbDir * climbSpeed );
if ( climbDist < climbSpeed * GetMoveInterval() )
{
if (climbDist <= 1e-2)
climbDist = 0;
const float climbTime = climbDist / climbSpeed;
SetMoveInterval( GetMoveInterval() - climbTime );
SetLocalOrigin( climbDest );
return AIMR_CHANGE_TYPE;
}
else
{
SetMoveInterval( 0 );
}
// --------------------------------------------
// Turn to face the climb
// --------------------------------------------
SetIdealYawAndUpdate( yaw );
return AIMR_OK;
}
void CAI_Motor::MoveClimbStop()
{
if ( GetNavigator()->GetMovementActivity() > ACT_RESET )
SetActivity( GetNavigator()->GetMovementActivity() );
else
SetActivity( ACT_IDLE );
GetOuter()->RemoveFlag( FL_FLY );
SetSmoothedVelocity( vec3_origin );
SetGravity( 1.0 );
}
//-----------------------------------------------------------------------------
// Purpose: Motion for jumping
// Input :
// Output : Returns bits (MoveStatus_b) regarding the move status
//-----------------------------------------------------------------------------
void CAI_Motor::MoveJumpStart( const Vector &velocity )
{
// take the npc off the ground and throw them in the air
SetSmoothedVelocity( velocity );
SetGravity( GetOuter()->GetJumpGravity() );
SetGroundEntity( NULL );
SetActivity( ACT_JUMP );
SetIdealYawAndUpdate( velocity );
}
int CAI_Motor::MoveJumpExecute( )
{
// needs to detect being hit
UpdateYaw( );
if (GetOuter()->GetActivity() == ACT_JUMP && GetOuter()->IsActivityFinished())
{
SetActivity( ACT_GLIDE );
}
// use all the time
SetMoveInterval( 0 );
return AIMR_OK;
}
AIMoveResult_t CAI_Motor::MoveJumpStop()
{
SetSmoothedVelocity( Vector(0,0,0) );
if (GetOuter()->GetActivity() == ACT_GLIDE)
{
float flTime = GetOuter()->GetGroundChangeTime();
GetOuter()->AddStepDiscontinuity( flTime, GetAbsOrigin(), GetAbsAngles() );
if ( SelectWeightedSequence( ACT_LAND ) == ACT_INVALID )
return AIMR_CHANGE_TYPE;
SetActivity( ACT_LAND );
// FIXME: find out why the client doesn't interpolate immediatly after sequence change
// GetOuter()->SetCycle( flTime - gpGlobals->curtime );
}
if (GetOuter()->GetActivity() != ACT_LAND || GetOuter()->IsActivityFinished())
{
return AIMR_CHANGE_TYPE;
}
SetMoveInterval( 0 );
SetGravity( 1.0f );
return AIMR_OK;
}
//-----------------------------------------------------------------------------
float CAI_Motor::GetIdealSpeed() const
{
return GetOuter()->GetIdealSpeed();
}
float CAI_Motor::GetIdealAccel() const
{
return GetOuter()->GetIdealAccel();
}
//-----------------------------------------------------------------------------
// how far will I go?
float CAI_Motor::MinStoppingDist( float flMinResult )
{
// FIXME: should this be a constant rate or a constant time like it is now?
float flDecelRate = GetIdealAccel();
if (flDecelRate > 0.0)
{
// assuming linear deceleration, how long till my V hits 0?
float t = GetCurSpeed() / flDecelRate;
// and how far will I travel? (V * t - 1/2 A t^2)
float flDist = GetCurSpeed() * t - 0.5 * flDecelRate * t * t;
// this should always be some reasonable non-zero distance
if (flDist > flMinResult)
return flDist;
return flMinResult;
}
return flMinResult;
}
//-----------------------------------------------------------------------------
// Purpose: how fast should I be going ideally
//-----------------------------------------------------------------------------
float CAI_Motor::IdealVelocity( void )
{
// FIXME: this should be a per-entity setting so run speeds are not based on animation speeds
return GetIdealSpeed() * GetPlaybackRate();
}
//-----------------------------------------------------------------------------
void CAI_Motor::ResetMoveCalculations()
{
}
//-----------------------------------------------------------------------------
void CAI_Motor::MoveStart()
{
}
//-----------------------------------------------------------------------------
void CAI_Motor::MoveStop()
{
memset( &m_vecVelocity, 0, sizeof(m_vecVelocity) );
GetOuter()->GetLocalNavigator()->ResetMoveCalculations();
}
//-----------------------------------------------------------------------------
void CAI_Motor::MovePaused()
{
}
//-----------------------------------------------------------------------------
// Purpose: what linear accel/decel rate do I need to hit V1 in d distance?
//-----------------------------------------------------------------------------
float DeltaV( float v0, float v1, float d )
{
return 0.5 * (v1 * v1 - v0 * v0 ) / d;
}
//-----------------------------------------------------------------------------
float CAI_Motor::CalcIntervalMove()
{
// assuming linear acceleration, how far will I travel?
return 0.5 * (GetCurSpeed() + GetIdealSpeed()) * GetMoveInterval();
}
//-----------------------------------------------------------------------------
// Purpose: Move the npc to the next location on its route.
// Input : vecDir - Normalized vector indicating the direction of movement.
// flDistance - distance to move
// flInterval - Time interval for this movement.
// flGoalDistance - target distance
// flGoalVelocity - target velocity
//-----------------------------------------------------------------------------
AIMotorMoveResult_t CAI_Motor::MoveGroundExecute( const AILocalMoveGoal_t &move, AIMoveTrace_t *pTraceResult )
{
// --------------------------------------------
// turn in the direction of movement
// --------------------------------------------
MoveFacing( move );
// --------------------------------------------
return MoveGroundExecuteWalk( move, GetIdealSpeed(), CalcIntervalMove(), pTraceResult );
}
AIMotorMoveResult_t CAI_Motor::MoveGroundExecuteWalk( const AILocalMoveGoal_t &move, float speed, float dist, AIMoveTrace_t *pTraceResult )
{
bool bReachingLocalGoal = ( dist > move.maxDist );
// can I move farther in this interval than I'm supposed to?
if ( bReachingLocalGoal )
{
if ( !(move.flags & AILMG_CONSUME_INTERVAL) )
{
// only use a portion of the time interval
SetMoveInterval( GetMoveInterval() * (1 - move.maxDist / dist) );
}
else
SetMoveInterval( 0 );
dist = move.maxDist;
}
else
{
// use all the time
SetMoveInterval( 0 );
}
SetMoveVel( move.dir * speed );
// --------------------------------------------
// walk the distance
// --------------------------------------------
AIMotorMoveResult_t result = AIM_SUCCESS;
if ( dist > 0.0 )
{
Vector vecFrom = GetLocalOrigin();
Vector vecTo = vecFrom + move.dir * dist;
result = MoveGroundStep( vecTo, move.pMoveTarget, -1, true, bReachingLocalGoal, pTraceResult );
if ( result == AIM_FAILED )
MoveStop();
}
else if ( !OnMoveStalled( move ) )
{
result = AIM_FAILED;
}
return result;
}
//-----------------------------------------------------------------------------
// Purpose: Move the npc to the next location on its route.
// Input : pTargetEnt -
// vecDir - Normalized vector indicating the direction of movement.
// flInterval - Time interval for this movement.
//-----------------------------------------------------------------------------
AIMotorMoveResult_t CAI_Motor::MoveFlyExecute( const AILocalMoveGoal_t &move, AIMoveTrace_t *pTraceResult )
{
// turn in the direction of movement
MoveFacing( move );
// calc accel/decel rates
float flNewSpeed = GetIdealSpeed();
SetMoveVel( move.dir * flNewSpeed );
float flTotal = 0.5 * (GetCurSpeed() + flNewSpeed) * GetMoveInterval();
float distance = move.maxDist;
// can I move farther in this interval than I'm supposed to?
if (flTotal > distance)
{
// only use a portion of the time interval
SetMoveInterval( GetMoveInterval() * (1 - distance / flTotal) );
flTotal = distance;
}
else
{
// use all the time
SetMoveInterval( 0 );
}
Vector vecStart, vecEnd;
vecStart = GetLocalOrigin();
VectorMA( vecStart, flTotal, move.dir, vecEnd );
AIMoveTrace_t moveTrace;
GetMoveProbe()->MoveLimit( NAV_FLY, vecStart, vecEnd, MASK_NPCSOLID, NULL, &moveTrace );
if ( pTraceResult )
*pTraceResult = moveTrace;
// Check for total blockage
if (fabs(moveTrace.flDistObstructed - flTotal) <= 1e-1)
{
// But if we bumped into our target, then we succeeded!
if ( move.pMoveTarget && (moveTrace.pObstruction == move.pMoveTarget) )
return AIM_PARTIAL_HIT_TARGET;
return AIM_FAILED;
}
// The true argument here causes it to touch all triggers
// in the volume swept from the previous position to the current position
UTIL_SetOrigin(GetOuter(), moveTrace.vEndPosition, true);
return (IsMoveBlocked(moveTrace.fStatus)) ? AIM_PARTIAL_HIT_WORLD : AIM_SUCCESS;
}
//-----------------------------------------------------------------------------
// Purpose: turn in the direction of movement
// Output :
//-----------------------------------------------------------------------------
void CAI_Motor::MoveFacing( const AILocalMoveGoal_t &move )
{
if ( GetOuter()->OverrideMoveFacing( move, GetMoveInterval() ) )
return;
// required movement direction
float flMoveYaw = UTIL_VecToYaw( move.dir );
int nSequence = GetSequence();
float fSequenceMoveYaw = GetSequenceMoveYaw( nSequence );
if ( fSequenceMoveYaw == NOMOTION )
{
fSequenceMoveYaw = 0;
}
if (!HasPoseParameter( nSequence, GetOuter()->LookupPoseMoveYaw() ))
{
SetIdealYawAndUpdate( UTIL_AngleMod( flMoveYaw - fSequenceMoveYaw ) );
}
else
{
// FIXME: move this up to navigator so that path goals can ignore these overrides.
Vector dir;
float flInfluence = GetFacingDirection( dir );
dir = move.facing * (1 - flInfluence) + dir * flInfluence;
VectorNormalize( dir );
// ideal facing direction
float idealYaw = UTIL_AngleMod( UTIL_VecToYaw( dir ) );
// FIXME: facing has important max velocity issues
SetIdealYawAndUpdate( idealYaw );
// find movement direction to compensate for not being turned far enough
float flDiff = UTIL_AngleDiff( flMoveYaw, GetLocalAngles().y );
SetPoseParameter( GetOuter()->LookupPoseMoveYaw(), flDiff );
/*
if ((GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT))
{
DevMsg( "move %.1f : diff %.1f : ideal %.1f\n", flMoveYaw, flDiff, m_IdealYaw );
}
*/
}
}
//-----------------------------------------------------------------------------
// Purpose: Set the ideal yaw and run the current or specified timestep
// worth of rotation.
//-----------------------------------------------------------------------------
void CAI_Motor::SetIdealYawAndUpdate( float idealYaw, float yawSpeed)
{
SetIdealYaw( idealYaw );
if (yawSpeed == AI_CALC_YAW_SPEED)
RecalculateYawSpeed();
else if (yawSpeed != AI_KEEP_YAW_SPEED)
SetYawSpeed( yawSpeed );
UpdateYaw(-1);
}
//-----------------------------------------------------------------------------
void CAI_Motor::RecalculateYawSpeed()
{
SetYawSpeed( CalcYawSpeed() );
}
//-----------------------------------------------------------------------------
float AI_ClampYaw( float yawSpeedPerSec, float current, float target, float time )
{
if (current != target)
{
float speed = yawSpeedPerSec * time;
float move = target - current;
if (target > current)
{
if (move >= 180)
move = move - 360;
}
else
{
if (move <= -180)
move = move + 360;
}
if (move > 0)
{// turning to the npc's left
if (move > speed)
move = speed;
}
else
{// turning to the npc's right
if (move < -speed)
move = -speed;
}
return UTIL_AngleMod(current + move);
}
return target;
}
//-----------------------------------------------------------------------------
// Purpose: Turns a npc towards its ideal yaw.
// Input : yawSpeed - Yaw speed in degrees per 1/10th of a second.
// flInterval - Time interval to turn, -1 uses time since last think.
// Output : Returns the number of degrees turned.
//-----------------------------------------------------------------------------
void CAI_Motor::UpdateYaw( int yawSpeed )
{
// Don't do this if our yaw is locked
if ( IsYawLocked() )
return;
GetOuter()->SetUpdatedYaw();
float ideal, current, newYaw;
if ( yawSpeed == -1 )
yawSpeed = GetYawSpeed();
// NOTE: GetIdealYaw() will never exactly be reached because UTIL_AngleMod
// also truncates the angle to 16 bits of resolution. So lets truncate it here.
current = UTIL_AngleMod( GetLocalAngles().y );
ideal = UTIL_AngleMod( GetIdealYaw() );
// FIXME: this needs a proper interval
float dt = MIN( 0.2, gpGlobals->curtime - GetLastThink() );
newYaw = AI_ClampYaw( (float)yawSpeed * 10.0, current, ideal, dt );
if (newYaw != current)
{
QAngle angles = GetLocalAngles();
angles.y = newYaw;
SetLocalAngles( angles );
}
}
//=========================================================
// DeltaIdealYaw - returns the difference ( in degrees ) between
// npc's current yaw and ideal_yaw
//
// Positive result is left turn, negative is right turn
//=========================================================
float CAI_Motor::DeltaIdealYaw ( void )
{
float flCurrentYaw;
flCurrentYaw = UTIL_AngleMod( GetLocalAngles().y );
if ( flCurrentYaw == GetIdealYaw() )
{
return 0;
}
return UTIL_AngleDiff( GetIdealYaw(), flCurrentYaw );
}
//-----------------------------------------------------------------------------
void CAI_Motor::SetIdealYawToTarget( const Vector &target, float noise, float offset )
{
float base = CalcIdealYaw( target );
base += offset;
if ( noise > 0 )
{
noise *= 0.5;
base += random->RandomFloat( -noise, noise );
if ( base < 0 )
base += 360;
else if ( base >= 360 )
base -= 360;
}
SetIdealYaw( base );
}
//-----------------------------------------------------------------------------
void CAI_Motor::SetIdealYawToTargetAndUpdate( const Vector &target, float yawSpeed )
{
SetIdealYawAndUpdate( CalcIdealYaw( target ), yawSpeed );
}
//-----------------------------------------------------------------------------
// Purpose: Keep track of multiple objects that the npc is interested in facing
//-----------------------------------------------------------------------------
void CAI_Motor::AddFacingTarget( CBaseEntity *pTarget, float flImportance, float flDuration, float flRamp )
{
m_facingQueue.Add( pTarget, flImportance, flDuration, flRamp );
}
void CAI_Motor::AddFacingTarget( const Vector &vecPosition, float flImportance, float flDuration, float flRamp )
{
m_facingQueue.Add( vecPosition, flImportance, flDuration, flRamp );
}
void CAI_Motor::AddFacingTarget( CBaseEntity *pTarget, const Vector &vecPosition, float flImportance, float flDuration, float flRamp )
{
m_facingQueue.Add( pTarget, vecPosition, flImportance, flDuration, flRamp );
}
float CAI_Motor::GetFacingDirection( Vector &vecDir )
{
float flTotalInterest = 0.0;
vecDir = Vector( 0, 0, 0 );
int i;
// clean up facing targets
for (i = 0; i < m_facingQueue.Count();)
{
if (!m_facingQueue[i].IsActive())
{
m_facingQueue.Remove( i );
}
else
{
i++;
}
}
for (i = 0; i < m_facingQueue.Count(); i++)
{
float flInterest = m_facingQueue[i].Interest( );
Vector tmp = m_facingQueue[i].GetPosition() - GetAbsOrigin();
// NDebugOverlay::Line( m_facingQueue[i].GetPosition(), GetAbsOrigin(), 255, 0, 0, false, 0.1 );
VectorNormalize( tmp );
vecDir = vecDir * (1 - flInterest) + tmp * flInterest;
flTotalInterest = (1 - (1 - flTotalInterest) * (1 - flInterest));
VectorNormalize( vecDir );
}
return flTotalInterest;
}
//-----------------------------------------------------------------------------
AIMoveResult_t CAI_Motor::MoveNormalExecute( const AILocalMoveGoal_t &move )
{
AI_PROFILE_SCOPE(CAI_Motor_MoveNormalExecute);
// --------------------------------
AIMotorMoveResult_t fMotorResult;
AIMoveTrace_t moveTrace;
if ( move.navType == NAV_GROUND )
{
fMotorResult = MoveGroundExecute( move, &moveTrace );
}
else
{
Assert( move.navType == NAV_FLY );
fMotorResult = MoveFlyExecute( move, &moveTrace );
}
static AIMoveResult_t moveResults[] =
{
AIMR_ILLEGAL, // AIM_FAILED
AIMR_OK, // AIM_SUCCESS
AIMR_BLOCKED_NPC, // AIM_PARTIAL_HIT_NPC
AIMR_BLOCKED_WORLD, // AIM_PARTIAL_HIT_WORLD
AIMR_BLOCKED_WORLD, // AIM_PARTIAL_HIT_TARGET
};
Assert( ARRAYSIZE( moveResults ) == AIM_NUM_RESULTS && fMotorResult >= 0 && fMotorResult <= ARRAYSIZE( moveResults ) );
AIMoveResult_t result = moveResults[fMotorResult];
if ( result != AIMR_OK )
{
OnMoveExecuteFailed( move, moveTrace, fMotorResult, &result );
SetMoveInterval( 0 ); // always consume interval on failure, even if overridden by OnMoveExecuteFailed()
}
return DbgResult( result );
}
//-----------------------------------------------------------------------------
// Purpose: Look ahead my stopping distance, or at least my hull width
//-----------------------------------------------------------------------------
float CAI_Motor::MinCheckDist( void )
{
// Take the groundspeed into account
float flMoveDist = GetMoveInterval() * GetIdealSpeed();
float flMinDist = MAX( MinStoppingDist(), flMoveDist);
if ( flMinDist < GetHullWidth() )
flMinDist = GetHullWidth();
return flMinDist;
}
//-----------------------------------------------------------------------------
CAI_Navigator *CAI_Motor::GetNavigator( void )
{
return GetOuter()->GetNavigator();
}
int CAI_Motor::SelectWeightedSequence ( Activity activity )
{
return GetOuter()->SelectWeightedSequence ( activity );
}
float CAI_Motor::GetSequenceGroundSpeed( int iSequence )
{
return GetOuter()->GetSequenceGroundSpeed( iSequence );
}
//-----------------------------------------------------------------------------
void CAI_Motor::SetSmoothedVelocity(const Vector &vecVelocity)
{
GetOuter()->SetAbsVelocity(vecVelocity);
}
Vector CAI_Motor::GetSmoothedVelocity()
{
return GetOuter()->GetSmoothedVelocity();
}
float CAI_Motor::StepHeight() const
{
return GetOuter()->StepHeight();
}
bool CAI_Motor::CanStandOn( CBaseEntity *pSurface ) const
{
return GetOuter()->CanStandOn( pSurface );
}
float CAI_Motor::CalcIdealYaw( const Vector &vecTarget )
{
return GetOuter()->CalcIdealYaw( vecTarget );
}
float CAI_Motor::SetBoneController( int iController, float flValue )
{
return GetOuter()->SetBoneController( iController, flValue );
}
float CAI_Motor::GetSequenceMoveYaw( int iSequence )
{
return GetOuter()->GetSequenceMoveYaw( iSequence );
}
void CAI_Motor::SetPlaybackRate( float flRate )
{
return GetOuter()->SetPlaybackRate( flRate );
}
float CAI_Motor::GetPlaybackRate()
{
return GetOuter()->GetPlaybackRate();
}
float CAI_Motor::SetPoseParameter( const char *szName, float flValue )
{
return GetOuter()->SetPoseParameter( szName, flValue );
}
float CAI_Motor::GetPoseParameter( const char *szName )
{
return GetOuter()->GetPoseParameter( szName );
}
bool CAI_Motor::HasPoseParameter( int iSequence, const char *szName )
{
return GetOuter()->HasPoseParameter( iSequence, szName );
}
float CAI_Motor::SetPoseParameter( int iParameter, float flValue )
{
return GetOuter()->SetPoseParameter( iParameter, flValue );
}
bool CAI_Motor::HasPoseParameter( int iSequence, int iParameter )
{
return GetOuter()->HasPoseParameter( iSequence, iParameter );
}
void CAI_Motor::SetMoveType( MoveType_t val, MoveCollide_t moveCollide )
{
GetOuter()->SetMoveType( val, moveCollide );
}
//=============================================================================