simulator.h

Go to the documentation of this file.

#ifndef SIMULATOR_H
#define SIMULATOR_H
 
#include "pogosim.h"
#include "robot.h"
#include "objects.h"
#include "lights.h"
#include "configuration.h"
#include "data_logger.h"
#include "SDL_FontCache.h"
#include "trajectory_traces.h"
 
#include <optional>
#include <unordered_set>

extern "C" int robot_main(void);

//void set_current_robot(Robot& robot);
void set_current_robot(PogobotObject& robot);
 
enum class boundary_condition_t { solid, periodic };
 
 
void dummy_global_robot_init();
 

class Simulation {
    Configuration& config;  
 
    // SDL globals
    SDL_Window* window = nullptr;         
    SDL_Renderer* renderer = nullptr;     
    bool enable_gui = true;               
    bool paused = false;                  
    bool one_tick_requested = false;      
    bool running = true;                  
    bool show_time = false;               
    bool show_scale_bar = false;          
    bool show_comm = false;               
    bool show_comm_above_all = false;     
    bool show_lateral_leds = false;       
    bool show_light_levels = false;       
    bool show_trajectory_traces = false;  
 
    double t = 0.0f;                      
 
    uint16_t window_width = 800;          
    uint16_t window_height = 600;         
    uint16_t sub_step_count = 4;          
    double GUI_speed_up = 1.0;            
 
    float arena_width = 1000.0;           
    float arena_height = 1000.0;          
    float arena_surface = 1e6;            
    float max_comm_radius = 00.0f;        
    float comm_ignore_occlusions = false; 
 
    boundary_condition_t boundary_condition = boundary_condition_t::solid;
    // domain box in Box2D units (scaled)
    b2Vec2 domain_min{0.0f, 0.0f};
    float domain_w = 0.0f;
    float domain_h = 0.0f;
 
    b2WorldId worldId;                    
    //std::vector<Robot> robots;          ///< Vector of robots in the simulation.
    arena_polygons_t arena_polygons;      
    arena_polygons_t scaled_arena_polygons;      
 
    // Objects
    std::map<std::string, std::vector<std::shared_ptr<Object>>> objects;    
    std::vector<std::shared_ptr<Pogowall>> wall_objects;                    
    std::vector<std::shared_ptr<PhysicalObject>> phys_objects;              
    std::vector<std::shared_ptr<PogobotObject>> robots;                     
    std::vector<std::shared_ptr<Object>> non_robots;                        
    std::unique_ptr<LightLevelMap> light_map;                               
    TrajectoryTraces trajectory_traces;                                      
    std::string initial_formation;                                          
    std::pair<float, float> initial_formation_center;                       
    std::string initial_formation_root_object_name;                         
    float formation_min_space_between_neighbors;                            
    float formation_max_space_between_neighbors;                            
    float chessboard_distance_between_neighbors;                            
    uint32_t formation_attempts_per_point;                                  
    uint32_t formation_max_restarts;                                        
    std::string formation_filename;                                         
    std::pair<float, float> imported_formation_min_coords;                  
    std::pair<float, float> imported_formation_max_coords;                  
//    std::pair<float, float> formation_offset;                               ///< Apply an offset to the formation -- used for the chessboard-style formations.
//    float formation_rotation;                                               ///< Apply a rotation to the formation -- used for the chessboard-style formations.
    bool formation_cluster_at_center;                                       
    float light_map_nb_bin_x;                                               
    float light_map_nb_bin_y;                                               
 
    double last_frame_shown_t = -1.0;     
    double last_frame_saved_t = -1.0;     
    double last_data_saved_t = -1.0;      
 
    // Fonts
    FC_Font* font;                          
 
    // Mouse dragging for visualization
    bool dragging_pos_by_mouse = false;   
    int last_mouse_x;                     
    int last_mouse_y;                     
    std::weak_ptr<PogobotObject> selected_robot; 
 
    // Find the robot at the given screen position
    std::shared_ptr<PogobotObject> find_robot_at_screen_position(int mouse_x, int mouse_y) const;
    // Run per-robot click callback for the robot under the mouse.
    void handle_robot_click(int mouse_x, int mouse_y);
    // Render a visual indication that the robot is selected (e.g. a circle around it)
    void render_selected_robot();
 
    // Data logger
    bool enable_data_logging;                
    std::unique_ptr<DataLogger> data_logger; 
    uint64_t data_logger_flush_row_count;    
    std::optional<std::unordered_set<std::string>> data_logger_categories; 
 
    // Dummy robot used as current robot in the global_step callback
    std::unique_ptr<PogobotObject> dummy_global_robot;
    DiskGeometry dummy_global_robot_geom = DiskGeometry(26.5);
 
 
public:
    bool current_robot_enable_data_logging;  

    Simulation(Configuration& _config);

    virtual ~Simulation();

    void init_all();

    void create_robots();

    void create_objects();

    void create_arena();

    void create_walls();

    void init_box2d();

    void init_config();

    void init_SDL();

    void speed_up();

    void speed_down();

    void pause();

    void help_message();

    void handle_SDL_events();

    void compute_neighbors();

    void init_callbacks();

    void init_data_logger();

    void init_console_logger();

    void draw_scale_bar();

    void toggle_trajectory_traces();

    void render_all();

    void export_frames();

    void export_data();

    void main_loop();

    void stop_simulation_main_loop();

    void delete_old_data();

    Configuration& get_config();

    DataLogger* get_data_logger();

    LightLevelMap* get_light_map();

    arena_polygons_t const& get_arena_geometry() { return arena_polygons; };

    boundary_condition_t const& get_boundary_condition() { return boundary_condition; };

    void apply_periodic_wrapping();

    uint32_t get_nb_robots() const { return robots.size(); }
 
};

extern std::unique_ptr<Simulation> simulation;
 
 
#endif // SIMULATOR_H
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker