275 lines
10 KiB
C++
275 lines
10 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
// NextBotGroundLocomotion.h
|
|
// Basic ground-based movement for NextBotCombatCharacters
|
|
// Author: Michael Booth, February 2009
|
|
// Note: This is a refactoring of ZombieBotLocomotion from L4D
|
|
|
|
#ifndef NEXT_BOT_GROUND_LOCOMOTION_H
|
|
#define NEXT_BOT_GROUND_LOCOMOTION_H
|
|
|
|
#include "NextBotLocomotionInterface.h"
|
|
#include "nav_mesh.h"
|
|
|
|
|
|
class NextBotCombatCharacter;
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* Basic ground-based movement for NextBotCombatCharacters.
|
|
* This locomotor resolves collisions and assumes a ground-based bot under the influence of gravity.
|
|
*/
|
|
class NextBotGroundLocomotion : public ILocomotion
|
|
{
|
|
public:
|
|
DECLARE_CLASS( NextBotGroundLocomotion, ILocomotion );
|
|
|
|
NextBotGroundLocomotion( INextBot *bot );
|
|
virtual ~NextBotGroundLocomotion();
|
|
|
|
virtual void Reset( void ); // reset locomotor to initial state
|
|
virtual void Update( void ); // update internal state
|
|
|
|
virtual void Approach( const Vector &pos, float goalWeight = 1.0f ); // move directly towards the given position
|
|
virtual void DriveTo( const Vector &pos ); // Move the bot to the precise given position immediately,
|
|
|
|
virtual bool ClimbUpToLedge( const Vector &landingGoal, const Vector &landingForward, const CBaseEntity *obstacle ); // initiate a jump to an adjacent high ledge, return false if climb can't start
|
|
virtual void JumpAcrossGap( const Vector &landingGoal, const Vector &landingForward ); // initiate a jump across an empty volume of space to far side
|
|
virtual void Jump( void ); // initiate a simple undirected jump in the air
|
|
virtual bool IsClimbingOrJumping( void ) const; // is jumping in any form
|
|
virtual bool IsClimbingUpToLedge( void ) const; // is climbing up to a high ledge
|
|
virtual bool IsJumpingAcrossGap( void ) const; // is jumping across a gap to the far side
|
|
|
|
virtual void Run( void ); // set desired movement speed to running
|
|
virtual void Walk( void ); // set desired movement speed to walking
|
|
virtual void Stop( void ); // set desired movement speed to stopped
|
|
virtual bool IsRunning( void ) const;
|
|
virtual void SetDesiredSpeed( float speed ); // set desired speed for locomotor movement
|
|
virtual float GetDesiredSpeed( void ) const; // returns the current desired speed
|
|
|
|
virtual float GetSpeedLimit( void ) const; // get maximum speed bot can reach, regardless of desired speed
|
|
|
|
virtual bool IsOnGround( void ) const; // return true if standing on something
|
|
virtual void OnLeaveGround( CBaseEntity *ground ); // invoked when bot leaves ground for any reason
|
|
virtual void OnLandOnGround( CBaseEntity *ground ); // invoked when bot lands on the ground after being in the air
|
|
virtual CBaseEntity *GetGround( void ) const; // return the current ground entity or NULL if not on the ground
|
|
virtual const Vector &GetGroundNormal( void ) const;// surface normal of the ground we are in contact with
|
|
|
|
virtual void ClimbLadder( const CNavLadder *ladder, const CNavArea *dismountGoal ); // climb the given ladder to the top and dismount
|
|
virtual void DescendLadder( const CNavLadder *ladder, const CNavArea *dismountGoal ); // descend the given ladder to the bottom and dismount
|
|
virtual bool IsUsingLadder( void ) const;
|
|
virtual bool IsAscendingOrDescendingLadder( void ) const; // we are actually on the ladder right now, either climbing up or down
|
|
|
|
virtual void FaceTowards( const Vector &target ); // rotate body to face towards "target"
|
|
|
|
virtual void SetDesiredLean( const QAngle &lean );
|
|
virtual const QAngle &GetDesiredLean( void ) const;
|
|
|
|
virtual const Vector &GetFeet( void ) const; // return position of "feet" - the driving point where the bot contacts the ground
|
|
|
|
virtual float GetStepHeight( void ) const; // if delta Z is greater than this, we have to jump to get up
|
|
virtual float GetMaxJumpHeight( void ) const; // return maximum height of a jump
|
|
virtual float GetDeathDropHeight( void ) const; // distance at which we will die if we fall
|
|
|
|
virtual float GetRunSpeed( void ) const; // get maximum running speed
|
|
virtual float GetWalkSpeed( void ) const; // get maximum walking speed
|
|
|
|
virtual float GetMaxAcceleration( void ) const; // return maximum acceleration of locomotor
|
|
virtual float GetMaxDeceleration( void ) const; // return maximum deceleration of locomotor
|
|
|
|
virtual const Vector &GetAcceleration( void ) const; // return current world space acceleration
|
|
virtual void SetAcceleration( const Vector &accel ); // set world space acceleration
|
|
|
|
virtual const Vector &GetVelocity( void ) const; // return current world space velocity
|
|
virtual void SetVelocity( const Vector &vel ); // set world space velocity
|
|
|
|
virtual void OnMoveToSuccess( const Path *path ); // invoked when an bot reaches its MoveTo goal
|
|
virtual void OnMoveToFailure( const Path *path, MoveToFailureType reason ); // invoked when an bot fails to reach a MoveTo goal
|
|
|
|
private:
|
|
void UpdatePosition( const Vector &newPos ); // move to newPos, resolving any collisions along the way
|
|
void UpdateGroundConstraint( void ); // keep ground solid
|
|
Vector ResolveCollisionV0( Vector from, Vector to, int recursionLimit );
|
|
|
|
Vector ResolveZombieCollisions( const Vector &pos ); // push away zombies that are interpenetrating
|
|
Vector ResolveCollision( const Vector &from, const Vector &to, int recursionLimit ); // check for collisions along move
|
|
bool DetectCollision( trace_t *pTrace, int &nDestructionAllowed, const Vector &from, const Vector &to, const Vector &vecMins, const Vector &vecMaxs );
|
|
void ApplyAccumulatedApproach( void );
|
|
bool DidJustJump( void ) const; // return true if we just started a jump
|
|
bool TraverseLadder( void ); // return true if we are climbing a ladder
|
|
|
|
virtual float GetGravity( void ) const; // return gravity force acting on bot
|
|
virtual float GetFrictionForward( void ) const; // return magnitude of forward friction
|
|
virtual float GetFrictionSideways( void ) const; // return magnitude of lateral friction
|
|
virtual float GetMaxYawRate( void ) const; // return max rate of yaw rotation
|
|
|
|
|
|
private:
|
|
NextBotCombatCharacter *m_nextBot;
|
|
|
|
Vector m_priorPos; // last update's position
|
|
Vector m_lastValidPos; // last valid position (not interpenetrating)
|
|
|
|
Vector m_acceleration;
|
|
Vector m_velocity;
|
|
|
|
float m_desiredSpeed; // speed bot wants to be moving
|
|
float m_actualSpeed; // actual speed bot is moving
|
|
|
|
float m_maxRunSpeed;
|
|
|
|
float m_forwardLean;
|
|
float m_sideLean;
|
|
QAngle m_desiredLean;
|
|
|
|
bool m_isJumping; // if true, we have jumped and have not yet hit the ground
|
|
bool m_isJumpingAcrossGap; // if true, we have jumped across a gap and have not yet hit the ground
|
|
EHANDLE m_ground; // have to manage this ourselves, since MOVETYPE_CUSTOM always NULLs out GetGroundEntity()
|
|
Vector m_groundNormal; // surface normal of the ground we are in contact with
|
|
bool m_isClimbingUpToLedge; // true if we are jumping up to an adjacent ledge
|
|
Vector m_ledgeJumpGoalPos;
|
|
bool m_isUsingFullFeetTrace; // true if we're in the air and tracing the lowest StepHeight in ResolveCollision
|
|
|
|
const CNavLadder *m_ladder; // ladder we are currently climbing/descending
|
|
const CNavArea *m_ladderDismountGoal; // the area we enter when finished with our ladder move
|
|
bool m_isGoingUpLadder; // if false, we're going down
|
|
|
|
CountdownTimer m_inhibitObstacleAvoidanceTimer; // when active, turn off path following feelers
|
|
|
|
CountdownTimer m_wiggleTimer; // for wiggling
|
|
NavRelativeDirType m_wiggleDirection;
|
|
|
|
mutable Vector m_eyePos; // for use with GetEyes(), etc.
|
|
|
|
Vector m_moveVector; // the direction of our motion in XY plane
|
|
float m_moveYaw; // global yaw of movement direction
|
|
|
|
Vector m_accumApproachVectors; // weighted sum of Approach() calls since last update
|
|
float m_accumApproachWeights;
|
|
bool m_bRecomputePostureOnCollision;
|
|
|
|
CountdownTimer m_ignorePhysicsPropTimer; // if active, don't collide with physics props (because we got stuck in one)
|
|
EHANDLE m_ignorePhysicsProp; // which prop to ignore
|
|
};
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetGravity( void ) const
|
|
{
|
|
return 1000.0f;
|
|
}
|
|
|
|
inline float NextBotGroundLocomotion::GetFrictionForward( void ) const
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
inline float NextBotGroundLocomotion::GetFrictionSideways( void ) const
|
|
{
|
|
return 3.0f;
|
|
}
|
|
|
|
inline float NextBotGroundLocomotion::GetMaxYawRate( void ) const
|
|
{
|
|
return 250.0f;
|
|
}
|
|
|
|
inline CBaseEntity *NextBotGroundLocomotion::GetGround( void ) const
|
|
{
|
|
return m_ground;
|
|
}
|
|
|
|
|
|
inline const Vector &NextBotGroundLocomotion::GetGroundNormal( void ) const
|
|
{
|
|
return m_groundNormal;
|
|
}
|
|
|
|
|
|
inline void NextBotGroundLocomotion::SetDesiredLean( const QAngle &lean )
|
|
{
|
|
m_desiredLean = lean;
|
|
}
|
|
|
|
|
|
inline const QAngle &NextBotGroundLocomotion::GetDesiredLean( void ) const
|
|
{
|
|
return m_desiredLean;
|
|
}
|
|
|
|
|
|
inline void NextBotGroundLocomotion::SetDesiredSpeed( float speed )
|
|
{
|
|
m_desiredSpeed = speed;
|
|
}
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetDesiredSpeed( void ) const
|
|
{
|
|
return m_desiredSpeed;
|
|
}
|
|
|
|
|
|
inline bool NextBotGroundLocomotion::IsClimbingOrJumping( void ) const
|
|
{
|
|
return m_isJumping;
|
|
}
|
|
|
|
inline bool NextBotGroundLocomotion::IsClimbingUpToLedge( void ) const
|
|
{
|
|
return m_isClimbingUpToLedge;
|
|
}
|
|
|
|
inline bool NextBotGroundLocomotion::IsJumpingAcrossGap( void ) const
|
|
{
|
|
return m_isJumpingAcrossGap;
|
|
}
|
|
|
|
inline bool NextBotGroundLocomotion::IsRunning( void ) const
|
|
{
|
|
/// @todo Rethink interface to distinguish actual state vs desired state (do we want to be running, or are we actually at running speed right now)
|
|
return m_actualSpeed > 0.9f * GetRunSpeed();
|
|
}
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetStepHeight( void ) const
|
|
{
|
|
return 18.0f;
|
|
}
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetMaxJumpHeight( void ) const
|
|
{
|
|
return 180.0f; // 120.0f; // 84.0f; // 58.0f;
|
|
}
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetDeathDropHeight( void ) const
|
|
{
|
|
return 200.0f;
|
|
}
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetRunSpeed( void ) const
|
|
{
|
|
return 150.0f;
|
|
}
|
|
|
|
|
|
inline float NextBotGroundLocomotion::GetWalkSpeed( void ) const
|
|
{
|
|
return 75.0f;
|
|
}
|
|
|
|
inline float NextBotGroundLocomotion::GetMaxAcceleration( void ) const
|
|
{
|
|
return 500.0f;
|
|
}
|
|
|
|
inline float NextBotGroundLocomotion::GetMaxDeceleration( void ) const
|
|
{
|
|
return 500.0f;
|
|
}
|
|
|
|
|
|
#endif // NEXT_BOT_GROUND_LOCOMOTION_H
|
|
|