iavoidancecomputer.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: MUBI - secondary contact: LAPA
#ifndef Navigation_IAvoidanceComputer_H
#define Navigation_IAvoidanceComputer_H

#include "gwnavruntime/math/vec3f.h"
#include "gwnavruntime/kernel/SF_RefCount.h"

namespace Kaim
{

class Bot;

enum AvoidanceResult
{
    Avoidance_NoAvoidance = 0,  
    Avoidance_SlowDown,         
    Avoidance_Accelerate,       
    Avoidance_Turn,             
    Avoidance_Stop,             
    Avoidance_SolutionNotFound, 
    Avoidance_ForcePassage,     
    Avoidance_WaitForcePassage, 
    Avoidance_NoTrajectory
};

class IAvoidanceComputer: public RefCountBase<IAvoidanceComputer, MemStat_PathFollowing>
{
    KY_CLASS_WITHOUT_COPY(IAvoidanceComputer)

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

    IAvoidanceComputer() {}

    virtual ~IAvoidanceComputer() {}

    // ---------------------------------- Pure Virtual Functions ----------------------------------
    virtual AvoidanceResult Compute(
        Bot& bot, KyFloat32 simulationTimeInSeconds, KyFloat32 desiredSpeed, const Vec2f& movingDirection,
        Vec2f& avoidanceVelocity, Vec2f& outputFrontDirection, bool& collide) = 0;

    static const char* GetAvoidanceResultString(AvoidanceResult avoidanceResult)
    {
        switch(avoidanceResult)
        {
        case Avoidance_NoAvoidance:
            return "No avoidance";
        case Avoidance_SlowDown:
            return "Slow down";
        case Avoidance_Accelerate:
            return "Accelerate";
        case Avoidance_Turn:
            return "Turn";
        case Avoidance_Stop:
            return "Stop";
        case Avoidance_SolutionNotFound:
            return "Solution not found";
        case Avoidance_ForcePassage:
            return "Forcing passage";
        case Avoidance_WaitForcePassage:
            return "Waiting for force passage";
        default:
            return "";
        };
    }

    static const char* GetAvoidanceResultDescription(AvoidanceResult avoidanceResult)
    {
        switch(avoidanceResult)
        {
        case Avoidance_NoAvoidance:
            return "The trajectory goes in target direction at the desired speed";
        case Avoidance_SlowDown:
            return "The trajectory goes in target direction but at lower speed than the desired one";
        case Avoidance_Accelerate:
            return "The trajectory goes in target direction but at higher speed than the desired one";
        case Avoidance_Turn:
            return "The trajectory deviates from target direction";
        case Avoidance_Stop:
            return "The avoidance computer decided that stopping the Bot is the best solution";
        case Avoidance_SolutionNotFound:
            return "The avoidance computer was not able to find any collision-free solutions";
        case Avoidance_ForcePassage:
            return "The bot decided to force the passage";
        case Avoidance_WaitForcePassage:
            return "The bot is required to wait for the force passage timer to expire";
        default:
            return "";
        };
    }

public: // internal
    // Used specifically by the ShortcutTrajectory in order to skip, cf. World::SetNumberOfFramesForShortcutTrajectoryPeriodicUpdate()
    virtual bool IsComputationRequiredThisFrame(Bot* /*bot*/, KyFloat32 /*simulationTimeInSeconds*/) { return true; }
};

} // namespace Kaim

#endif // Navigation_IAvoidanceComputer_H