main.cpp

 
#include <main/main.hpp>
#include "metrics.hpp"
 
#ifdef TESTING
message_bus gMessage_bus;
#endif
 
#ifndef TESTING
 
int main(int argc, char *argv[]) {
#elif defined(TESTING)
    int ST_engine_main(int argc, char *argv[]) {
#endif
    //we get rid of the two warnings for unused parameters.
    //int main() will work fine on linux, but not on Windows
    //where SDL does some weird stuff with the main function,
    //so we need to specify main like this to avoid conflict with SDL
    (void) argc;
    (void) argv;
 
    //Order of subsystem initialization is crucial
#ifndef TESTING
    message_bus gMessage_bus;
#endif
    fps gFps;
    console gConsole(gMessage_bus);
    gConsole.set_log_level(ST::log_type::INFO | ST::log_type::SUCCESS | ST::log_type::ERROR);
 
    //TODO: The initial resolution does not get passed to the game_manager due to the initialization order
    task_manager gTask_manager;
    audio_manager gAudio_manager(gTask_manager, gMessage_bus);
    input_manager gInput_manager(gTask_manager, gMessage_bus);
    window_manager gDisplay_manager(gMessage_bus, gTask_manager, "ST");
    drawing_manager gDrawing_manager(gDisplay_manager.get_window(), gMessage_bus);
 
    assets_manager gAssets_manager(gMessage_bus, gTask_manager);
    physics_manager gPhysics_manager(gMessage_bus);
    game_manager gGame_manager(gMessage_bus);
    timer gTimer;
 
    gGame_manager.update();
    gConsole.post_init();
 
    //time keeping variables
    const double LOGIC_UPDATE_RATE = 16.66666;
    double total_time = 0;
    double current_time = gTimer.time_since_start();
    double frame_time;
    double new_time;
 
    ST::metrics gMetrics{};
    assets_manager::update_task(&gAssets_manager);
    gDisplay_manager.update();
 
    //main loop
    while (gGame_manager.game_is_running()) {
        new_time = gTimer.time_since_start();
        frame_time = new_time - current_time;
        current_time = new_time;
        total_time += frame_time;
 
        gMetrics.reset_accumulators();
 
        if (total_time >= LOGIC_UPDATE_RATE) {
            do {
                gInput_manager.update();
 
                double game_logic_begin = gTimer.time_since_start();
 
                gGame_manager.update();
                double game_logic_end = gTimer.time_since_start();
                gMetrics.game_logic_time += game_logic_end - game_logic_begin;
 
                double physics_begin = gTimer.time_since_start();
                gPhysics_manager.update(*gGame_manager.get_level());
                double physics_end = gTimer.time_since_start();
                gMetrics.physics_time += physics_end - physics_begin;
 
                total_time -= LOGIC_UPDATE_RATE;
            } while (total_time >= LOGIC_UPDATE_RATE);
            //All three start their own update tasks which run in the background
            gAssets_manager.update();
            gDisplay_manager.update();
            gAudio_manager.update();
        }
        gConsole.update();
        gFps.update(current_time, frame_time);
 
        gMetrics.frame_time = frame_time;
 
        double render_begin = gTimer.time_since_start();
        gDrawing_manager.update(*gGame_manager.get_level(), gFps.get_value(), gConsole, gMetrics);
        double render_end = gTimer.time_since_start();
        gMetrics.render_time = render_end - render_begin;
    }
    return 0;
}