Maze, room, IEntity, RoomSide were added + some fixes

CMakeLists.txt

@@ -12,4 +12,6 @@ FetchContent_Declare(SFML GIT_REPOSITORY https://github.com/SFML/SFML.git GIT_TA
 FetchContent_MakeAvailable(SFML)
 
 add_executable(${PROJECT_NAME} ${SOURCES})
+target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_SOURCE_DIR}/source)
+
 target_link_libraries(${PROJECT_NAME} PRIVATE sfml-system sfml-window sfml-graphics)
\ No newline at end of file

source/Application/Application.cpp

 #include "Application.h"
-#include <iostream> /// @todo избвится
+#include <iostream>
 
 void Application::apply_deffer_state_change() {
     if (m_ptr_state_next)

source/Application/Application.h

 #pragma once
-#include "../States/SelectState/SelectState.h"
-#include "../Configuration.h"
+#include <States/SelectState/SelectState.h>
 
 class Application : public IStateManager {
 public:

source/BasicAbstractions/Font.h

 #pragma once
-#include "../Configuration.h"
+#include <Configuration.h>
 
 class MyFont {
 public:

source/Application/IWindowKeeper.h → source/BasicAbstractions/IWindowKeeper.h

 #pragma once
-#include <SFML/Graphics.hpp>
+#include <Configuration.h>
 
 class IWindowKeeper {
 public:
-    IWindowKeeper(const sf::VideoMode& video_mode, const sf::String& window_title) : m_window(video_mode, window_title) {}
+    IWindowKeeper(const sf::VideoMode& video_mode, const sf::String& window_title) : m_window(video_mode, window_title) {
+        m_window.setFramerateLimit(config::FRAME_RATE_LIMIT);
+    }
     virtual ~IWindowKeeper() = default;
 protected:
     virtual void event_handling() = 0;

source/States/ChangeStateCommand.h

 #pragma once
-#include "../BasicAbstractions/Command.h"
-#include "../Application/IState.h"
-#include "ExitState/ExitState.h"
+#include <BasicAbstractions/Command.h>
+#include <BasicAbstractions/IState.h>
+#include <States/ExitState/ExitState.h>
 
 struct ChangeStateCommand : ISelectCommand {
     explicit ChangeStateCommand(IStateManager& state_manager) : m_state_manager(state_manager) {}

source/States/ExitState/ExitState.h

 #pragma once
-#include "../../Application/IState.h"
+#include <BasicAbstractions/IState.h>
 
 struct ExitState : IState {
     using IState::IState;

source/States/GameState/Entities/IEntity.h

+#pragma once
+#include <States/GameState/IPreparable.h>
+#include <States/GameState/Maze/Room.h>
+
+class IEntity : public IPreparable {
+public:
+    void set_location(Room* ptr_room) { m_ptr_room = ptr_room; }
+    [[nodiscard]] Room* get_location() const { return m_ptr_room; }
+    ~IEntity() override = default;
+protected:
+    Room* m_ptr_room = nullptr;
+};
\ No newline at end of file

source/States/GameState/GameState.cpp

 #include "GameState.h"
 #include <iostream> /// @todo remove it
-#include "../ExitState/ExitState.h"
+#include <States/ExitState/ExitState.h>
 
 bool GameState::do_step() {
     std::cout << "Game state" << std::endl;

source/States/GameState/GameState.h

 #pragma once
-#include "../../Application/IState.h"
-#include "../../Application/IWindowKeeper.h"
+#include <BasicAbstractions/IState.h>
+#include <BasicAbstractions/IWindowKeeper.h>
 
 struct GameState : IState, IWindowKeeper {
     explicit GameState(IStateManager& state_manager, const sf::VideoMode& video_mode, const sf::String& window_title) : IState(state_manager), IWindowKeeper(video_mode, window_title) {}

source/States/GameState/IPreparable.h

+#pragma once
+#include <BasicAbstractions/IDrawable.h>
+
+struct IPreparable : IDrawable {
+    virtual void prepare_for_drawing() = 0;
+    ~IPreparable() override = default;
+};
\ No newline at end of file

source/States/GameState/Maze/Maze.cpp

+#include <States/GameState/Maze/Maze.h>
+
+void Maze::draw_into(sf::RenderWindow& window) const {
+    for (const auto& room : m_rooms)
+        room->draw_into(window);
+}
\ No newline at end of file

source/States/GameState/Maze/Maze.h

+#pragma once
+
+#include <States/GameState/Maze/Room.h>
+
+#include <vector>
+
+class Maze : public IDrawable {
+public:
+    explicit Maze(std::vector<std::unique_ptr<Room>> rooms) : m_rooms(std::move(rooms)) {}
+    void draw_into(sf::RenderWindow& window) const override;
+private:
+    std::vector<std::unique_ptr<Room>> m_rooms;
+};
\ No newline at end of file

source/States/GameState/Maze/Room.cpp

+#include <States/GameState/Maze/Room.h>
+
+Room::Room(float size) : m_rectangle({size, size}) {
+    m_rectangle.setOrigin(size/2, size/2);
+}
+
+void Room::set_side(const Direction side, std::unique_ptr<IRoomSide>&& ptr_side) {
+    if (side == INVALID) throw std::invalid_argument("Invalid direction");
+    m_sides[side] = std::move(ptr_side);
+}
+
+Room::Direction Room::get_direction(const IRoomSide* ptr_side) const {
+    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;
+    return INVALID;
+}
+
+void Room::draw_into(sf::RenderWindow& window) const {
+    window.draw(m_rectangle);
+    for (auto& side : m_sides) {
+        side->draw_into(window);
+    }
+}
+

source/States/GameState/Maze/Room.h

+#pragma once
+
+#include <States/GameState/IPreparable.h>
+#include <States/GameState/Maze/RoomSide.h>
+
+#include <array>
+
+struct IRoomSide;
+
+class Room: public IDrawable {
+public:
+    enum Direction { INVALID = -1, LEFT, RIGHT, UP, DOWN };
+    explicit Room(float size);
+    float get_size() const { return m_rectangle.getSize().x; }
+    void set_position(const sf::Vector2f pos) { m_rectangle.setPosition(pos); }
+    sf::Vector2f get_position() const { return m_rectangle.getPosition(); }
+    void set_side(Direction side, std::unique_ptr<IRoomSide>&& ptr_side);
+    IRoomSide* get_side(const Direction side) const { return m_sides[side].get(); }
+    Direction get_direction(const IRoomSide* ptr_side) const;
+    void draw_into(sf::RenderWindow& window) const override;
+private:
+    sf::RectangleShape m_rectangle;
+    std::array<std::unique_ptr<IRoomSide>, 4> m_sides;
+};
+

source/States/GameState/Maze/RoomSide.cpp

+#include <States/GameState/Entities/IEntity.h>
+
+void Pass::enter(IEntity* entity) const {
+    if (entity->get_location() == &m_room1)
+        entity->set_location(&m_room2);
+    else entity->set_location(&m_room1);
+}
\ No newline at end of file

source/States/GameState/Maze/RoomSide.h

+#pragma once
+#include <States/GameState/IPreparable.h>
+
+class IEntity;
+class Room;
+
+struct IRoomSide : IPreparable {
+    virtual void enter(IEntity* entity) const = 0;
+    ~IRoomSide() override = default;
+};
+
+class Pass : public IRoomSide {
+public:
+    explicit Pass(Room& room1, Room& room2) : m_room1(room1), m_room2(room2) {}
+    void enter(IEntity* entity) const override;
+    void draw_into(sf::RenderWindow& window) const override {}
+    void prepare_for_drawing() override {}
+private:
+    Room& m_room1;
+    Room& m_room2;
+};
+
+class Wall : public IRoomSide {
+public:
+    explicit Wall(Room& room) : m_room(room) {}
+    void enter(IEntity* entity) const override {}
+    void draw_into(sf::RenderWindow& window) const override { window.draw(m_line, 2, sf::Lines); }
+    void prepare_for_drawing() override {} /// @todo разобраться, что тут делать
+private:
+    Room& m_room;
+    sf::Vertex m_line[2];
+};
\ No newline at end of file

source/States/SelectState/SelectState.cpp

 #include "SelectState.h"
-#include "../ChangeStateCommand.h"
-#include "../../Configuration.h"
-#include "../../BasicAbstractions/Font.h"
+#include <States/ChangeStateCommand.h>
+#include <BasicAbstractions/Font.h>
 
 void Button::set(const sf::Vector2f pos, const sf::Vector2f size, const std::string& text, const size_t font_size, std::unique_ptr<ISelectCommand> ptr_command) {
     m_rectangle.setSize(size);
@@ -102,7 +101,6 @@ void SelectState::render() {
 }
 
 bool SelectState::do_step() {
-    m_window.setFramerateLimit(config::FRAME_RATE_LIMIT);
     while (m_window.isOpen()) {
         event_handling();
         update();

source/States/SelectState/SelectState.h

 #pragma once
-#include "../../Application/IState.h"
-#include "../../Application/IWindowKeeper.h"
-#include "../../BasicAbstractions/IDrawable.h"
-#include "../../BasicAbstractions/Command.h"
+#include <BasicAbstractions/IState.h>
+#include <BasicAbstractions/IWindowKeeper.h>
+#include <BasicAbstractions/IDrawable.h>
+#include <BasicAbstractions/Command.h>
 
 class Button: public IDrawable {
 public: