GameBuilder.cpp

#include <States/GameState/GameBuilder/GameBuilder.h>
#include <random>
#include <queue>

void CommonBuilder::create_context(const float dynamic_objets_ratio) {
    std::mt19937 gen(std::random_device{}());

    std::vector<std::vector<std::unique_ptr<Room>>::iterator> buf_rooms;
    for (auto& row : m_rooms) {
        for (auto room = row.begin(); room != row.end(); ++room) {
            if (*room == nullptr) continue;
            buf_rooms.push_back(room);
        }
    }

    if (buf_rooms.empty()) return;

    std::uniform_int_distribution distrib(0 , static_cast<int>(buf_rooms.size()-1));

    auto pos = buf_rooms.begin() + distrib(gen);
    const sf::Vector2f pacman_pos = (*pos)->get()->get_position();
    m_context.pacman.set_initial_location((*pos)->get());
    buf_rooms.erase(pos);

    if (dynamic_objets_ratio > 1) throw std::invalid_argument("GAME_ENEMY_RATIO should be <= 1");
    const auto number_of_dynamic_entities = static_cast<size_t>(static_cast<float>(buf_rooms.size()) * dynamic_objets_ratio);
    for (size_t i = 0; i < number_of_dynamic_entities; ++i) {
        distrib.param(std::uniform_int_distribution<>::param_type(0, static_cast<int>(buf_rooms.size()) - 1));
        pos = buf_rooms.begin() + distrib(gen);
        if (float pos_x = (*pos)->get()->get_position().x, pos_y = (*pos)->get()->get_position().y;
            std::sqrt((pos_x-pacman_pos.x) * (pos_x-pacman_pos.x) + (pos_y-pacman_pos.y) * (pos_y-pacman_pos.y)) <= m_room_size * 2) {
            m_context.static_objects.emplace_back(std::move(std::make_unique<Food>()));
            m_context.static_objects.back()->set_initial_location((*pos)->get());
        }
        else {
            m_context.dynamic_objects.emplace_back(std::move(std::make_unique<Enemy>()));
            m_context.dynamic_objects.back()->set_initial_location((*pos)->get());
        }
        buf_rooms.erase(pos);
    }

    for (const auto& it_room : buf_rooms) {
        m_context.static_objects.emplace_back(std::move(std::make_unique<Food>()));
        m_context.static_objects.back()->set_initial_location(it_room->get());
    }
}

void CommonBuilder::create_state(IStateManager& state_manager, const sf::VideoMode& mode, const std::string& window_title) {
    m_game_state = std::make_unique<GameState>(state_manager, mode, window_title);
}

void CommonBuilder::set_all_to_state() {
    std::vector<std::unique_ptr<Room>> rooms;
    for (auto& row : m_rooms) {
        for (auto& room : row) {
            if (room == nullptr) continue;
            rooms.emplace_back(std::move(room));
        }
    }
    m_game_state->set_maze(Maze(std::move(rooms)));
    m_game_state->set_context(std::move(m_context));
}

void SimpleBuilder::create_rooms() {
    const auto number_of_rooms_in_row = static_cast<size_t>(m_width / m_room_size),
        number_of_rooms_in_col = static_cast<size_t>(m_height / m_room_size);

    const sf::Vector2f gap(
        (m_width - static_cast<float>(number_of_rooms_in_row) * m_room_size + m_room_size) / 2.f,
        (m_height - static_cast<float>(number_of_rooms_in_col) * m_room_size + m_room_size) / 2.f