loop_functions.h

Go to the documentation of this file.

 
#ifndef LOOP_FUNCTIONS_H
#define LOOP_FUNCTIONS_H
 
namespace argos {
   class CLoopFunctions;
   class CFloorEntity;
   class CPositionalEntity;
   class CEmbodiedEntity;
}
 
#include <functional>
 
#include <argos3/core/utility/configuration/base_configurable_resource.h>
#include <argos3/core/simulator/simulator.h>
#include <argos3/core/simulator/space/space.h>
#include <argos3/core/utility/datatypes/color.h>
#include <argos3/core/utility/math/vector2.h>
#include <argos3/core/utility/math/vector3.h>
#include <argos3/core/utility/math/quaternion.h>
#include <argos3/core/simulator/physics_engine/physics_engine.h>
 
namespace argos {
 
   class CLoopFunctions : public CBaseConfigurableResource {
 
   public:
 
      CLoopFunctions() :
         m_cSimulator(CSimulator::GetInstance()),
         m_cSpace(m_cSimulator.GetSpace()) {
      }
 
      virtual ~CLoopFunctions() {}
 
      virtual void Init(TConfigurationNode& t_tree) {}
 
      virtual void Reset() {}
 
      virtual void Destroy() {}
 
      virtual void PreStep() {}
 
      virtual void PostStep() {}
 
      virtual bool IsExperimentFinished() {
         return false;
      }
 
      virtual void PostExperiment() {
      }
 
      virtual CColor GetFloorColor(const CVector2& c_pos_on_floor) {
         return CColor::WHITE;
      }
 
      inline CSimulator& GetSimulator() {
         return m_cSimulator;
      }
 
      inline CSpace& GetSpace() {
         return m_cSpace;
      }
 
      inline const CSpace& GetSpace() const {
        return m_cSpace;
      }
 
      virtual void MoveEntity(CPositionalEntity& c_entity,
                              const CVector3& c_position,
                              const CQuaternion& c_orientation);
 
      virtual bool MoveEntity(CEmbodiedEntity& c_entity,
                              const CVector3& c_position,
                              const CQuaternion& c_orientation,
                              bool b_check_only = false,
                              bool b_ignore_collisions = false);
 
      virtual void AddEntity(CEntity& c_entity);
 
      virtual void RemoveEntity(const std::string& str_entity_id);
 
      virtual void RemoveEntity(CEntity& c_entity);
 
 
      void IterateOverControllableEntities(const CSpace::TControllableEntityIterCBType& c_cb) const {
        m_cSpace.IterateOverControllableEntities(c_cb);
      }
 
   private:
 
      CSimulator& m_cSimulator;
 
      CSpace& m_cSpace;
 
   };
}
 
#define REGISTER_LOOP_FUNCTIONS(CLASSNAME, LABEL) \
   REGISTER_SYMBOL(CLoopFunctions,                \
                   CLASSNAME,                     \
                   LABEL,                         \
                   "undefined",                   \
                   "undefined",                   \
                   "undefined",                   \
                   "undefined",                   \
                   "undefined")
 
#endif