created documentation in Doxyfile

assets/Pacman_documentation

+Subproject commit 3961d4d2ef163b1fac94e411b4a6f5c1a36eff68

source/application/App/Application.h

@@ -9,9 +9,10 @@
 class Application : public IStateManager {
 public:
     Application();
-    int run();
     ~Application() override = default;
 
+    int run();
+
 private:
     void set_next_state(std::unique_ptr<IState>&& ptr_state) override;
     void apply_deffer_state_change() noexcept;

source/application/Assets/Texture_Sound.h

@@ -2,6 +2,9 @@
 #include <SFML/Graphics.hpp>
 #include <SFML/Audio.hpp>
 
+/**
+ * @brief загрузка текстур, звука, шрифта
+ */
 struct MyAssets_one {
     MyAssets_one() = delete;
     static sf::Font& GetFont();

source/application/BobBuilder/BobBuilderDirector.h

 #pragma once
 #include "IGameBuilder.h"
+///> паттерн BUILDER
+///> отвечает за создание лабиринта, размещение объектов и персонажей...
 
 class GameBuilderDirector {
 public:

source/application/BobBuilder/GameBuilders.cpp

 #include "GameBuilders.h"
 
 CommonBuilder::CommonBuilder(float width, float height, float room_size) :
-        m_width(width), m_height(height), m_room_size(room_size){
-}
-
+        m_width(width), m_height(height), m_room_size(room_size){ }
+
+/**
+ * @brief Создает контекст для игры
+ * @details Всегда в рандомное место располагаем пакмана.
+ * В качестве параметров передаем players, когда players = 2, создаем еще одного пакмана в рандомном месте.
+ * Дальше располагаем врагов в соотношении dynamic_objects_ratio, задаваемое в config.h, также в рандомные места.
+ * В оставшиеся свободные комнаты располагаем еду.
+ */
 void CommonBuilder::create_context(float dynamic_objects_ratio, int players) {
     std::vector<Room*> empty_rooms_buffer;
     for (auto& row : m_rooms)
         for (auto& room : row)
             if (room != nullptr)
                 empty_rooms_buffer.emplace_back(room);
-    //в рандомное место располагаем пакмана
+    ///> в рандомное место располагаем пакмана
     float id = std::rand() % empty_rooms_buffer.size();
     m_context.pacman.set_location(empty_rooms_buffer[id]);
     auto it = std::next(empty_rooms_buffer.begin(), id);
@@ -22,7 +28,7 @@ void CommonBuilder::create_context(float dynamic_objects_ratio, int players) {
         empty_rooms_buffer.erase(it2);
     }
 
-    //располагаем врагов
+    /// > располагаем врагов рандомно
     size_t rooms_row = static_cast<size_t>(m_width / m_room_size);
     size_t rooms_col = static_cast<size_t>(m_height / m_room_size);
     for (size_t i = 0; i < rooms_row * rooms_col * dynamic_objects_ratio; i++) {
@@ -33,36 +39,52 @@ void CommonBuilder::create_context(float dynamic_objects_ratio, int players) {
         m_context.dynamic_objects.emplace_back(std::move(enemy));
     }
 
-    //располагаем еду
+    ///> располагаем еду на оставшиеся места
     for (auto it : empty_rooms_buffer) {
         auto food = std::make_unique<Food>();
         food->set_location(it);
         food->set_texture(&FoodTexture::instance());
-
+        ///> в рандомное место под едой располагаем скример
         if (rand() % 100 < 2) food->is_screamer = true;
         m_context.static_objects.emplace_back(std::move(food));
     }
     empty_rooms_buffer.clear();
 }
 
+/**
+ * @brief Cоздаем состояние GameState, используя имя, режим окна и сслыку на менеджер состояний
+ */
 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);
 }
 
+/**
+ * @brief Созданный лабиринт и контекст назначаем созданному состоянию игры GameState
+ */
 void CommonBuilder::set_all_to_state() {
     std::vector<Room*> rooms;
     for (auto& row : m_rooms)
         for (auto& col : row)
             rooms.emplace_back(col);
     Maze maze(rooms);
-    m_game_state->set_maze(std::move(maze));
+    m_game_state->set_maze(std::move(maze)); ///> назначаем лабиринт
     m_game_state->set_context(std::move(m_context));
 }
 
+/**
+ * @brief Получить результат строителя.
+ */
 std::unique_ptr<GameState> CommonBuilder::get_game() {
     return std::move(m_game_state);
 }
 
+/**
+ * @brief Создаем все комнаты
+ * @details Сетку комнат храним в классе CommonBuilder
+ * В SimpleBuilder все возможное пространство заполняем комнатами.
+ * В set_rooms_sides() создаем проходы вправо/влево и вверх/вниз, стены делаем только на контуре.
+ * В ComplexBuilder формирует "решетчатый" лабиринт по алгоритму Эллера
+ */
 void SimpleBuilder::create_rooms() {
     size_t rows = m_height / m_room_size;
     size_t cols = config::GAME_WIDTH / m_room_size; ///> слева "менюшка" и справа игра
@@ -82,37 +104,30 @@ void SimpleBuilder::create_rooms() {
 void SimpleBuilder::set_rooms_sides() {
     for (size_t i = 0; i < m_rooms.size(); i++) {
         for (size_t j = 0; j < m_rooms[i].size(); j++) {
-            if (i == 0) {
-                auto up_wall = std::make_shared<Wall>(*m_rooms[i][j]);
-                m_rooms[i][j]->set_side(Room::UP, std::move(up_wall));
-            }
-            else {
+            if (i == 0)  ///> нулевая строка -> создаем стену сверху
+                m_rooms[i][j]->set_side(Room::UP, std::move(std::make_shared<Wall>(*m_rooms[i][j])));
+            else { ///> создаем проходы сверху и снизу
                 auto pass = std::make_shared<Pass>(*m_rooms[i - 1][j], *m_rooms[i][j]);
                 m_rooms[i][j]->set_side(Room::UP, pass);
                 m_rooms[i - 1][j]->set_side(Room::DOWN, pass);
             }
-            if (j == 0) {
-                auto left_wall = std::make_shared<Wall>(*m_rooms[i][j]);
-                m_rooms[i][j]->set_side(Room::LEFT, std::move(left_wall));
-            }
-            else {
+            if (j == 0) ///> если строка в нулевом столбце -> создаем стену слева
+                m_rooms[i][j]->set_side(Room::LEFT, std::move(std::make_shared<Wall>(*m_rooms[i][j])));
+            else {  ///> создаем проходы вправо и влево
                 auto pass = std::make_shared<Pass>(*m_rooms[i][j - 1], *m_rooms[i][j]);
                 m_rooms[i][j]->set_side(Room::LEFT, pass);
                 m_rooms[i][j - 1]->set_side(Room::RIGHT, pass);
             }
-            if (i == m_rooms.size() - 1) {
-                auto down_wall = std::make_shared<Wall>(*m_rooms[i][j]);
-                m_rooms[i][j]->set_side(Room::DOWN, std::move(down_wall));
-            }
-            if (j == m_rooms.begin()->size() - 1) {
-                auto right_wall = std::make_shared<Wall>(*m_rooms[i][j]);
-                m_rooms[i][j]->set_side(Room::RIGHT, std::move(right_wall));
-            }
+            if (i == m_rooms.size() - 1) ///> если последняя строка -> создаем стену снизу
+                m_rooms[i][j]->set_side(Room::DOWN, std::move(std::make_shared<Wall>(*m_rooms[i][j])));
+
+            if (j == m_rooms.begin()->size() - 1)  ///> если комнаты в последнем столбце -> создаем стену справа
+                m_rooms[i][j]->set_side(Room::RIGHT, std::move(std::make_shared<Wall>(*m_rooms[i][j])));
         }
     }
-
 }
 
+///> создание комнат
 void ComplexBuilder::create_rooms() {
     size_t room_quantity_row = (m_height / m_room_size);
     size_t room_quantity_col = config::GAME_WIDTH / m_room_size;
@@ -131,65 +146,73 @@ void ComplexBuilder::create_rooms() {
     }
 }
 
+///> Генерация лабиринта через алгоритм Эллера
 void ComplexBuilder::set_rooms_sides() {
     size_t cols = m_rooms[0].size();
     size_t rows = m_rooms.size();
     for (int j = 0; j < cols; j++) {
+        ///> все комнаты нулевой строки сверху получают стену UP
         m_rooms[0][j]->set_side(Room::Direction::UP, std::make_unique<Wall>(*m_rooms[0][j]));
     }
     for (int j = 0; j < cols; j++) {
+        ///> все комнаты последней строки снизу получают стену DOWN
         m_rooms[rows - 1][j]->set_side(Room::Direction::DOWN, std::make_unique<Wall>(*m_rooms[rows - 1][j]));
         if (j != cols - 1) {
+            ///> создаем проход направо между соседними комнатами
             m_rooms[rows  - 1][j]->set_side(Room::Direction::RIGHT, std::make_unique<Pass>(*m_rooms[rows - 1][j], *m_rooms[rows - 1][j+1]));
             m_rooms[rows - 1][j+1]->set_side(Room::Direction::LEFT, std::make_unique<Pass>(*m_rooms[rows - 1][j+1], *m_rooms[rows - 1][j]));
         }
     }
     for (int i = 0; i < rows ; i++) {
+        ///> все комнаты нулевого столбца слева получают стену LEFT
         m_rooms[i][0]->set_side(Room::Direction::LEFT, std::make_unique<Wall>(*m_rooms[i][0]));
     }
     for (int i = 0; i < rows; i++) {
+        ///> все комнаты последнего столбца справа получают стену RIGHT
         m_rooms[i][cols - 1]->set_side(Room::Direction::RIGHT, std::make_unique<Wall>(*m_rooms[i][cols - 1]));
     }
 
-    std::vector<int> row(cols);
+    std::vector<int> row(cols); ///> присваиваем ячейкам свое уникальное множество
     int count = 0;
     for (; count < cols; row[count] = count, count++);
-    for (int i = 0; i < rows - 1; i++) {
+    for (int i = 0; i < rows - 1; i++) { ///> исключаем последнюю строку
         for (int j = 0; j < cols - 1; j++) {
-            if (rand() % 2) {
+            if (rand() % 2) { ///> создавать стену или нет?
                 m_rooms[i][j]->set_side(Room::Direction::RIGHT, std::make_unique<Wall>(*m_rooms[i][j]));
                 m_rooms[i][j+1]->set_side(Room::Direction::LEFT, std::make_unique<Wall>(*m_rooms[i][j+1]));
             }
             else {
                 m_rooms[i][j]->set_side(Room::Direction::RIGHT, std::make_unique<Pass>(*m_rooms[i][j], *m_rooms[i][j+1]));
                 m_rooms[i][j+1]->set_side(Room::Direction::LEFT, std::make_unique<Pass>(*m_rooms[i][j+1], *m_rooms[i][j]));
+                ///> объединение множеств
                 int temp = row[j + 1];
                 for (int k = 0; k < cols; k++) {
                     if (row[k] == temp) row[k] = row[j];
                 }
             }
         }
-        for (int j = 0; j < cols; j++) {
+        for (int j = 0; j < cols; j++) { ///> соединение с ячейкой снизу/вверх
             if (rand() % 2) {
                 int temp = 0;
                 for (int k = 0; k < cols; k++) {
+                    ///> гарантируем, что в каждом множетве будет хотя бы один выход вниз
                     if (row[k] == row[j] && !m_rooms[i][k]->get_side(Room::Direction::DOWN)) temp++;
                 }
-                if (temp > 1) {
+                if (temp > 1) { ///> если есть еще ячейки, у которых нет выхода вниз -> можно поставить стену
                     m_rooms[i][j]->set_side(Room::Direction::DOWN, std::make_unique<Wall>(*m_rooms[i][j]));
                     m_rooms[i+1][j]->set_side(Room::Direction::UP, std::make_unique<Wall>(*m_rooms[i+1][j]));
                 }
-                else {
+                else { ///> обязательно ставим проход
                     m_rooms[i][j]->set_side(Room::Direction::DOWN, std::make_unique<Pass>(*m_rooms[i][j], *m_rooms[i+1][j]));
                     m_rooms[i+1][j]->set_side(Room::Direction::UP, std::make_unique<Pass>(*m_rooms[i+1][j], *m_rooms[i][j]));
                 }
             }
-            else {
+            else { ///> всегда ставим проход
                 m_rooms[i][j]->set_side(Room::Direction::DOWN, std::make_unique<Pass>(*m_rooms[i][j], *m_rooms[i+1][j]));
                 m_rooms[i+1][j]->set_side(Room::Direction::UP, std::make_unique<Pass>(*m_rooms[i+1][j], *m_rooms[i][j]));
             }
         }
-        for (int j = 0; j < cols; j++) {
+        for (int j = 0; j < cols; j++) { ///обновляем множества для следующей строки
             if (m_rooms[i][j]->get_side(Room::Direction::DOWN)) row[j] = count++;
         }
     }