hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/mujoco/ant/operations_cpu.h

@@ -0,0 +1,160 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_MUJOCO_ANT_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_MUJOCO_ANT_OPERATIONS_CPU_H
+
+#include "ant.h"
+#include "../../operations_generic.h"
+#include <cstring>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::mujoco::ant{
+    #include "model.h"
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename SPEC>
+    void malloc(DEVICE& device, rl::environments::mujoco::Ant<SPEC>& env) {
+        using TI = typename DEVICE::index_t;
+        constexpr typename DEVICE::index_t error_length = 1000;
+        char error[error_length] = "Could not load model";
+        {
+            mjVFS* vfs = new mjVFS; // needs to be allocated on the heap because it is huge and putting it on the stack resulted in a stack overflow on windows
+            mj_defaultVFS(vfs);
+            mj_makeEmptyFileVFS(vfs, "model.xml", rl_tools::rl::environments::mujoco::ant::model_xml_len);
+            int file_idx = mj_findFileVFS(vfs, "model.xml");
+            std::memcpy(vfs->filedata[file_idx], rl_tools::rl::environments::mujoco::ant::model_xml, rl_tools::rl::environments::mujoco::ant::model_xml_len);
+            env.model = mj_loadXML("model.xml", vfs, error, error_length);
+            mj_deleteFileVFS(vfs, "model.xml");
+            delete vfs;
+        }
+#ifdef RL_TOOLS_DEBUG_RL_ENVIRONMENTS_MUJOCO_CHECK_INIT
+        utils::assert_exit(device, env.model != nullptr, error);
+#endif
+        env.data = mj_makeData(env.model);
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q; state_i++){
+            env.init_q[state_i] = env.data->qpos[state_i];
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q_DOT; state_i++){
+            env.init_q_dot[state_i] = env.data->qvel[state_i];
+        }
+        env.torso_id = mj_name2id(env.model, mjOBJ_XBODY, "torso");
+
+    }
+    template <typename DEVICE, typename SPEC>
+    void free(DEVICE& device, rl::environments::mujoco::Ant<SPEC>& env){
+        mj_deleteData(env.data);
+        mj_deleteModel(env.model);
+    }
+    template <typename DEVICE, typename SPEC>
+    void init(DEVICE& device, rl::environments::mujoco::Ant<SPEC>& env){ }
+    template <typename DEVICE, typename SPEC>
+    std::string json(DEVICE&, rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters){
+        return "{}";
+    }
+    template <typename DEVICE, typename SPEC>
+    std::string json(DEVICE&, rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, typename rl::environments::mujoco::Ant<SPEC>::State& state){
+        return "{}";
+    }
+    template<typename DEVICE, typename SPEC, typename RNG>
+    static void sample_initial_parameters(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, RNG& rng){ }
+    template<typename DEVICE, typename SPEC>
+    static void initial_parameters(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters){ }
+    template<typename DEVICE, typename SPEC, typename RNG>
+    static void sample_initial_state(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, typename rl::environments::mujoco::ant::State<SPEC>& state, RNG& rng){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        mj_resetData(env.model, env.data);
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q; state_i++){
+            state.q    [state_i] = env.init_q    [state_i] + random::uniform_real_distribution(typename DEVICE::SPEC::RANDOM(), -(T)SPEC::PARAMETERS::RESET_NOISE_SCALE, (T)SPEC::PARAMETERS::RESET_NOISE_SCALE, rng);
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q_DOT; state_i++){
+            state.q_dot[state_i] = env.init_q_dot[state_i] + random::normal_distribution::sample(typename DEVICE::SPEC::RANDOM(), (T)0, (T)SPEC::PARAMETERS::RESET_NOISE_SCALE, rng);
+        }
+        mj_forward(env.model, env.data);
+    }
+    template<typename DEVICE, typename SPEC>
+    static void initial_state(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, typename rl::environments::mujoco::ant::State<SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        mj_resetData(env.model, env.data);
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q; state_i++){
+            state.q    [state_i] = env.init_q[state_i];
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q_DOT; state_i++){
+            state.q_dot[state_i] = env.init_q_dot[state_i];
+        }
+        mj_forward(env.model, env.data);
+    }
+    template<typename DEVICE, typename SPEC, typename ACTION_SPEC, typename RNG>
+    typename SPEC::T step(DEVICE& device, rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, const rl::environments::mujoco::ant::State<SPEC>& state, const Matrix<ACTION_SPEC>& action, rl::environments::mujoco::ant::State<SPEC>& next_state, RNG& rng) {
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        using ENVIRONMENT = rl::environments::mujoco::Ant<SPEC>;
+        static_assert(ACTION_SPEC::ROWS == 1);
+        static_assert(ACTION_SPEC::COLS == ENVIRONMENT::ACTION_DIM);
+        T x_pre = env.data->xpos[env.torso_id * 3];
+
+        T control_cost = 0;
+        for(TI action_i = 0; action_i < SPEC::ACTION_DIM; action_i++){
+            T control = get(action, 0, action_i);
+            control = math::clamp<T>(device.math, control, -1, 1);
+            env.data->ctrl[action_i] = control;
+            control_cost += control * control;
+        }
+        control_cost *= SPEC::PARAMETERS::CONTROL_COST_WEIGHT;
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q; state_i++){
+            env.data->qpos[state_i] = state.q[state_i];
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q_DOT; state_i++){
+            env.data->qvel[state_i] = state.q_dot[state_i];
+        }
+        for(TI frame_i = 0; frame_i < SPEC::PARAMETERS::FRAME_SKIP; frame_i++){
+            mj_step(env.model, env.data);
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q; state_i++){
+            next_state.q[state_i] = env.data->qpos[state_i];
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q_DOT; state_i++){
+            next_state.q_dot[state_i] = env.data->qvel[state_i];
+        }
+        mj_rnePostConstraint(env.model, env.data);
+
+        T x_post = env.data->xpos[env.torso_id * 3];
+        bool healthy = is_finite(device, wrap<DEVICE, T, SPEC::STATE_DIM>(device, (T*)next_state.q)) && is_finite(device, wrap<DEVICE, T, SPEC::STATE_DIM>(device, (T*)next_state.q_dot));
+        healthy &= next_state.q[2] >= SPEC::PARAMETERS::HEALTY_Z_MIN && next_state.q[2] <= SPEC::PARAMETERS::HEALTY_Z_MAX;
+        T healty_reward = healthy || SPEC::PARAMETERS::TERMINATE_WHEN_UNHEALTHY ? SPEC::PARAMETERS::HEALTHY_REWARD : 0;
+        T forward_reward = (x_post - x_pre) / SPEC::PARAMETERS::DT / SPEC::PARAMETERS::FRAME_SKIP;
+        env.last_reward = forward_reward + healty_reward - control_cost;
+        env.last_terminated = SPEC::PARAMETERS::TERMINATE_WHEN_UNHEALTHY && !healthy;
+        return SPEC::PARAMETERS::DT * SPEC::PARAMETERS::FRAME_SKIP;
+    }
+    template<typename DEVICE, typename SPEC, typename ACTION_SPEC, typename RNG>
+    static typename SPEC::T reward(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, const rl::environments::mujoco::ant::State<SPEC>& state, const Matrix<ACTION_SPEC>& action, const rl::environments::mujoco::ant::State<SPEC>& next_state, RNG& rng){
+        return env.last_reward;
+    }
+
+    template<typename DEVICE, typename SPEC, typename OBS_TYPE_SPEC, typename OBS_SPEC, typename RNG>
+    static void observe(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, const typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, const rl::environments::mujoco::ant::State<SPEC>& state, const rl::environments::mujoco::ant::Observation<OBS_TYPE_SPEC>&, Matrix<OBS_SPEC>& observation, RNG& rng){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q - 2; state_i++){
+            set(observation, 0, state_i, state.q[state_i + 2]);
+        }
+        for(TI state_i = 0; state_i < SPEC::STATE_DIM_Q_DOT; state_i++){
+            set(observation, 0, state_i + SPEC::STATE_DIM_Q - 2, state.q_dot[state_i]);
+        }
+    }
+    template<typename DEVICE, typename SPEC, typename RNG>
+    static bool terminated(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env, const typename rl::environments::mujoco::Ant<SPEC>::Parameters& parameters, const typename rl::environments::mujoco::ant::State<SPEC> state, RNG& rng){
+        return env.last_terminated;
+    }
+    template <typename DEVICE, typename SPEC>
+    std::string json(DEVICE& device, const rl::environments::mujoco::Ant<SPEC>& env){
+        std::string json_string = "{";
+        json_string += "\"name\": \"Ant-v4\"";
+        json_string += "\"}";
+        return json_string;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/mujoco/ant/ui.h

@@ -0,0 +1,141 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_MUJOCO_ANT_UI_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_MUJOCO_ANT_UI_H
+#include <GLFW/glfw3.h>
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::mujoco::ant {
+    template <typename T_ENVIRONMENT>
+    struct UI{
+        using ENVIRONMENT = T_ENVIRONMENT;
+        ENVIRONMENT* env;
+        GLFWwindow* window;
+        mjvCamera camera;
+        mjvOption option;
+        mjvScene scene;
+        mjrContext context;
+        bool button_left = false;
+        bool button_middle = false;
+        bool button_right =  false;
+        double lastx = 0;
+        double lasty = 0;
+    };
+    namespace ui::callbacks{
+        template <typename UI>
+        void keyboard(GLFWwindow* window, int key, int scancode, int act, int mods) {
+            UI* ui = (UI*)glfwGetWindowUserPointer(window);
+            if (act==GLFW_PRESS && key==GLFW_KEY_BACKSPACE) {
+                mj_resetData(ui->env->model, ui->env->data);
+                mj_forward(ui->env->model, ui->env->data);
+            }
+        }
+        template <typename UI>
+        void mouse_button(GLFWwindow* window, int button, int act, int mods) {
+            UI* ui = (UI*)glfwGetWindowUserPointer(window);
+            ui->button_left = (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT)==GLFW_PRESS);
+            ui->button_middle = (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_MIDDLE)==GLFW_PRESS);
+            ui->button_right = (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_RIGHT)==GLFW_PRESS);
+
+            glfwGetCursorPos(window, &ui->lastx, &ui->lasty);
+        }
+
+        template <typename UI>
+        void mouse_move(GLFWwindow* window, double xpos, double ypos) {
+            UI* ui = (UI*)glfwGetWindowUserPointer(window);
+            if (!ui->button_left && !ui->button_middle && !ui->button_right) {
+                return;
+            }
+            double dx = xpos - ui->lastx;
+            double dy = ypos - ui->lasty;
+            ui->lastx = xpos;
+            ui->lasty = ypos;
+            int width, height;
+            glfwGetWindowSize(window, &width, &height);
+            bool mod_shift = (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT)==GLFW_PRESS || glfwGetKey(window, GLFW_KEY_RIGHT_SHIFT)==GLFW_PRESS);
+            mjtMouse action;
+            if (ui->button_right) {
+                action = mod_shift ? mjMOUSE_MOVE_H : mjMOUSE_MOVE_V;
+            } else if (ui->button_left) {
+                action = mod_shift ? mjMOUSE_ROTATE_H : mjMOUSE_ROTATE_V;
+            } else {
+                action = mjMOUSE_ZOOM;
+            }
+            mjv_moveCamera(ui->env->model, action, dx/height, dy/height, &ui->scene, &ui->camera);
+        }
+
+        template <typename UI>
+        void scroll(GLFWwindow* window, double xoffset, double yoffset) {
+            UI* ui = (UI*)glfwGetWindowUserPointer(window);
+            mjv_moveCamera(ui->env->model, mjMOUSE_ZOOM, 0, -0.05*yoffset, &ui->scene, &ui->camera);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename ENVIRONMENT>
+    void init(DEVICE& dev, ENVIRONMENT& env, typename ENVIRONMENT::Parameters& parameters, rl::environments::mujoco::ant::UI<ENVIRONMENT>& ui){
+        using UI = rl::environments::mujoco::ant::UI<ENVIRONMENT>;
+        ui.env = &env;
+        if (!glfwInit()) {
+            mju_error("Could not initialize GLFW");
+        }
+        ui.window = glfwCreateWindow(1200, 900, "Demo", NULL, NULL);
+        glfwSetWindowUserPointer(ui.window, &ui);
+        glfwMakeContextCurrent(ui.window);
+        glfwSwapInterval(1);
+
+        mjv_defaultCamera(&ui.camera);
+        ui.camera.type = mjCAMERA_TRACKING;
+        ui.camera.trackbodyid = env.torso_id;
+        ui.camera.distance = 6;
+        mjv_defaultOption(&ui.option);
+        mjv_defaultScene(&ui.scene);
+        mjr_defaultContext(&ui.context);
+
+        mjv_makeScene(ui.env->model, &ui.scene, 2000);
+        mjr_makeContext(ui.env->model, &ui.context, mjFONTSCALE_150);
+
+        glfwSetKeyCallback(ui.window, rl::environments::mujoco::ant::ui::callbacks::keyboard<UI>);
+        glfwSetCursorPosCallback(ui.window, rl::environments::mujoco::ant::ui::callbacks::mouse_move<UI>);
+        glfwSetMouseButtonCallback(ui.window, rl::environments::mujoco::ant::ui::callbacks::mouse_button<UI>);
+        glfwSetScrollCallback(ui.window, rl::environments::mujoco::ant::ui::callbacks::scroll<UI>);
+    }
+    template <typename DEVICE, typename ENVIRONMENT>
+    void set_state(DEVICE& dev, ENVIRONMENT& environment, typename ENVIRONMENT::Parameters& parameters, rl::environments::mujoco::ant::UI<ENVIRONMENT>& ui, const typename ENVIRONMENT::State& state){
+        using TI = typename DEVICE::index_t;
+        for(TI state_i = 0; state_i < ENVIRONMENT::SPEC::STATE_DIM_Q; state_i++){
+            ui.env->data->qpos[state_i] = state.q[state_i];
+        }
+        for(TI state_i = 0; state_i < ENVIRONMENT::SPEC::STATE_DIM_Q_DOT; state_i++){
+            ui.env->data->qvel[state_i] = state.q_dot[state_i];
+        }
+        mj_forward(ui.env->model, ui.env->data);
+        mjrRect viewport = {0, 0, 0, 0};
+        glfwGetFramebufferSize(ui.window, &viewport.width, &viewport.height);
+
+        mjv_updateScene(ui.env->model, ui.env->data, &ui.option, NULL, &ui.camera, mjCAT_ALL, &ui.scene);
+        mjr_render(viewport, &ui.scene, &ui.context);
+
+        glfwSwapBuffers(ui.window);
+
+        glfwPollEvents();
+    }
+
+    template <typename DEVICE, typename ENVIRONMENT>
+    void free(DEVICE& dev, ENVIRONMENT& env, rl::environments::mujoco::ant::UI<ENVIRONMENT>& ui){
+        mjv_freeScene(&ui.scene);
+        mjr_freeContext(&ui.context);
+
+#if defined(__APPLE__) || defined(_WIN32)
+        glfwTerminate();
+#endif
+    }
+
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/mujoco/mujoco.h

@@ -0,0 +1 @@
+#include "ant/ant.h"

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/multi_agent/bottleneck/bottleneck.h

@@ -0,0 +1,113 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_MULTI_AGENT_BOTTLENECK_BOTTLENECK_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_MULTI_AGENT_BOTTLENECK_BOTTLENECK_H
+
+#include "../../../../math/operations_generic.h"
+#include "../environments.h"
+#include "../../observation.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::multi_agent::bottleneck {
+    template <typename T_T, typename T_TI>
+    struct DefaultParameters {
+        using T = T_T;
+        using TI = T_TI;
+        static constexpr TI N_AGENTS = 2;
+        static constexpr TI LIDAR_RESOLUTION = 5;
+        static constexpr T LIDAR_FOV = math::PI<T> * 20/180; // in radians (0 to PI)
+        static constexpr T LIDAR_RANGE = 3;
+        static constexpr T DT = 0.05;
+        static constexpr T ARENA_WIDTH = 20; // x: left to right, y: top to bottom (display coordinate system)
+        static constexpr T ARENA_HEIGHT = 20;
+        static constexpr T AGENT_DIAMETER = 1.5;
+        static constexpr T AGENT_MAX_SPEED = 2;
+        static constexpr T AGENT_MAX_ACCELERATION = 2;
+        static constexpr T AGENT_MAX_ANGULAR_VELOCITY = 2;
+        static constexpr T AGENT_MAX_ANGULAR_ACCELERATION = 2;
+        static constexpr T BOTTLENECK_POSITION = 10; // y
+        static constexpr T BOTTLENECK_WIDTH = 2;
+        static constexpr T BARRIER_WIDTH = 0.5;
+        static constexpr TI EPISODE_STEP_LIMIT = 200;
+        static constexpr bool SPAWN_BOTH_SIDES = false;
+    };
+    template <typename T_PARAMETERS>
+    struct Observation{
+        using PARAMETERS = T_PARAMETERS;
+        using T = typename PARAMETERS::T;
+        using TI = typename PARAMETERS::TI;
+        static constexpr TI PER_AGENT_DIM = 7 + PARAMETERS::LIDAR_RESOLUTION;
+        static constexpr TI DIM = PARAMETERS::N_AGENTS * PER_AGENT_DIM;
+        using SHAPE = tensor::Shape<TI, DIM>;
+    };
+    template <typename T_PARAMETERS>
+    struct ObservationPrivileged{
+        using PARAMETERS = T_PARAMETERS;
+        using T = typename PARAMETERS::T;
+        using TI = typename PARAMETERS::TI;
+        static constexpr TI PER_AGENT_DIM = 7 + PARAMETERS::LIDAR_RESOLUTION;
+        static constexpr TI DIM = PARAMETERS::N_AGENTS * PER_AGENT_DIM;
+        using SHAPE = tensor::Shape<TI, DIM>;
+    };
+    template <typename T_TYPE_POLICY, typename T_TI, typename T_PARAMETERS = DefaultParameters<typename T_TYPE_POLICY::DEFAULT, T_TI>, typename T_OBSERVATION = Observation<T_PARAMETERS>, typename T_OBSERVATION_PRIVILEGED = ObservationPrivileged<T_PARAMETERS>>
+    struct Specification{
+        using T = typename T_TYPE_POLICY::DEFAULT;
+        using TI = T_TI;
+        using OBSERVATION = T_OBSERVATION;
+        using OBSERVATION_PRIVILEGED = T_OBSERVATION_PRIVILEGED;
+        using PARAMETERS = T_PARAMETERS;
+    };
+
+    template <typename T>
+    struct Intersection {
+        bool intersects = false;
+        T point[2];
+        T distance;
+    };
+
+    template <typename T, typename TI>
+    struct AgentState {
+        T position[2];
+        T orientation;
+        T velocity[2];
+        T angular_velocity;
+        Intersection<T> lidar[DefaultParameters<T, TI>::LIDAR_RESOLUTION];
+        bool dead;
+    };
+
+    template <typename SPEC>
+    struct State{
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        AgentState<T, TI> agent_states[SPEC::PARAMETERS::N_AGENTS];
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::multi_agent{
+    template <typename T_SPEC>
+    struct Bottleneck: Environment<typename T_SPEC::T, typename T_SPEC::TI>{
+        using SPEC = T_SPEC;
+        using PARAMETERS = typename SPEC::PARAMETERS;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        using State = multi_agent::bottleneck::State<SPEC>;
+        using Parameters = typename SPEC::PARAMETERS;
+        using Observation = typename SPEC::OBSERVATION;
+        using ObservationPrivileged = typename SPEC::OBSERVATION_PRIVILEGED;
+        static constexpr TI N_AGENTS = Parameters::N_AGENTS;
+        static constexpr TI PER_AGENT_ACTION_DIM = 2; // linear and angular acceleration
+        static constexpr TI ACTION_DIM = N_AGENTS * PER_AGENT_ACTION_DIM;
+        static constexpr TI EPISODE_STEP_LIMIT = Parameters::EPISODE_STEP_LIMIT;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+
+
+
+
+
+#endif