254 lines
9.1 KiB
C++
254 lines
9.1 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef AI_MOTOR_H
|
|
#define AI_MOTOR_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "AI_Interest_Target.h"
|
|
#include "ai_component.h"
|
|
#include "ai_movetypes.h"
|
|
#include "ai_navtype.h"
|
|
#include "simtimer.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
enum Navigation_t;
|
|
class CAI_PlaneSolver;
|
|
class CAI_MoveProbe;
|
|
class CAI_Navigator;
|
|
|
|
#define AI_CALC_YAW_SPEED -1
|
|
#define AI_KEEP_YAW_SPEED -2
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
float AI_ClampYaw(float yawSpeedPerSec, float current, float target,
|
|
float time);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CAI_Motor
|
|
//
|
|
// Purpose: Implements the primitive locomotion of AIs.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CAI_Motor : public CAI_Component, public CAI_ProxyMovementSink {
|
|
public:
|
|
CAI_Motor(CAI_BaseNPC *pOuter);
|
|
virtual ~CAI_Motor();
|
|
|
|
void Init(IAI_MovementSink *pMovementServices);
|
|
|
|
// --------------------------------
|
|
// The current timestep the motor is working on
|
|
// --------------------------------
|
|
float GetMoveInterval() { return m_flMoveInterval; }
|
|
float SetMoveInterval(float flInterval) {
|
|
return (m_flMoveInterval = flInterval);
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// Translational movement
|
|
// ----------------------------------------------------
|
|
AIMoveResult_t MoveNormalExecute(const AILocalMoveGoal_t &move);
|
|
|
|
virtual void MoveClimbStart(const Vector &climbDest, const Vector &climbDir,
|
|
float climbDist, float yaw);
|
|
virtual AIMoveResult_t MoveClimbExecute(const Vector &climbDest,
|
|
const Vector &climbDir,
|
|
float climbDist, float yaw,
|
|
int climbNodesLeft);
|
|
virtual void MoveClimbStop();
|
|
|
|
//---------------------------------
|
|
|
|
virtual void MoveJumpStart(const Vector &velocity);
|
|
virtual int MoveJumpExecute();
|
|
virtual AIMoveResult_t MoveJumpStop();
|
|
|
|
virtual void ResetMoveCalculations();
|
|
virtual void MoveStart();
|
|
virtual void MoveStop();
|
|
virtual void MovePaused();
|
|
|
|
//---------------------------------
|
|
|
|
float GetIdealSpeed() const;
|
|
float GetIdealAccel() const;
|
|
float GetCurSpeed() const { return m_vecVelocity.Length(); }
|
|
const Vector &GetCurVel() const { return m_vecVelocity; }
|
|
|
|
virtual float OverrideMaxYawSpeed(Activity activity) { return -1; }
|
|
bool IsDeceleratingToGoal() const { return false; }
|
|
|
|
//---------------------------------
|
|
// Raw ground step forward to the specifed position
|
|
//
|
|
|
|
AIMotorMoveResult_t MoveGroundStep(const Vector &newPos,
|
|
CBaseEntity *pMoveTarget = NULL,
|
|
float yaw = -1, bool bAsFarAsCan = true,
|
|
bool bTestZ = true,
|
|
AIMoveTrace_t *pTraceResult = NULL);
|
|
|
|
// ----------------------------------------------------
|
|
// Rotational movement (yaw); goal and speed
|
|
// ----------------------------------------------------
|
|
|
|
void SetYawSpeed(float yawSpeed) { m_YawSpeed = yawSpeed; }
|
|
float GetYawSpeed() const { return m_YawSpeed; }
|
|
float GetIdealYaw() const { return m_IdealYaw; }
|
|
void SetIdealYaw(float idealYaw) { m_IdealYaw = idealYaw; }
|
|
|
|
// Set ideal yaw specified as a vector
|
|
void SetIdealYaw(const Vector &vecFacing) {
|
|
SetIdealYaw(UTIL_VecToYaw(vecFacing));
|
|
}
|
|
|
|
// Set ideal yaw based on a specified target
|
|
void SetIdealYawToTarget(const Vector &target, float noise = 0.0,
|
|
float offset = 0.0);
|
|
|
|
// Set the ideal yaw and run the current or specified timestep worth of
|
|
// rotation. Note it is not correct to call any "update" variant of these
|
|
// methods more than once per think cycle
|
|
void SetIdealYawAndUpdate(float idealYaw,
|
|
float yawSpeed = AI_CALC_YAW_SPEED);
|
|
void SetIdealYawAndUpdate(const Vector &vecFacing,
|
|
float yawSpeed = AI_CALC_YAW_SPEED) {
|
|
SetIdealYawAndUpdate(UTIL_VecToYaw(vecFacing), yawSpeed);
|
|
}
|
|
void SetIdealYawToTargetAndUpdate(const Vector &target,
|
|
float yawSpeed = AI_CALC_YAW_SPEED);
|
|
|
|
// Add multiple facing goals while moving/standing still.
|
|
virtual void AddFacingTarget(CBaseEntity *pTarget, float flImportance,
|
|
float flDuration, float flRamp = 0.0);
|
|
virtual void AddFacingTarget(const Vector &vecPosition, float flImportance,
|
|
float flDuration, float flRamp = 0.0);
|
|
virtual void AddFacingTarget(CBaseEntity *pTarget,
|
|
const Vector &vecPosition, float flImportance,
|
|
float flDuration, float flRamp = 0.0);
|
|
virtual float GetFacingDirection(Vector &vecDir);
|
|
|
|
// Force the heading to the ideal yaw
|
|
void SnapYaw() { UpdateYaw(360); }
|
|
|
|
// Run the current or specified timestep worth of rotation
|
|
virtual void UpdateYaw(int speed = -1);
|
|
|
|
//
|
|
virtual void RecalculateYawSpeed();
|
|
|
|
// Returns the difference ( in degrees ) between npc's current yaw and
|
|
// ideal_yaw
|
|
float DeltaIdealYaw();
|
|
|
|
// Issues turn gestures when needed due to turning
|
|
virtual void MaintainTurnActivity(void){};
|
|
virtual bool AddTurnGesture(float flYD) { return false; };
|
|
|
|
// --------------------------------
|
|
// Move primitives
|
|
// --------------------------------
|
|
virtual float MinStoppingDist(
|
|
float flMinResult =
|
|
10.0); // how far before I can come to a complete stop?
|
|
virtual float MinCheckDist(); // how far should I look ahead in my route?
|
|
|
|
//---------------------------------
|
|
|
|
CAI_Navigator *GetNavigator(void);
|
|
int SelectWeightedSequence(Activity activity);
|
|
float GetSequenceGroundSpeed(int iSequence);
|
|
|
|
float CalcIntervalMove();
|
|
|
|
// Yaw locking
|
|
bool IsYawLocked(void) const { return m_bYawLocked; }
|
|
void SetYawLocked(bool state) { m_bYawLocked = state; }
|
|
|
|
protected:
|
|
//
|
|
// Common services provided by CAI_BaseNPC, Convenience methods to simplify
|
|
// derived code
|
|
//
|
|
CAI_MoveProbe *GetMoveProbe() { return m_pMoveProbe; }
|
|
void SetSmoothedVelocity(const Vector &vecVelocity);
|
|
Vector GetSmoothedVelocity();
|
|
float CalcIdealYaw(const Vector &vecTarget);
|
|
float SetBoneController(int iController, float flValue);
|
|
float GetSequenceMoveYaw(int iSequence);
|
|
void SetPlaybackRate(float flRate);
|
|
float GetPlaybackRate(); // get
|
|
float SetPoseParameter(const char *szName, float flValue);
|
|
float SetPoseParameter(int iParameter, float flValue);
|
|
float GetPoseParameter(const char *szName);
|
|
bool HasPoseParameter(int iSequence, const char *szName);
|
|
bool HasPoseParameter(int iSequence, int iParameter);
|
|
void SetMoveType(MoveType_t val,
|
|
MoveCollide_t moveCollide = MOVECOLLIDE_DEFAULT);
|
|
float StepHeight() const;
|
|
bool CanStandOn(CBaseEntity *pSurface) const;
|
|
|
|
// ----------------------------------------------------
|
|
// Primitives
|
|
// ----------------------------------------------------
|
|
|
|
virtual void MoveFacing(const AILocalMoveGoal_t &move);
|
|
|
|
virtual AIMotorMoveResult_t MoveGroundExecute(const AILocalMoveGoal_t &move,
|
|
AIMoveTrace_t *pTraceResult);
|
|
AIMotorMoveResult_t MoveGroundExecuteWalk(const AILocalMoveGoal_t &move,
|
|
float speed, float dist,
|
|
AIMoveTrace_t *pTraceResult);
|
|
virtual AIMotorMoveResult_t MoveFlyExecute(const AILocalMoveGoal_t &move,
|
|
AIMoveTrace_t *pTraceResult);
|
|
|
|
protected: // made protected while animation transition details worked out,
|
|
// private:
|
|
// --------------------------------
|
|
void SetMoveVel(const Vector &velocity) { m_vecVelocity = velocity; }
|
|
float IdealVelocity(); // how fast should I be moving in an ideal state?
|
|
|
|
// --------------------------------
|
|
float m_flMoveInterval;
|
|
|
|
float m_IdealYaw;
|
|
float m_YawSpeed;
|
|
|
|
Vector m_vecVelocity;
|
|
Vector m_vecAngularVelocity;
|
|
|
|
// --------------------------------
|
|
|
|
int m_nDismountSequence;
|
|
Vector m_vecDismount;
|
|
|
|
// --------------------------------
|
|
|
|
CAI_InterestTarget m_facingQueue;
|
|
|
|
// --------------------------------
|
|
|
|
CAI_MoveProbe *m_pMoveProbe;
|
|
|
|
bool m_bYawLocked;
|
|
|
|
//---------------------------------
|
|
public:
|
|
DECLARE_SIMPLE_DATADESC();
|
|
};
|
|
|
|
//=============================================================================
|
|
|
|
#endif // AI_MOTOR_H
|