epuck_simple_grid_world.h

Go to the documentation of this file.

#ifndef EPUCK_SIMPLE_GRID_WORLD_H
#define EPUCK_SIMPLE_GRID_WORLD_H
 
 
#include "rlenvs/bitrl_config.h"
 
#ifdef BITRL_WEBOTS
 
#include "rlenvs/envs/env_types.h"
#include "rlenvs/envs/time_step.h"
#include "rlenvs/envs/webots_envs/webots_base_env.h"
#include "rlenvs/rigid_bodies/webots_robots/epuck_robot.h"
#include "rlenvs/rlenvs_types_v2.h"
 
#include <webots/PositionSensor.hpp>
#include <webots/Robot.hpp>
 
#include <any>
#include <exception>
#include <vector>
 
namespace rlenvscpp
{
namespace envs
{
namespace webots_envs
{
 
using namespace rlenvscpp::rigid_bodies::webots_robots;
 
class EpuckSimpleGridWorld final
    : public WebotsEnvBase<TimeStep<std::vector<real_t>>,
                           ContinuousVectorStateDiscreteActionEnv<3, // the state space has size 3
                                                                  1, // the action space ends at 1
                                                                  0, // the action space starts at 0
                                                                  real_t>>
{
 
  public:
    static const std::string name;
 
    typedef WebotsEnvBase<
        TimeStep<state_type>,
        envs::ContinuousVectorStateDiscreteActionEnv<3, // the state space has size 2
                                                     1, // the action space ends at 1
                                                     0, // the action space starts at 0
                                                     real_t>>
        base_type;
 
    typedef typename base_type::time_step_type time_step_type;
 
    typedef typename base_type::state_space_type state_space_type;
 
    typedef typename base_type::action_space_type action_space_type;
 
    typedef typename base_type::action_type action_type;
 
    typedef typename base_type::state_type state_type;
 
    using base_type::reset;
 
    EpuckSimpleGridWorld();
 
    virtual void make(const std::string &version,
                      const std::unordered_map<std::string, std::any> &options) override final;
 
    virtual void close() override final;
 
    virtual void pause_simulation() override final;
 
    virtual time_step_type
    reset(uint_t /*seed*/,
          const std::unordered_map<std::string, std::any> & /*options*/) override final;
 
    virtual time_step_type step(const action_type &action) override final;
 
    uint_t n_actions() const noexcept { return action_space_type::size; }
 
    real_t compute_reward() const;
 
    EpuckRobot &get_robot() noexcept { return robot_; }
 
    const EpuckRobot &get_robot() const noexcept { return robot_; }
 
  private:
    EpuckRobot robot_;
 
    void build_make_options_(const std::unordered_map<std::string, std::any> &options);
 
    void activate_robot_();
 
    time_step_type on_stop_();
 
    time_step_type on_move_();
};
 
} // namespace webots_envs
} // namespace envs
} // namespace rlenvscpp
 
#endif
#endif