Merge branch 'created-maze' into 'main'

working version with a transition from the menu to the game and the beginning...

See merge request !3

source/application/BobBuilder/ComplexGameBuilder.cpp

-#include "ComplexGameBuilder.h"
-
-void ComplexBuilder::create_rooms() {
-    //@todo
-}
-
-void ComplexBuilder::set_rooms_sides() {
-    //@todo
-}
-
-void ComplexBuilder::create_context(float dynamic_objects_ratio) {
-    //@todo
-}
-
-void ComplexBuilder::create_state(IStateManager &state_manager, sf::VideoMode &mode, std::string &window_title) {
-    //@todo
-}
-
-void ComplexBuilder::set_all_to_state() {
-    //@todo
-}
-
-std::unique_ptr<GameState> ComplexBuilder::get_game() {
-    return std::move(m_game_state);
-}
\ No newline at end of file

source/application/BobBuilder/ComplexGameBuilder.h

-#pragma once
-#include "IGameBuilder.h"
-#include "../Context/Context.h"
-
-class ComplexBuilder: public IGameBuilder {
-public:
-    ComplexBuilder(float width, float height, float room_size) : m_height(height), m_width(width), m_room_size(room_size) {};
-    void create_rooms() override;
-    void set_rooms_sides() override;
-    void create_context(float dynamic_objects_ratio) override;
-    void create_state(IStateManager &state_manager, sf::VideoMode &mode, std::string &window_title) override;
-    void set_all_to_state() override;
-    std::unique_ptr<GameState> get_game() override;
-
-private:
-    float m_width;
-    float m_height;
-    float m_room_size;
-    std::vector<std::vector<std::unique_ptr<Room>>> m_rooms;
-    GameContext m_context;
-    std::unique_ptr<GameState> m_game_state;
-};
\ No newline at end of file

source/application/BobBuilder/GameBuilders.cpp

+#include "GameBuilders.h"
+
+void CommonBuilder::create_context(float dynamic_objects_ratio) {
+//    GameContext context;
+//    std::vector<Room*> buffer;
+//    //проходимся по комнатам, если она пустая то добавляем в buffer
+//    for (auto& row : m_rooms) {
+//        for (auto& room : row) {
+//            if (room != nullptr)
+//                buffer.emplace_back(room);
+//        }
+//    }
+//
+//    int id = rand() % buffer.size();
+//    //помещаем пакмана в рандомную комнату и удаляем ее из буфера
+//    m_context.pacman.set_location(buffer[id]);
+//    auto it = buffer.begin();
+//    for (int i = 0; i < id; i++, it++);
+//    buffer.erase(it);
+//
+//    for (auto it = buffer.begin(); it != buffer.end(); it++) {
+//        auto food = std::make_unique<Food>();
+////        food->set_location();
+//        context.static_objects.emplace_back(std::move(food));
+//    }
+//
+//    buffer.clear();
+//    m_context = std::move(context);
+}
+
+void CommonBuilder::create_state(IStateManager &state_manager, sf::VideoMode &mode, 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& col : row)
+            rooms.emplace_back(std::move(col));
+    m_game_state->set_maze(Maze(std::move(rooms)));
+    m_game_state->set_context(std::move(m_context));
+}
+
+std::unique_ptr<GameState> CommonBuilder::get_game() {
+    return std::move(m_game_state);
+}
+
+void SimpleBuilder::create_context(float dynamic_objects_ratio) {
+    GameContext context;
+    std::vector<Room*> buffer;
+    //проходимся по комнатам, если она пустая то добавляем в buffer
+    for (auto& row : m_rooms) {
+        for (auto& room : row) {
+            if (room != nullptr)
+                buffer.emplace_back(room);
+        }
+    }
+
+    int id = rand() % buffer.size();
+    //помещаем пакмана в рандомную комнату и удаляем ее из буфера
+    m_context.pacman.set_location(buffer[id]);
+    auto it = buffer.begin();
+    for (int i = 0; i < id; i++, it++);
+    buffer.erase(it);
+
+    for (auto it = buffer.begin(); it != buffer.end(); it++) {
+        auto food = std::make_unique<Food>();
+        food->set_location(buffer[id]);
+        context.static_objects.emplace_back(std::move(food));
+    }
+
+    buffer.clear();
+    m_context = std::move(context);
+}
+
+void SimpleBuilder::create_rooms() {
+    size_t room_col = m_width / m_room_size;
+    size_t room_row = m_height / m_room_size;
+
+    int room_size = static_cast<int>(m_room_size);
+    auto starting_point = sf::Vector2f{(m_width - m_room_size*room_col)/2 + m_room_size/2, (m_height - m_room_size*room_row)/2 + + m_room_size/2};
+
+    for (int row = 0; row < room_row * room_size; row += room_size) {
+        std::vector<Room*> vector_row;
+        for (int col = 0; col < room_col * room_size; col += room_size) {
+            auto room = new Room(m_room_size);
+            room->set_position(sf::Vector2f {(col + starting_point.x), (row + starting_point.y)});
+            vector_row.emplace_back(room);
+        }
+        m_rooms.emplace_back(std::move(vector_row));
+    }
+}
+
+void SimpleBuilder::set_rooms_sides() {
+
+}
+
+void ComplexBuilder::create_rooms() {
+
+}
+
+void ComplexBuilder::set_rooms_sides() {
+
+}
\ No newline at end of file

