controllable_entity.h

Go to the documentation of this file.

 
#ifndef CONTROLLABLE_ENTITY_H
#define CONTROLLABLE_ENTITY_H
 
namespace argos {
   class CControllableEntity;
   class CSimulatedActuator;
   class CSimulatedSensor;
}
 
#include <argos3/core/simulator/entity/entity.h>
#include <argos3/core/control_interface/ci_controller.h>
#include <argos3/core/utility/math/ray3.h>
 
namespace argos {
 
   class CControllableEntity : public CEntity {
 
   public:
 
      ENABLE_VTABLE();
 
      typedef std::vector<CControllableEntity*> TVector;
 
      typedef std::map<std::string, CControllableEntity*> TMap;
 
   public:
 
      CControllableEntity(CComposableEntity* pc_parent);
 
      CControllableEntity(CComposableEntity* pc_parent,
                          const std::string& str_id);
 
      virtual ~CControllableEntity();
 
      virtual void Init(TConfigurationNode& t_tree);
 
      virtual void Reset();
 
      virtual void Destroy();
 
      const CCI_Controller& GetController() const;
 
      CCI_Controller& GetController();
 
      void SetController(const std::string& str_controller_id);
 
      void SetController(const std::string& str_controller_id,
                         TConfigurationNode& t_controller_config);
 
      virtual void Sense();
 
      virtual void ControlStep();
 
      virtual void Act();
 
      virtual std::string GetTypeDescription() const {
         return "controller";
      }
 
      inline void AddCheckedRay(bool b_obstructed,
                                const CRay3& c_ray) {
         m_vecCheckedRays.push_back(std::make_pair(b_obstructed, c_ray));
      }
 
      inline void AddIntersectionPoint(const CRay3& c_ray,
                                       Real f_t_on_ray) {
         CVector3 cPoint;
         c_ray.GetPoint(cPoint, f_t_on_ray);
         m_vecIntersectionPoints.push_back(cPoint);
      }
 
      inline std::vector<std::pair<bool, CRay3> >& GetCheckedRays() {
         return m_vecCheckedRays;
      }
 
      inline std::vector<CVector3>& GetIntersectionPoints() {
         return m_vecIntersectionPoints;
      }
 
      inline const std::map<std::string, CSimulatedActuator*>& GetActuators() const {
         return m_mapActuators;
      }
 
      inline const std::map<std::string, CSimulatedSensor*>& GetSensors() const {
         return m_mapSensors;
      }
 
   protected:
 
      CCI_Controller* m_pcController;
 
      std::map<std::string, CSimulatedActuator*> m_mapActuators;
 
      std::map<std::string, CSimulatedSensor*> m_mapSensors;
 
      std::vector<std::pair<bool, CRay3> > m_vecCheckedRays;
 
      std::vector<CVector3> m_vecIntersectionPoints;
 
   };
 
}
 
#endif