bot.h

Go to the documentation of this file.

/*
* Copyright 2016 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.
*/

#pragma once

#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"
#include "gwnavruntime/dynamicnavmesh/tagvolumetrigger.h"

namespace Kaim
{

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

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:
    // ------------------------------ Functions -----------------------------

    BotInitConfig() { SetDefaults(); }

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

        m_blockingNavTag.Clear();
        m_blockingNavTag.SetAsExclusive();
    }


    // ---------------------------------- 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;

    DynamicNavTag m_blockingNavTag;
};

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 { return m_botOutput; } 


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

    const Vec3f& GetPosition()       const { return m_position; }       
    const Vec2f& GetFrontDirection() const { return m_frontDirection; } 
    const Vec3f& GetVelocity()       const { return m_velocity; }       

    const SpatializedCylinder& GetSpatializedCylinder() const { return m_spatializedCylinder; } 

    // This can be used to achieve much more precise arrival detection and check point validation.
    const Vec3f& GetPreviousPosition() const { return m_previousPosition; }

    NavTrianglePtr GetNavTrianglePtr() const { return GetNavTrianglePtr(m_database); } 
    const ChannelSectionPtr& GetChannelSectionPtr() const { return m_positionInChannel; }

    Database* GetDatabase() const { return m_database; }
    IPathFinderQuery* GetPathFinderQuery() { return m_pathFinderQuery; }
    BasePathProgressComputer* GetPathProgressComputer() const { return m_pathProgressComputer; }
    Trajectory* GetTrajectory() const { return m_trajectory; }

    const PositionOnLivePath& GetProgressOnLivePath() const { return m_progressOnLivePath; }
    ProgressOnPathStatus GetProgressOnLivePathStatus() const { return m_progressOnPathStatus; }
    static const char* GetProgressOnLivePathStatusDescription(ProgressOnPathStatus status);

    KyFloat32 GetRemainingDistanceFromProgressToEndOfPath() const;

    const BotConfig& GetConfig() const { return *m_botConfig; }

    DisplayListManager* GetDisplayListManager() const;

    VisualDebugServer* GetVisualDebugServer() const;

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

    void SetRadius(KyFloat32 radius);
    KyFloat32 GetRadius() const { return m_botConfig->m_radius; }

    void SetHeight(KyFloat32 height);
    KyFloat32 GetHeight() const { return m_botConfig->m_height; }

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

    void SetTrajectoryMode(TrajectoryMode trajectoryMode);
    TrajectoryMode GetTrajectoryMode() const { return m_botConfig->m_trajectoryMode; }

    // ---------------------------------- PathFind Config ----------------------------------

    void SetPathFinderConfig(const PathFinderConfig& pathFinderConfig);
    const PathFinderConfig& GetPathFinderConfig() const { return m_botConfig->m_pathFinderConfig; }

    void SetChannelComputerConfig(const ChannelComputerConfig& channelComputerConfig);
    const ChannelComputerConfig& GetChannelComputerConfig() const { return m_botConfig->m_channelComputerConfig; }

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

    void SetPathProgressConfig(const PathProgressConfig& pathProgressConfig);
    const PathProgressConfig& GetPathProgressConfig() const { return m_botConfig->m_pathProgressConfig; }

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

    void SetMaxDesiredLinearSpeed(KyFloat32 maxDesiredLinearSpeed);
    KyFloat32 GetMaxDesiredLinearSpeed() const { return m_botConfig->m_maxDesiredLinearSpeed; }

    void SetTrajectoryFailureMode(TrajectoryFailureMode trajectoryFailureMode);
    TrajectoryFailureMode GetTrajectoryFailureMode() const { return m_botConfig->m_trajectoryFailureMode; }

    void SetShortcutTrajectoryConfig(const ShortcutTrajectoryConfig& shortcutTrajectoryConfig);
    const ShortcutTrajectoryConfig& GetShortcutTrajectoryConfig() const { return m_botConfig->m_shortcutTrajectoryConfig; }

    void SetSplineTrajectoryConfig(const SplineTrajectoryConfig& splineTrajectoryConfig);
    const SplineTrajectoryConfig& GetSplineTrajectoryConfig() const { return m_botConfig->m_splineTrajectoryConfig; }

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

    void SetEnableAvoidance(bool enable);
    bool GetEnableAvoidance() const { return m_botConfig->m_enableAvoidance; }

    void SetColliderCollectorConfig(const ColliderCollectorConfig& colliderCollectorConfig);
    const ColliderCollectorConfig& GetColliderCollectorConfig() const { return m_botConfig->m_colliderCollectorConfig; }

    void SetAvoidanceConfig(const AvoidanceConfig& avoidanceConfig);
    const AvoidanceConfig& GetAvoidanceConfig() const { return m_botConfig->m_avoidanceConfig; }

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

    void SetTrajectoryMinimalMoveDistance(KyFloat32 trajectoryMinimalMoveDistance);
    KyFloat32 GetTrajectoryMinimalMoveDistance() const { return m_botConfig->m_trajectoryMinimalMoveDistance; }

    void SetLocalMaxCostMultiplierOnPathDistance(KyFloat32 localMaxCostMultiplierOnPathDistance);
    KyFloat32 GetLocalMaxCostMultiplierOnPathDistance() const { return m_botConfig->m_pathProgressConfig.m_advancedConfig.m_localMaxCostMultiplierOnPathDistance; }


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

    void SetNewPathNavigationProfileId(KyUInt32 navigationProfileId) { m_newPathToDestNavigationProfileId = navigationProfileId; }
    KyUInt32 GetNewPathNavigationProfileId() const { return m_newPathToDestNavigationProfileId; }

    KyResult ComputeAStarQueryAsync(const Vec3f& destPos, const PathFinderConfig* pathFinderConfig = nullptr);
    KyResult ComputeAStarQueryAsync(const Vec3f& destPos, const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode = NAVGRAPHEDGE_BIDIRECTIONAL,
                                    const PathFinderConfig* pathFinderConfig = nullptr);

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

    Ptr<BaseAStarQuery> GetAStarQuery() { return m_botNavigationCollection.GetOrCreateAStarQuery(m_newPathToDestNavigationProfileId); }

    KyResult InitAStarQuery(Ptr<BaseAStarQuery>& astarQuery, const Vec3f& destPos, const PathFinderConfig* pathFinderConfig = nullptr);

    KyResult InitAStarQuery(Ptr<BaseAStarQuery>& astarQuery, const Vec3f& destPos,
        const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode = NAVGRAPHEDGE_BIDIRECTIONAL,
        const PathFinderConfig* pathFinderConfig = nullptr);

    KyResult ComputePathAsync(IPathFinderQuery* pathFinderQuery);

    KyResult InjectPath(Path* newPath);

    void CancelComputePathAsync() { m_livePath.CancelAsyncPathComputation(); }

    bool IsComputingPath() const { return m_livePath.IsComputingNewPath(); }

    BaseNavigationProfile* GetFollowedPathNavigationProfile();

    void* GetBotTraverseLogicUserData() const { return m_traverseLogicUserData; }
    void SetBotTraverseLogicUserData(void* traverseLogicUserData) { m_traverseLogicUserData = traverseLogicUserData; }

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

    const LivePath&             GetLivePath()             const { return m_livePath; }
    const PathEventList&        GetPathEventList()        const { return m_livePath.GetPathEventList(); }
    const PathValidityInterval& GetPathValidityInterval() const { return m_livePath.m_validityInterval; }
    Path*                       GetFollowedPath()         const { return m_livePath.GetFollowedPath(); }
    PathSource                  GetFollowedPathSource()   const { return m_livePath.GetFollowedPathSource(); }
    ChannelArray*               GetChannelArray()         const { return m_livePath.GetChannelArray(); }

    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 { return m_doComputeProgressOnPath; }

    void SetDoValidateCheckPoint(bool doValidateCheckPoint);
    bool GetDoValidateCheckPoint() const { return m_doValidateCheckPoint; }

    void SetDoComputeTrajectory(bool doComputeTrajectory);
    bool GetDoComputeTrajectory() const { return m_doComputeTrajectory; }
    void ForceRecomputeTrajectory();

    void SetBlocking(bool isBlocking);
    bool IsBlocking() const; 

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

    template<class TraverseLogic>
    Vec3f ComputeMoveOnNavMeshWithTraverseLogic(const Vec3f& velocity, KyFloat32 simulationTimeInSeconds);

    // ---------------------------------- Manual Control helper ----------------------------------

    ManualControlStatus EnterManualControl();

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

    ResetTrajectoryStatus ExitManualControl();

    void SetForceMinimizedSpatializationCoherency(bool forceMinimizeCoherency) { m_forceMinimizedSpatializationCoherency = forceMinimizeCoherency; }
    bool GetForceMinimizedSpatializationCoherency() const { return m_forceMinimizedSpatializationCoherency; }

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();

    void SetupTagVolumeInitConfig(TagVolumeInitConfig& tagVolumeInitConfig);
    void OnTagVolumeIntegration();
    void OnTagVolumeDeIntegration();

    DatabaseBinding* GetDatabaseBinding();

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

    void ComputeBotRadiusAndHeight();

    // 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
    NavTrianglePtr GetNavTrianglePtr(Database* boundDatabase) const;