source/application/BobBuilder/SimpleGameBuilder.h → source/application/BobBuilder/GameBuilders.h

 #pragma once
 #include "IGameBuilder.h"
 #include "../Context/Context.h"
+#include "../../../workdir/config.h"
 
-class SimpleBuilder : public IGameBuilder {
+class CommonBuilder : public IGameBuilder {
 public:
-    SimpleBuilder(float width, float height, float room_size) : m_width(width), m_height(height), m_room_size(room_size) {};
-    void create_rooms() override;
-    void set_rooms_sides() override;
     void create_context(float dynamic_objects_ratio);
     void create_state(IStateManager& state_manager, sf::VideoMode& mode, std::string& window_title);
     void set_all_to_state();
     std::unique_ptr<GameState> get_game() override;
 
+protected:
+    float m_width;
+    float m_height;
+    float m_room_size;
+    std::vector<std::vector<Room*>> m_rooms;
+    GameContext m_context;
+    std::unique_ptr<GameState> m_game_state;
+};
+
+class SimpleBuilder : public CommonBuilder {
+public:
+    void create_context(float dynamic_objects_ratio);
+    SimpleBuilder(float width, float height, float room_size) : m_width(width), m_height(height), m_room_size(room_size) {};
+    void create_rooms() override;
+    void set_rooms_sides() override;
 private:
     float m_width;
     float m_height;
     float m_room_size;
-    std::vector<std::vector<std::unique_ptr<Room>>> m_rooms;
+    std::vector<std::vector<Room*>> m_rooms;
     GameContext m_context;
     std::unique_ptr<GameState> m_game_state;
+};
+
+class ComplexBuilder : public CommonBuilder {
+public:
+    void create_rooms() override;
+    void set_rooms_sides() override;
 };
\ No newline at end of file

source/application/BobBuilder/SimpleGameBuilder.cpp

-#include "SimpleGameBuilder.h"
-
-void SimpleBuilder::create_rooms() {
-    //@todo
-}
-
-void SimpleBuilder::set_rooms_sides() {
-    //@todo
-}
-
-void SimpleBuilder::create_context(float dynamic_objects_ratio) {
-    //@todo
-}
-
-void SimpleBuilder::create_state(IStateManager &state_manager, sf::VideoMode &mode, std::string &window_title) {
-    //@todo
-}
-
-void SimpleBuilder::set_all_to_state() {
-    //@todo
-}
-
-std::unique_ptr<GameState> SimpleBuilder::get_game() {
-    return std::move(m_game_state);
-}
\ No newline at end of file

source/application/Context/Context.cpp

@@ -2,13 +2,13 @@
 
 GameContext GameContext::clone() {
     GameContext context;
-    context.pacman = pacman;
+    context.pacman = std::move(pacman);
     context.state = state;
-    for (auto& s_o : static_objects) {
-        context.static_objects.emplace_back(s_o->clone());
+    for (auto& obj : static_objects) {
+        context.static_objects.emplace_back(obj->clone());
     }
-    for (auto& d_o : dynamic_objects) {
-        context.dynamic_objects.emplace_back(d_o->clone());
+    for (auto& obj : dynamic_objects) {
+        context.dynamic_objects.emplace_back(obj->clone());
     }
     return context;
 }

source/application/Drawable/DrawMenu/Menu/Menu.cpp

 #include "Menu.h"
 #include "../../../../../workdir/config.h"
-#include "../../../BobBuilder/SimpleGameBuilder.h"
+#include "../../../BobBuilder/GameBuilders.h"
 #include <memory>
 
 Menu::Menu(IStateManager& state_manager) {

source/application/Drawable/Entity/IEntity.cpp

 #include "IEntity.h"
 #include "../../../../workdir/config.h"
+#include "../Maze/Maze.h"
+
+void IEntity::set_location(Room* ptr_room) {
+    m_ptr_room = ptr_room;
+}
 
 Food::Food() {
     //@todo
-    m_shape = sf::CircleShape(config::GAME_FOOD_SIZE, 10);
+    m_shape = sf::CircleShape(config::GAME_FOOD_SIZE, 30);
 }
 
 std::unique_ptr<IStaticEntity> Food::clone() const {

source/application/Drawable/Entity/IEntity.h

@@ -6,10 +6,10 @@ class Room;
 
 class IEntity: public IPreparable {
 public:
-    void set_location(Room* ptr_room) { m_ptr_room = ptr_room; }
-    Room* get_location() { return m_ptr_room; } //@todo unique_ptr
+    void set_location(Room* ptr_room);
+    Room* get_location() { return m_ptr_room; }
 protected:
-    Room* m_ptr_room; //@todo unique_ptr
+    Room* m_ptr_room;
 };
 
 class IStaticEntity : public IEntity {
@@ -37,6 +37,7 @@ private:
 class Food: public IStaticEntity {
 public:
     Food();
+    Food(const Food& food) = default;
     void draw_into(sf::RenderWindow& window) const override;
     void prepare_for_drawing() override;
     std::unique_ptr<IStaticEntity> clone() const override;

source/application/Drawable/Entity/Pacman.cpp

@@ -8,7 +8,7 @@ Pacman::Pacman() {
 
 void Pacman::move(Room::Direction direction) {
     //@todo move pacman
-//    m_ptr_room->get_side(direction)->enter(*this);
+    m_ptr_room->get_side(direction)->enter(this);
 }
 
 void Pacman::draw_into(sf::RenderWindow &window) const {

source/application/Drawable/Maze/Maze.cpp

@@ -12,11 +12,11 @@ void Room::set_side(Direction side, std::shared_ptr<IRoomSide> ptr_side) {
     }
 }
 
-Room::Direction Room::get_direction(IRoomSide* ptr_side) {
-    if (m_sides[LEFT].get() == ptr_side) return LEFT;
-    if (m_sides[RIGHT].get() == ptr_side) return RIGHT;
-    if (m_sides[UP].get() == ptr_side) return UP;
-    if (m_sides[DOWN].get() == ptr_side) return DOWN;
+Room::Direction Room::get_direction(std::shared_ptr<IRoomSide> ptr_side) {
+    if (m_sides[LEFT] == ptr_side) return LEFT;
+    if (m_sides[RIGHT] == ptr_side) return RIGHT;
+    if (m_sides[UP] == ptr_side) return UP;
+    if (m_sides[DOWN] == ptr_side) return DOWN;
     else return INVALID;
 }
 

source/application/Drawable/Maze/Maze.h

@@ -19,8 +19,8 @@ public:
     void set_position(sf::Vector2f pos) { m_rectangle.setPosition(pos); }
     sf::Vector2f get_position() { return m_rectangle.getPosition(); }
     void set_side(Direction side, std::shared_ptr<IRoomSide> ptr_side);
-    IRoomSide* get_side(Direction side) { return m_sides[side].get(); }
-    Direction get_direction(IRoomSide* ptr_side);
+    std::shared_ptr<IRoomSide> get_side(Direction side) { return m_sides[side]; }
+    Direction get_direction(std::shared_ptr<IRoomSide> ptr_side);
     void draw_into(sf::RenderWindow& m_window) const override;
 
 public:
@@ -31,7 +31,7 @@ public:
 class Maze: public IDrawable {
 public:
     Maze() = default;
-    Maze(std::vector<std::unique_ptr<Room>>& rooms) : m_rooms(std::move(rooms)) {};
+    Maze(std::vector<std::unique_ptr<Room>> rooms) : m_rooms(std::move(rooms)) {};
     void draw_into(sf::RenderWindow& m_window) const override;
 private:
     std::vector<std::unique_ptr<Room>> m_rooms;

source/application/SelectCommand/ISelectCommand.h

@@ -31,7 +31,7 @@ public:
             ChangeStateCommand(state_manager), m_ptr_director(std::move(ptr_director)) {};
     void execute() override {
         auto state = m_ptr_director->build(m_state_manager);
-//        m_state_manager.set_next_state(std::move(state)); //@todo
+        m_state_manager.set_next_state(std::move(state));
     };
 
 private:

source/application/State/GameState.cpp

@@ -7,20 +7,72 @@ GameState::GameState(IStateManager &state_manager, const sf::VideoMode &video_mo
 
 void GameState::event_handling() {
     sf::Event event;
-    //@todo write event handling
     while (m_window.pollEvent(event)) {
         if (event.type == sf::Event::Closed) {
-            //m_state_manager.set_next_state(std::make_unique<SelectState>(m_state_manager,  m_window, config::SELECT_LEVEL_TITLE));
+            m_state_manager.set_next_state(std::make_unique<SelectState>(m_state_manager,  config::GAME_VIDEO_MODE, config::SELECT_LEVEL_TITLE));
+        }
+        if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Z) {
+            m_context_manager.restore_previous_context();
+        }
+        if (event.type == sf::Event::KeyPressed && m_context_manager.get_current_context().state  == GameContext::INGAME) {
+            process_key_pressed(event.key.code);
         }
     }
 }
 
+void GameState::process_key_pressed(sf::Keyboard::Key code) {
+    switch (code) {
+        case sf::Keyboard::W:
+            m_context_manager.save_current_context();
+            m_context_manager.get_current_context().pacman.move(Room::UP);
+            break;
+        case sf::Keyboard::S:
+            m_context_manager.save_current_context();
+            m_context_manager.get_current_context().pacman.move(Room::DOWN);
+            break;
+        case sf::Keyboard::A:
+            m_context_manager.save_current_context();
+            m_context_manager.get_current_context().pacman.move(Room::LEFT);
+            break;
+        case sf::Keyboard::D:
+            m_context_manager.save_current_context();
+            m_context_manager.get_current_context().pacman.move(Room::RIGHT);
+            break;
+    }
+
+};
 void GameState::update() {
+    if (m_context_manager.get_current_context().state != GameContext::INGAME) return;
+
+    GameContext& context = m_context_manager.get_current_context();
+    for (auto& entity : context.dynamic_objects)
+        entity->action();
+
     //@todo
+
 }
 
 void GameState::render() {
-    //@todo
+    GameContext& context = m_context_manager.get_current_context();
+    switch (context.state) {
+        case GameContext::INGAME:
+            m_window.clear(config::GAME_COLOR_BACKGROUND_INGAME);
+            break;
+        case GameContext::LOST:
+            m_window.clear(config::GAME_COLOR_BACKGROUND_LOST);
+            break;
+        default:
+            m_window.clear(config::GAME_COLOR_BACKGROUND_WIN);
+    }
+
+    m_maze.draw_into(m_window);
+    for (auto& el: context.static_objects)
+        el->draw_into(m_window);
+
+    context.pacman.draw_into(m_window);
+    for (auto& el : context.dynamic_objects)
+        el->draw_into(m_window);
+    m_window.display();
 }
 
 bool GameState::do_step() {

source/application/State/GameState.h

@@ -13,6 +13,7 @@ public:
 
     void set_maze(Maze&& maze) {m_maze = std::move(maze); }
     void set_context(GameContext&& context);
+    void process_key_pressed(sf::Keyboard::Key code);
 private:
     Maze m_maze;
     ContextManager m_context_manager;

source/application/State/SelectState.cpp

@@ -9,7 +9,6 @@ SelectState::SelectState(IStateManager& state_manager,
 void SelectState::event_handling() {
     sf::Event event;
     while (m_window.pollEvent(event)) {
-        //@todo finish event handling
         if (event.type == sf::Event::Closed) {
             m_state_manager.set_next_state(std::make_unique<ExitState>(m_state_manager));
             break;