modFollowAgent.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2012 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include <vrfutil/soilFactors.h>

#include <bhaveSim/bhaveSimDefines.h>
#include <kyruntime.h>

#include <kyruntime/pathfinding/pathfinder.h>


namespace Kaim
{

class ActionTorsoRotate;
class PointLockManager;


class DT_DLL_bhaveSim modFollowAgent
{
   KY_DEFINE_NEW_DELETE_OPERATORS

   /* The modFollowAgent creates and initializes an instance of this class to ensure that any Body that is removed 
      from the World is also un-registered from the modFollowAgent if it is the current Leader of the modFollowAgent.
      \ingroup kyruntime_agents */
   class WorldObserver : public IWorldObserver
   {
   public:
      /* Default constructor. */
      WorldObserver() : m_followAgent(KY_NULL) {}

      /* Sets up the WorldObserver for use. 
         \param modFollowAgent      The instance of the modFollowAgent whose Leader will be updated. */
      void Initialize(modFollowAgent& followAgent) { m_followAgent = &followAgent; }

      virtual void OnActivateBody(Body& ) {}
      /* This implementation of IWorldObserver::OnActivateBody() tests each Body removed from the World to see if
         it matches the Leader Body of the modFollowAgent. If it is, the Leader Body of the modFollowAgent is reset to #KY_NULL. */
      virtual void OnDeactivateBody(Body& body)
      {
         if (m_followAgent->GetLeader() == &body)
            m_followAgent->SetLeader(KY_NULL);
      }
   protected:
      modFollowAgent* m_followAgent;
   };

public:

   modFollowAgent();

   ~modFollowAgent();

   KyResult Initialize(Bot& bot, TimeManager::TaskId computeRealDestinationTaskId);

   void Clear();

   void ReInit();
   
   KyBool Think();


   void SetLeader(Body* target);

   Body* GetLeader() const { return m_leaderBody;}

   void SetDistFromLeader (KyFloat32 distFromTarget);

   KyFloat32 GetDistFromLeader() const {return m_desiredDistFromLeader;}

   void SetAngleFromLeader(KyFloat32 angleFromTarget);
   
   KyFloat32 GetAngleFromLeader() const { return m_desiredAngleFromLeader; }

   void SetMinimalImportantMove(const KyFloat32 value);
   
   KyFloat32 GetMinimalImportantMove() const { return m_minimalImportantMove; }

   void SetSpeed(const KyFloat32 speed);
   
   KyFloat32 GetSpeed() const { return m_desiredSpeed; }

   void SetMaxTimeToReachIdealDestination(KyFloat32 interval);


   const Vec3f& GetDestination() const { return m_destination.GetPosition(); }
   
   KyBool HasArrived() const { return m_hasArrived; }
   
protected:
   /* Compute the agent's destination to put them at the correct station
      * offset from the leader. The station will be a position at the desired
      * range and angle from the leader unless
      * 1- this location cannot be seen from the leader; in which case the 
      * location is moved toward the leader until it is visible; or
      * 2- path following fails; in which case path following is set to just
      * move toward the leader and stop when it gets the desired distance
      * away (regardless of angle).
      */ 
   void computeAndLockDestination(Vec3f &offsetPosNow);

   /* Checks if follow agent should recompute its destination.
      * True if the desired destination has moved more than a threshold.
      * We use leader direction of motion instead of heading if the leader
      * is moving.
      * Returns the current ideal offset position in offsetPosNow.*/
   KyBool NeedRecomputation(Vec3f &offsetPosNow);

   /* If idealPos is not visible from the leader, then this function 
    *  will move the destination position toward the leader until it is
    *  visible. This is called from computeAndLockDestination.*/
   void computeVisibleDestination(Vec3f& idealPos);
   
protected:
   Bot* m_bot;

   WorldObserver m_worldObserver;
   Body* m_leaderBody; //< Accessor to Leader entity
   KyFloat32 m_minDistBetweenAgents; //<Sum of radii of leader and this

   KyFloat32 m_desiredDistFromLeader; //< Follow instruction (distance from Leader)
   KyFloat32 m_desiredAngleFromLeader; //< Follow instruction (angle from Leader)

   PointLockManager* m_pointLockManager;  //< Pointer to point lock manager world

   TimeManager::TaskId m_computeRealDestinationTaskId; //< Id of 
      //ComputeRealDistance time-managed task
   KyFloat32 m_computeRealDistTimer; //< This timer is used to force a minimal 
      //delay between two calls
   KyFloat32 m_minimalIntervalToReevaluate; //< Minimal time to wait between 
      //two destination update
   KyFloat32 m_maximalIntervalToReachDestination; //< Maximal time to reach an 
      //Ideal Destination
   KyFloat32 m_timerToReach; //< time used to force a recomputation when agent 
      //take too much time to reach its ideal destination

   ActionTorsoRotate* m_torsoRotateAttr; //< Bot Torso Rotate Action, used to 

   PointWrapper m_destination; //< Agent destination point.
   PointInfo_NavTriangleId m_DestPointInfo; //< Ideal destination Mesh Point Info
   KyBool m_hasArrived; //< A flag to know if the agent has arrived

   KyFloat32 m_desiredSpeed;//< Contains agents move speed
   KyFloat32 m_leaderLastSpeed;//< The speed that the leader is moving; 
   KyBool m_useDistanceToLeaderMode;//< Agent cannot get to the desired 
   Vec3f m_lastIdealOffsetPos; //< The last computed ideal offset position,
 
   
   /* MinimalImportantMove is a distance that determines whether the desired
      offset position has moved enough to warrant a path following update. 
      The smaller this value is,
      the more reactive the entity will be, but it will also perform more
      computations to update its goal. */
   KyFloat32 m_minimalImportantMove;

   KyFloat32 m_currentMaxAccel;
   KyFloat32 m_currentMaxDecel;

};

}