public:
    // KY_DEPRECATED since 2.17.0
    KY_DEPRECATED(const ChannelComputerConfig& GetChannelComputerConfigConfig() const) { return GetChannelComputerConfig(); } // Renamed
    KY_DEPRECATED(KyResult InitAStarQueryForBot(Ptr<BaseAStarQuery>& astarQuery, const Vec3f& destPos, const PathFinderConfig* pathFinderConfig = nullptr)) { return InitAStarQuery(astarQuery, destPos, pathFinderConfig); }
    KY_DEPRECATED(KyResult InitAStarQueryForBot(Ptr<BaseAStarQuery>& astarQuery, const Vec3f& destPos, const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode = NAVGRAPHEDGE_BIDIRECTIONAL, const PathFinderConfig* pathFinderConfig = nullptr)) { return InitAStarQuery(astarQuery, destPos, startNavGraphEdgePtr, navGraphEdgePathfindMode, pathFinderConfig); }
    KY_DEPRECATED(KyResult ComputeNewPathToDestination(const Vec3f& destPos, const PathFinderConfig* pathFinderConfig = nullptr)) { return ComputeAStarQueryAsync(destPos, pathFinderConfig); }
    KY_DEPRECATED(KyResult ComputeNewPathToDestination(const Vec3f& destPos, const NavGraphEdgePtr& startNavGraphEdgePtr, NavGraphEdgeDirection navGraphEdgePathfindMode = NAVGRAPHEDGE_BIDIRECTIONAL, const PathFinderConfig* pathFinderConfig = nullptr)) { return ComputeAStarQueryAsync(destPos, startNavGraphEdgePtr, navGraphEdgePathfindMode, pathFinderConfig); }
    KY_DEPRECATED(KyResult ComputeNewPathAsync(IPathFinderQuery* pathFinderQuery)); // Beware this behaves differently from ComputePathAsync which now cancels a computing query.
    KY_DEPRECATED(void CancelAsyncPathComputation()) { CancelComputePathAsync(); } // Renamed
    KY_DEPRECATED(KyResult InjectNewPath(Path* newPath)); // Beware this behaves differently from InjectPath which now cancels a computing query.
    KY_DEPRECATED(bool CanAcceptNewPathComputation()) { return CanAcceptNewPath(); } // Renamed since it concerns Computing or injecting a new path
    KY_DEPRECATED(bool IsComputingNewPath() const) { return IsComputingPath(); } // Renamed

private:
    void SetDefaults();

    // check if new path computation and or injection can be accepted and raise flags accordingly.
    bool CanAcceptNewPath();
    void ClearPathFindingAndFollowingStates();
    void SetupBotRadiusCappedToGenerationMetrics();
    void SetupBotHeightCappedToGenerationMetrics();
    void SendPathFinderErrorDisplayList();
    void ReplaceFollowedPathWithNewPath();
    void SetTrajectory(Trajectory* trajectory);
    void DoClearFollowedPath(IPathEventListObserver::DestructionPurpose);

    SpatializationUpdateCoherency GetSpatializationUpdateCoherency() const;
    void UpdateBotPositionSpatializationButNotFloors() const;

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 navTriangle 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;

    // NavTriangles (per bound database) 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_isBlocking;
    DynamicNavTag m_blockingNavTag;
    TagVolumeTrigger<Bot> m_tagVolumeTrigger;

    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"