bot.h

Go to the documentation of this file.

/*
* Copyright 2015 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

// primary contact: BRGR - secondary contact: LAPA
#ifndef Navigation_Bot_H
#define Navigation_Bot_H


#include "gwnavruntime/world/worldelement.h"
#include "gwnavruntime/world/botconfig.h"
#include "gwnavruntime/spatialization/spatializedcylinder.h"
#include "gwnavruntime/path/livepath.h"
#include "gwnavruntime/path/positiononlivepath.h"
#include "gwnavruntime/path/ipatheventlistobserver.h"
#include "gwnavruntime/pathfollower/ipositiononpathvalidator.h"
#include "gwnavruntime/pathfollower/avoidanceconfig.h"
#include "gwnavruntime/pathfollower/manualcontrolinterval.h"
#include "gwnavruntime/pathfollower/resettrajectorystatus.h"
#include "gwnavruntime/channel/channelsectionptr.h"
#include "gwnavruntime/world/basenavigationprofile.h"
#include "gwnavruntime/world/botneedfullcomputeflags.h"
#include "gwnavruntime/world/botmoveonnavmesh.h"
#include "gwnavruntime/world/progressonpathstatus.h"
#include "gwnavruntime/world/botvisualdebug.h"
#include "gwnavruntime/pathfollower/iavoidancecomputer.h"


namespace Kaim
{

class Database;
class BaseNavigationProfile;
class BasePathProgressComputer;
class BaseAStarQuery;
class IPathEventListObserver;
class IMovePositionOnLivePathPredicate;
class IPathFinderQuery;
class Bot;
class SplineInputBlobDumpConfig;

class BotOutput
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Bot)
    KY_CLASS_WITHOUT_COPY(BotOutput)

public: // internal
    BotOutput();
    void Reset(const Vec2f& frontDirection = Vec2f::Zero());

public:
    // --- Path status  ---

    bool IsPathRecomputationNeeded() const; // tells if a path must be recomputed
    UpperBoundType GetUpperBoundType() const; // current type of the upperBound
    PositionOnPath GetUpperBound() const; // position of the UpperBound

public:
    // --- Bot movement ---

    Vec3f m_outputVelocity; // 2d in NavMesh, 3d in OutOfNavMesh
    Vec2f m_outputFrontDirection; // normalized Vec2f

    // --- Avoidance ---

    AvoidanceResult m_avoidanceResult; // previously AvoidanceResult
    bool m_hasCollided; // did the avoidance solved a collision

public: // internal
    Bot* m_bot;
};


class BotInitConfig
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Bot)

public:
    // ---------------------------------- Public Member Functions ----------------------------------

    BotInitConfig() { SetDefaults(); }

    void SetDefaults()
    {
        m_userData = KY_NULL;
        m_database = KY_NULL;
        m_databaseBinding = KY_NULL;
        m_startFrontDirection = Vec2f::UnitX();
        m_startNewPathNavigationProfileId = 0;
    }


    // ---------------------------------- Public Data Members ----------------------------------

    void* m_userData;

    Database* m_database;

    Ptr<DatabaseBinding> m_databaseBinding;

    KyUInt32 m_startNewPathNavigationProfileId;

    Vec3f m_startPosition;
    Vec3f m_startVelocity;
    Vec2f m_startFrontDirection;
};

class Bot : public WorldElement
{
    KY_DEFINE_NEW_DELETE_OPERATORS(MemStat_Bot)
    KY_CLASS_WITHOUT_COPY(Bot)

public:
    static  WorldElementType GetStaticType() { return TypeBot; }
    virtual WorldElementType GetType() const { return TypeBot; }

    virtual const char* GetTypeName() const { return "Bot"; }

    // ---------------------------------- Initialization / Clearing ----------------------------------

    Bot();

    Bot(const BotInitConfig& initConfig);

    Bot(const BotInitConfig& initConfig, const BotConfig& botConfig);

    virtual ~Bot();

    void Init(const BotInitConfig& initConfig);

    void Init(const BotInitConfig& initConfig, const BotConfig& botConfig);

    void Clear();

    void AddToDatabase();

    void RemoveFromDatabase();


    // ---------------------------------- BotInput ----------------------------------

    void SetPosition(const Vec3f& position);
    
    void SetVelocity(const Vec3f& velocity);
    
    void SetFrontDirection(const Vec2f& frontDirection);

    void SetPositionAndVelocityAndFrontDirection(const Vec3f& position, KyFloat32 simulationTimeInSeconds);
    
    void SetPositionAndVelocity(const Vec3f& position, KyFloat32 simulationTimeInSeconds);
    
    void SetVelocityAndFrontDirection(const Vec3f& velocity);

    // ---------------------------------- BotOutput ----------------------------------
    
    const BotOutput& GetBotOutput() const;


    // ---------------------------------- Getters ----------------------------------

    const Vec3f&                GetPosition()                 const; 
    const Vec2f&                GetFrontDirection()           const; 
    const Vec3f&                GetVelocity()                 const; 
    
    const SpatializedCylinder&  GetSpatializedCylinder()      const; 

    const Vec3f&                GetPreviousPosition()         const; 

    NavTrianglePtr              GetNavTrianglePtr()           const; 
    const ChannelSectionPtr&    GetChannelSectionPtr()        const;

    Database*                   GetDatabase()                 const;
    IPathFinderQuery*           GetPathFinderQuery();
    BasePathProgressComputer*   GetPathProgressComputer()     const;
    Trajectory*                 GetTrajectory()               const;

    const PositionOnLivePath&   GetProgressOnLivePath()       const;
    ProgressOnPathStatus        GetProgressOnLivePathStatus() const;
    static const char*          GetProgressOnLivePathStatusDescription(ProgressOnPathStatus status);
    
    KyFloat32 GetRemainingDistanceFromProgressToEndOfPath() const;

    const BotConfig& GetConfig() const;

    // ---------------------------------- Bot Shape Config ----------------------------------

    void SetRadius(KyFloat32 radius);
    KyFloat32 GetRadius() const;

    void SetHeight(KyFloat32 height);
    KyFloat32 GetHeight() const;

    // ---------------------------------- Trajectory Mode ----------------------------------

    void SetTrajectoryMode(TrajectoryMode trajectoryMode);
    TrajectoryMode GetTrajectoryMode() const;
    
    // ---------------------------------- PathFind Config ----------------------------------

    void SetPathFinderConfig(const PathFinderConfig& pathFinderConfig);
    const PathFinderConfig& GetPathFinderConfig() const;

    void SetChannelComputerConfig(const ChannelComputerConfig& channelComputerConfig);
    const ChannelComputerConfig& GetChannelComputerConfigConfig() const;

    // ---------------------------------- Path Progress Config ----------------------------------

    void SetPathProgressConfig(const PathProgressConfig& pathProgressConfig);
    const PathProgressConfig& GetPathProgressConfig() const;

    // ---------------------------------- Trajectory Config ----------------------------------

    void SetMaxDesiredLinearSpeed(KyFloat32 maxDesiredLinearSpeed);
    KyFloat32 GetMaxDesiredLinearSpeed() const;

    void SetTrajectoryFailureMode(TrajectoryFailureMode trajectoryFailureMode);
    TrajectoryFailureMode GetTrajectoryFailureMode() const;

    void SetShortcutTrajectoryConfig(const ShortcutTrajectoryConfig& shortcutTrajectoryConfig);
    const ShortcutTrajectoryConfig& GetShortcutTrajectoryConfig() const;

    void SetSplineTrajectoryConfig(const SplineTrajectoryConfig& splineTrajectoryConfig);
    const SplineTrajectoryConfig& GetSplineTrajectoryConfig() const;

    // ---------------------------------- Trajectory Avoidance ----------------------------------

    void SetEnableAvoidance(bool enable);
    bool GetEnableAvoidance() const;

    void SetColliderCollectorConfig(const ColliderCollectorConfig& colliderCollectorConfig);
    const ColliderCollectorConfig& GetColliderCollectorConfig() const;

    void SetAvoidanceConfig(const AvoidanceConfig& avoidanceConfig);
    const AvoidanceConfig& GetAvoidanceConfig() const;

    // ---------------------------------- Advanced Config ----------------------------------

    void SetTrajectoryMinimalMoveDistance(KyFloat32 trajectoryMinimalMoveDistance);
    KyFloat32 GetTrajectoryMinimalMoveDistance() const;

    void SetLocalCostOnPathDistance(KyFloat32 localCostOnPathDistance);
    KyFloat32 GetLocalCostOnPathDistance() const;


    // ---------------------------------- Basic PathFinding functions ----------------------------------

    void SetNewPathNavigationProfileId(KyUInt32 navigationProfileId);
    KyUInt32 GetNewPathNavigationProfileId() const;

    KyResult ComputeNewPathToDestination(const Vec3f& destPos);
    KyResult ComputeNewPathToDestination(const Vec3f& destPos, const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode = NAVGRAPHEDGE_BIDIRECTIONAL);


    // ---------------------------------- Advanced PathFinding functions ----------------------------------

    KyResult InitAStarQueryForBot(Ptr<BaseAStarQuery>& astarQuery, const Vec3f& destPos);

    KyResult InitAStarQueryForBot(Ptr<BaseAStarQuery>& astarQuery, const Vec3f& destPos,
        const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode = NAVGRAPHEDGE_BIDIRECTIONAL);

    BaseNavigationProfile* GetFollowedPathNavigationProfile();

    void* GetBotTraverseLogicUserData() const;
    void SetBotTraverseLogicUserData(void* traverseLogicUserData);

    void ComputeNewPathAsync(IPathFinderQuery* pathFinderQuery);

    void InjectNewPath(Path* newPath);

    void CancelAsyncPathComputation();

    bool IsComputingNewPath() const;


    // ---------------------------------- LivePath Management ----------------------------------

    const LivePath&             GetLivePath()             const;
    const PathEventList&        GetPathEventList()        const;
    const PathValidityInterval& GetPathValidityInterval() const;
    Path*                       GetFollowedPath()         const;
    PathSource                  GetFollowedPathSource()   const;
    ChannelArray*               GetChannelArray()         const;

    void ClearFollowedPath();

    const PositionOnPath* GetUpcomingEventPositionOnPath() const;

    const NavTag* GetUpcomingEventNavTag() const;

    const NavTag* GetPreviousEventNavTag() const;


    // ---------------------------------- Path Following ----------------------------------

    bool HasReachedPosition(const Vec3f& position, KyFloat32 precisionRadius) const;

    void SetDoComputeProgressOnPath(bool doUpdateProgressOnPath);
    bool GetDoComputeProgressOnPath() const;
    
    void SetDoValidateCheckPoint(bool doValidateCheckPoint);
    bool GetDoValidateCheckPoint() const;
    
    void SetDoComputeTrajectory(bool doComputeTrajectory);
    bool GetDoComputeTrajectory() const;
    void ForceRecomputeTrajectory();


    Vec3f ComputeMoveOnNavMesh(const Kaim::Vec3f& velocity, KyFloat32 simulationTimeInSeconds);

    template<class TraverseLogic>
    Vec3f ComputeMoveOnNavMeshWithTraverseLogic(const Kaim::Vec3f& velocity, KyFloat32 simulationTimeInSeconds);
    
    // ---------------------------------- Manual Control helper ----------------------------------
    
    ManualControlStatus EnterManualControl();

    ManualControlStatus EnterManualControl(const NavTag* navTag);
    ManualControlStatus EnterManualControl(const DynamicNavTag* navTag);

    ResetTrajectoryStatus ExitManualControl();

    void SetForceMinimizedSpatializationCoherency(bool forceMinimalCoherency);
    bool GetForceMinimizedSpatializationCoherency() const;

public: // internal
    // Main function of the Bot. Called for each bot in World::Update() every frame
    void UpdatePathFollowing(KyFloat32 simulationTimeInSeconds);
    
    void ComputeTrajectory(KyFloat32 simulationTimeInSeconds);

    // Tests if the trajectory can be reset from the given positionOnLivePath, if possible set m_progressOnLivePath to positionOnLivePath
    // Called internally by ExitManualControl
    ResetTrajectoryStatus ResetTrajectory(const PositionOnLivePath& positionOnLivePath);

    virtual void DoSendVisualDebug(VisualDebugServer& server, VisualDebugSendChangeEvent changeEvent); // Inherited from WorldElement

    // Bot spatialization through its SpatializedCylinder, must only be called into World::Update
    void UpdateSpatialization();

    // LivePath management
    LivePath& GetLivePath();
    PathEventList& GetPathEventList();
    void FlagPathAsPotentiallyDirty(); // Called in EventBroadcaster to trigger a path validity check after NavData has changed

    void ComputeBotRadiusAndHeight();

    NavTrianglePtr GetNavTrianglePtr(Database* boundDatabase) const; // return the triangle corresponding to m_position in the given Database, this database must be one of the DatabaseBinding, this function can imply a lazy update

public: // KY_DEPRECATED
    KY_DEPRECATED(void SetDoMaximizeSpatializationCoherency(bool maximizeCoherency)) { SetForceMinimizedSpatializationCoherency(!maximizeCoherency); } // Minimize better reflect what it does
    KY_DEPRECATED(bool GetDoMaximizeSpatializationCoherency()) { return !GetForceMinimizedSpatializationCoherency(); } // Minimize better reflect what it does

private:
    void SetDefaults();
    void ResetPathFindingAndFollowingStates();
    void SetupBotRadiusCappedToGenerationMetrics();
    void SetupBotHeightCappedToGenerationMetrics();
    void SendPathFinderErrorDisplayList();
    void ReplaceFollowedPathWithNewPath();
    void SetTrajectory(Trajectory* trajectory);
    
    SpatializationUpdateCoherency GetSpatializationUpdateCoherency() const;
    PointSpatialization& GetPositionSpatialization() const; // can imply a lazy update of m_positionSpatialization and m_botNeedFullComputeFlags 

    // If ShortcutTrajectory is in use it allows to skip some PathFollowing computations on several frames.
    // cf. World::SetNumberOfFramesForShortcutTrajectoryPeriodicUpdate()
    bool IsShortcutTrajectoryAllowingToSkipPathFollowingThisFrame(KyFloat32& simulationTimeInSecondsToApplyThisFrame);

public: // internal
    Database* m_database;
    void* m_traverseLogicUserData;

    Ptr<IPathFinderQuery> m_pathFinderQuery;

    // current navigation components
    Ptr<BasePathProgressComputer> m_pathProgressComputer;
    Ptr<Trajectory>               m_trajectory;

    // Members relative to Path and Spatialization.
    LivePath m_livePath;    // Maintain Path and runtime information such as its validity
    SpatializedCylinder m_spatializedCylinder;    // Spatialization of the bot in Databases, contains position, velocity and navTriganle at last World::Update()
    ChannelSectionPtr m_positionInChannel;        // Position of the bot in ChannelArray
    PositionOnLivePath m_progressOnLivePath;      // Progress of the bot along the path so far, it never goes backward on the path
    ProgressOnPathStatus m_progressOnPathStatus;  // Status relative to m_progressOnLivePath
    Vec3f m_previousPosition; // Position passed the previous frame. Used for arrival and checkpoint validation.
    ManualControlInterval m_manualControlInterval;
    KyFloat32 m_localMaxCostMultiplierOnPath; // Used by LocalCostAwarTraverseLogic

    // position, velocity and direction provided by user to be applied on SpatializedCylinder in next World::Update
    Vec3f m_position;       // user input position
    Vec3f m_velocity;       // user input velocity
    Vec2f m_frontDirection; // user input frontDirection

    // output position, velocity and direction recommended by Navigation to be applied after World::Update call
    BotOutput m_botOutput;

    // NavigationProfiles
    KyUInt32 m_newPathToDestNavigationProfileId;
    BotNavigationCollection m_botNavigationCollection; // the per-Bot per-NavigationProfile data

    // flags to force recompute on next Update
    mutable BotNeedFullComputeFlags m_botNeedFullComputeFlags;

    // ColliderCollector per bot data
    Vec3f m_lastCollectorPosition;
    Ptr<QueryDynamicOutput> m_collectorOutput;
    
    KyFloat32 m_forcePassageTimer; // for internal use, negative value indicates the passage is being forced, positive value indicates when waiting, 0 otherwise
    KyFloat32 m_colliderTimer; // Increase when colliding, decrease when not, never negative

private:
    Ptr<BotConfig> m_botConfig;

    bool m_forceMinimizedSpatializationCoherency;
    // NavTriangle based on user input position i.e. the NavTriangle for m_position which can differ from m_spatializedCylinder,
    // also note that m_spatializedCylinder is referenced into NavFloor whereas m_positionSpatialization is not!
    mutable PointSpatialization m_positionSpatialization; 

    bool m_doComputeProgressOnPath;
    bool m_doValidateCheckPoint;
    bool m_doComputeTrajectory;

    // VisualDebug
    BotVisualDebug m_visualDebug;

public: // debug
    Ptr<SplineInputBlobDumpConfig> m_advancedDebug_InputBlobDumpConfig;
};

} // namespace Kaim

#include "gwnavruntime/world/bot.inl"

#endif // Navigation_Bot_H