Pacman and food are drawing now at easy level

CMakeLists.txt

@@ -11,6 +11,7 @@ add_executable(game_pacman main.cpp "Sources/Application/App_n_IState.cpp" "Sour
 									"Sources/Button/Button.cpp" "Sources/SelectCommand/SelectCommand.cpp"
 									"Sources/Font/MyFont.cpp" "Sources/Menu/Menu.cpp" "Sources/Room/Room.cpp"
 									"Sources/Entities/Entities.cpp" "Sources/Context/Context.cpp" "config.h" 
-									"Sources/States/Select.cpp" "Sources/Builders/Game.cpp")
+									"Sources/States/Select.cpp" "Sources/Builders/Game_n_common.cpp" 
+									"Sources/Entities/Pacman.cpp"  )
 
 target_link_libraries(game_pacman PUBLIC sfml-window sfml-graphics sfml-system)
\ No newline at end of file

Sources/Application/App_n_IState.cpp

 #include "App_n_IState.h"
 #include <iostream>
 
-Application::Application(): m_ptr_state_current(std::make_unique<SelectState>(*this, config::SELECT_LEVEL_VIDEO_MODE, config::SELECT_LEVEL_TITLE)) {}
+Application::Application(): m_ptr_state_current(std::make_unique<SelectState>(*this, config::SELECT_LEVEL_VIDEO_MODE, config::SELECT_LEVEL_TITLE)) { srand(time(NULL)); }
 
 
 int Application::run() {

Sources/Builders/Game.cpp

-#include "Game.h"
-

Sources/Builders/Game.h

-#pragma once
-
-#include <memory>
-#include "SFML/Graphics.hpp"
-
-class IGameBuilder {};
-
-class GameBuilderDirector {
-public:
-	GameBuilderDirector() = default; //УБРАТЬ - временный костыль, чтобы конструктор меню работал
-	GameBuilderDirector(std::unique_ptr<IGameBuilder>&& ptr_builder, const sf::VideoMode& mode, const std::string& window_title, float dynamic_objects_ratio) {}
-};
-
-class SimpleBuilder {};
-class ComplexBuilder {};
\ No newline at end of file

Sources/Builders/Game_n_common.cpp

+#include "Game_n_common.h"
+
+//COMMON_BUILDER
+CommonBuilder::CommonBuilder(float width, float height, float room_size) : m_width(width), m_height(height), m_room_size(room_size) {}
+
+void CommonBuilder::create_context(float dynamic_object_ratio) {
+
+    std::vector<Room*> buf;
+    for (auto& row : m_rooms) {
+        for (auto& room : row) {
+            if (room != nullptr) {  //если комната существует(то есть мы ее заполнили на этапе create rooms)
+                buf.emplace_back(room);
+            }
+        }
+    }
+
+	
+    //определяем положение пакмена
+    int pos = std::rand() % buf.size();
+    m_context.pacman.set_location(buf.at(pos));
+    auto iter = buf.begin() + pos;
+    buf.erase(iter);
+
+    //располагаем врагов
+    for (size_t i = 0; i < static_cast<size_t>(m_width * m_height * dynamic_object_ratio); ++i) {
+        pos = std::rand() % buf.size();
+        m_context.dynamic_objects.emplace_back(std::move(std::make_unique<Enemy>()));
+        m_context.dynamic_objects.back()->set_location(buf.at(pos));
+
+        iter = buf.begin() + pos;
+        buf.erase(iter);
+
+    }
+
+    //располагаем еду
+    for (size_t i = 0; i < buf.size(); ++i) {
+        m_context.static_objects.emplace_back(std::move(std::make_unique<Food>()));
+        m_context.static_objects.back()->set_location(buf.at(i));
+    }
+
+    buf.clear();
+}
+
+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);
+}
+
+std::unique_ptr<GameState> CommonBuilder::get_game() {
+    return std::move(m_game_state);
+}
+
+void CommonBuilder::set_all_to_state() {
+    std::vector<std::unique_ptr<Room>> rooms;
+    for (auto& row: m_rooms) { //превращаем указатель в unique
+        for (auto& room: row) {
+            rooms.emplace_back(std::move(room));
+        }
+    }
+    m_game_state->set_maze(Maze(std::move(rooms)));
+    m_game_state->set_context(std::move(m_context));
+}
+
+
+//GAME_BUILDER_DIRECTOR
+GameBuilderDirector::GameBuilderDirector(std::unique_ptr<IGameBuilder>&& ptr_builder, const sf::VideoMode& mode, const std::string& window_title, float dynamic_objects_ratio): 
+    m_ptr_builder(std::move(ptr_builder)), m_mode(mode), m_window_title(window_title), m_dynamic_object_ratio(dynamic_objects_ratio) {}
+
+
+std::unique_ptr<GameState> GameBuilderDirector::build(IStateManager& state_manager) {
+	m_ptr_builder->create_rooms();
+	m_ptr_builder->set_rooms_side();
+    m_ptr_builder->create_context(m_dynamic_object_ratio);
+    m_ptr_builder->create_state(state_manager, m_mode, m_window_title);
+    m_ptr_builder->set_all_to_state();
+
+    return m_ptr_builder->get_game();
+}
+
+
+//SIMPLE
+SimpleBuilder::SimpleBuilder(float width, float height, float room_size) : CommonBuilder(width, height, room_size) {}
+
+void SimpleBuilder::create_rooms() {
+	size_t rooms_in_row = static_cast<size_t>(m_width / m_room_size);
+	size_t rooms_in_col = static_cast<size_t>(m_height / m_room_size);
+	float top_gap = (m_height - rooms_in_col * m_room_size) / 2 + m_room_size / 2;	//+m_room_size/2 из-за setorigin
+	float left_gap = (m_width - rooms_in_row * m_room_size) / 2 + m_room_size / 2;
+
+	for (size_t i = 0; i < rooms_in_col; ++i) {
+		std::vector<Room*> row;
+		for (size_t j = 0; j < rooms_in_row; ++j) {
+			Room* room = new Room(m_room_size);
+			room->set_position({ left_gap + m_room_size * j, top_gap + m_room_size * i });
+			row.emplace_back(std::move(room));
+		}
+		m_rooms.emplace_back(std::move(row));
+	}
+}
+
+void SimpleBuilder::set_rooms_side() {
+	size_t rooms_in_row = static_cast<size_t>(m_width / m_room_size);
+	size_t rooms_in_col = static_cast<size_t>(m_height / m_room_size);
+
+	std::shared_ptr<IRoomSide> side;
+	for (size_t i = 0; i < rooms_in_col; ++i) {
+		for (size_t j = 0; j < rooms_in_row; ++j) {
+			if (i == 0) {
+				side = std::make_shared<Wall>(*m_rooms.at(i).at(j));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::UP, side);
+				m_rooms.at(i).at(j)->get_side(Room::Direction::UP)->prepare_for_drawing();
+			}
+			else {
+				side = std::make_shared<Pass>(*m_rooms.at(i).at(j), *m_rooms.at(i - 1).at(j));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::UP, side);
+			}
+
+			if (i == rooms_in_col - 1) {
+				side = std::make_shared<Wall>(*m_rooms.at(i).at(j));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::DOWN, side);
+				m_rooms.at(i).at(j)->get_side(Room::Direction::DOWN)->prepare_for_drawing();
+			}
+			else {
+				side = std::make_shared<Pass>(*m_rooms.at(i).at(j), *m_rooms.at(i + 1).at(j));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::DOWN, side);
+			}
+
+			if (j == 0) {
+				side = std::make_shared<Wall>(*m_rooms.at(i).at(j));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::LEFT, side);
+				m_rooms.at(i).at(j)->get_side(Room::Direction::LEFT)->prepare_for_drawing();
+			}
+			else {
+				side = std::make_shared<Pass>(*m_rooms.at(i).at(j), *m_rooms.at(i).at(j - 1));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::LEFT, side);
+			}
+
+			if (j == rooms_in_row - 1) {
+				side = std::make_shared<Wall>(*m_rooms.at(i).at(j));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::RIGHT, side);
+				m_rooms.at(i).at(j)->get_side(Room::Direction::RIGHT)->prepare_for_drawing();
+			}
+			else {
+				side = std::make_shared<Pass>(*m_rooms.at(i).at(j), *m_rooms.at(i).at(j + 1));
+				m_rooms.at(i).at(j)->set_side(Room::Direction::RIGHT, side);
+			}
+		}
+	}
+}
+
+//COMPLEX
+ComplexBuilder::ComplexBuilder(float width, float height, float room_size) : CommonBuilder(width, height, room_size) {}
+
+void ComplexBuilder::create_rooms() {
+	
+}	
+
+void ComplexBuilder::set_rooms_side() {
+
+}
\ No newline at end of file

Sources/Builders/Game_n_common.h

+#pragma once
+
+#include <memory>
+#include "SFML/Graphics.hpp"
+
+#include "../States/States.h" //для Gamestate
+#include "../States/IState.h"
+#include "../Room/Room.h"
+#include "../Context/Context.h"
+
+class GameState;
+
+class IGameBuilder {
+public:
+	virtual void create_rooms() = 0;
+	virtual void set_rooms_side() = 0;
+	virtual void create_context(float dynamic_object_ratio) = 0;
+	virtual void create_state(IStateManager& state_manager, const sf::VideoMode& mode, const std::string& window_title) = 0;
+	virtual void set_all_to_state() = 0;
+	virtual std::unique_ptr<GameState> get_game() = 0;
+	virtual ~IGameBuilder() = default;
+};
+
+
+class CommonBuilder: public IGameBuilder {
+public:
+	CommonBuilder(float width, float height, float room_size);
+
+	void create_context(float dynamic_object_ratio) override;
+	void create_state(IStateManager& state_manager, const sf::VideoMode& mode, const std::string& window_title) override;
+	std::unique_ptr<GameState> get_game() override;
+	void set_all_to_state() override;
+
+protected:
+	float m_width;
+	float m_height;
+	float m_room_size;
+	std::vector<std::vector<Room*>> m_rooms;
+
+private:
+	GameContext m_context;
+	std::unique_ptr<GameState> m_game_state;
+};
+
+
+class GameBuilderDirector {
+public:
+	GameBuilderDirector(std::unique_ptr<IGameBuilder>&& ptr_builder, const sf::VideoMode& mode, const std::string& window_title, float dynamic_objects_ratio);
+	
+	std::unique_ptr<GameState> build(IStateManager& state_manager);
+
+private:
+	std::string m_window_title;
+	sf::VideoMode m_mode;
+	float m_dynamic_object_ratio;
+	std::unique_ptr<IGameBuilder> m_ptr_builder;
+};
+
+
+
+
+class SimpleBuilder : public CommonBuilder {
+public:
+	SimpleBuilder(float width, float height, float room_size);
+
+	void create_rooms() override;
+	void set_rooms_side() override;
+};
+
+
+class ComplexBuilder : public CommonBuilder {
+public:
+	ComplexBuilder(float width, float height, float room_size);
+
+	void create_rooms() override;	//РЕАЛИЗОВАТЬ
+	void set_rooms_side() override;	//РЕАЛИЗОВАТЬ
+};
\ No newline at end of file

Sources/Button/Button.h

@@ -7,6 +7,7 @@
 #include "../../config.h"
 #include "../Font/MyFont.h"
 
+class ISelectCommand;
 
 class Button: public IDrawable {
 public:

Sources/Context/Context.cpp

 #include "Context.h"
 
+//CONTEXT
+GameContext GameContext::clone() {
+    GameContext context;
+    context.pacman = std::move(pacman);
+    context.state = state;
+
+    for (auto& dyn: dynamic_objects) {
+        context.dynamic_objects.emplace_back(dyn->clone());
+    }
+
+    for (auto& stat: static_objects) {
+        context.static_objects.emplace_back(stat->clone());
+    }
+    return context;
+}
+
+
 //CONTEXTMANAGER
-//void ContextManager::restore_previous_context() {
-//	if (m_contexts.size() > 1){
-//		m_contexts.pop(); 
-//	}
-//	else {
-//		m_contexts.top() = m_initial_context.clone();
-//	}
-//}
\ No newline at end of file
+void ContextManager::restore_previous_context() {
+	if (m_contexts.size() > 1){
+		m_contexts.pop(); 
+	}
+	else {
+		m_contexts.top() = m_initial_context.clone();
+	}
+}
+
+void ContextManager::reset(GameContext&& context) {
+    m_initial_context = std::move(context);
+}
+
+GameContext& ContextManager::get_current_context() {
+    if (m_contexts.empty()) return m_initial_context;
+    return m_contexts.top();
+}
+
+void ContextManager::save_current_context() {
+    m_contexts.push(m_initial_context.clone());
+}

Sources/Context/Context.h

@@ -2,27 +2,33 @@
 
 #include <stack>
 #include <memory>
+#include <vector>
 
-//class GameContext {
-//public:
-//	GameContext clone();	//РЕАЛИЗОВАТЬ
-//
-//public:
-//	std::unique_ptr<Pacman> pacman;
-//	std::vector<std::unique_ptr<IStaticEntity>> static_objects;
-//	std::vector<std::unique_ptr<IDynamicEntity>> dynamic_objects;
-//	enum State { INGAME, WIN, LOST } state = INGAME;
-//};
-//
-//
-//class ContextManager {
-//public:
-//	void reset(GameContext&& context);	//РЕАЛИЗОВАТЬ
-//	GameContext& get_current_context();	//РЕАЛИЗОВАТЬ
-//	void save_current_context();	//РЕАЛИЗОВАТЬ
-//	void restore_previous_context();	//РЕАЛИЗОВАТЬ
-//
-//private:
-//	std::unique_ptr<GameContext> m_initial_context;
-//	std::stack<GameContext> m_contexts;
-//};
\ No newline at end of file
+//#include "../Entities/Entities.h" //ОНИ ТУТ ЕСТЬ
+#include "../Entities/Pacman.h"
+
+class Pacman;
+
+class GameContext {
+public:
+	GameContext clone();
+
+public:
+	Pacman pacman;
+	std::vector<std::unique_ptr<IStaticEntity>> static_objects;
+	std::vector<std::unique_ptr<IDynamicEntity>> dynamic_objects;
+	enum State { INGAME, WIN, LOST } state = INGAME;
+};
+
+
+class ContextManager {
+public:
+	void reset(GameContext&& context);	
+	GameContext& get_current_context();	
+	void save_current_context();	
+	void restore_previous_context();	
+
+private:
+	GameContext m_initial_context;
+	std::stack<GameContext> m_contexts;
+};
\ No newline at end of file

Sources/Entities/Entities.cpp

 #include "Entities.h"
 
+#include "../Room/Room.h"
+
 //IENTITY
-//void IEntity::set_location(Room* ptr_room) {
-//	m_ptr_room = ptr_room;
-//	this->prepare_for_drawing();	//отрисовываем себя
-//}
-//
-//Room* IEntity::get_location() {
-//	return m_ptr_room;
-//}
-//
-//
-////PACMAN
-//void Pacman::move(Room::Direction direction) {
-//	m_ptr_room->get_side(direction)->enter(this);
-//}
-//
-//
-////FOOD
-//std::unique_ptr<IStaticEntity> Food::clone() const {
-//	return std::make_unique<Food>(*this);
-//}
-//
-//
-////ENEMY
-//std::unique_ptr<IDynamicEntity> Enemy::clone() const {
-//	return std::make_unique<Enemy>(*this);
-//}
-//
-//
-//void Enemy::action() {
-//	auto miliseconds = static_cast<size_t>(m_stopwatch.getElapsedTime().asMilliseconds());	//получаем сколько прошло времени
-//	if (miliseconds < rand() % 10000) //если время меньше, чем случайное число до 10000 мс, то бездействие
-//		return;
-//	auto direction = static_cast<Room::Direction>(rand() % 4);
-//	m_ptr_room->get_side(direction)->enter(this);
-//	m_stopwatch.restart();	//запускаем секундомер сначала
-//}
\ No newline at end of file
+void IEntity::set_location(Room* ptr_room) {
+	m_ptr_room = ptr_room;
+	this->prepare_for_drawing();	//отрисовываем себя
+}
+
+Room* IEntity::get_location() {
+	return m_ptr_room;
+}
+
+
+//ENEMY
+Enemy::Enemy() {
+	m_circle = sf::CircleShape(config::GAME_ENEMY_SIZE);
+	m_circle.setOrigin({ config::GAME_ENEMY_SIZE/2, config::GAME_ENEMY_SIZE/2 });
+	m_circle.setFillColor(config::GAME_ENEMY_COLOR);
+}
+
+void Enemy::draw_into(sf::RenderWindow& window) const {
+	window.draw(m_circle);	
+}
+
+void Enemy::prepare_for_drawing() {	//prep drawing проходит в конце set_pos
+	m_circle.setPosition(m_ptr_room->get_position());	
+}
+
+std::unique_ptr<IDynamicEntity> Enemy::clone() const {
+	return std::make_unique<Enemy>(*this);
+}
+
+void Enemy::action() {
+	auto miliseconds = static_cast<size_t>(m_stopwatch.getElapsedTime().asMilliseconds());	//получаем сколько прошло времени
+	if (miliseconds < rand() % 10000) //если время меньше, чем случайное число до 10000 мс, то бездействие
+		return;
+	auto direction = static_cast<Room::Direction>(rand() % 4);
+	m_ptr_room->get_side(direction)->enter(this);
+	m_stopwatch.restart();	//запускаем секундомер сначала
+}
+
+std::unique_ptr<IGameEvent> Enemy::accept(IVisitor* ptr_visitor) {
+	return ptr_visitor->visit(this);
+}
+
+
+//FOOD
+Food::Food() {
+	m_circle = sf::CircleShape(config::GAME_FOOD_SIZE/2);
+	m_circle.setOrigin({ config::GAME_FOOD_SIZE/2, config::GAME_FOOD_SIZE/2 });
+	m_circle.setFillColor(config::GAME_FOOD_COLOR);
+}
+
+void Food::draw_into(sf::RenderWindow& window) const {
+	window.draw(m_circle);
+}
+
+void Food::prepare_for_drawing() {
+	m_circle.setPosition(m_ptr_room->get_position());
+}
+
+std::unique_ptr<IStaticEntity> Food::clone() const {
+	return std::make_unique<Food>(*this);
+}
+
+std::unique_ptr<IGameEvent> Food::accept(IVisitor* ptr_visitor) {
+	return ptr_visitor->visit(this);
+}
\ No newline at end of file

Sources/Entities/Entities.h

 #pragma once
 
-#include "../Room/Room.h"
-#include <memory> //УБРАТЬ
-
-//class IEntity : public IPreparable {	//мб entity отсюда надо убрать
-//public:
-//	void set_location(Room* ptr_room);
-//	Room* get_location();
-//
-//protected:
-//	Room* m_ptr_room;	//не unique тк room без него живет
-//};
-//
-//
-//class Pacman: public IEntity {
-//public:
-//	void move(Room::Direction direction); 
-//	void draw_into(sf::RenderWindow& window) const override; //РЕАЛИЗОВАТЬ
-//	void prepare_for_drawing() override; //РЕАЛИЗОВАТЬ
-//};
-//
-//
-//class IStaticEntity: public IEntity {
-//public:
-//	virtual ~IStaticEntity() = default;
-//
-//	virtual std::unique_ptr<IStaticEntity> clone() const = 0;
-//};
-//
-//
-//class IDynamicEntity: public IEntity {
-//public:
-//	virtual ~IDynamicEntity() = default;
-//
-//	virtual std::unique_ptr<IDynamicEntity> clone() const = 0;
-//	virtual void action() = 0;
-//};
-//
-//
-//class Food: public IStaticEntity {
-//public:
-//	void draw_into(sf::RenderWindow& window) const override;	//РЕАЛИЗОВАТЬ
-//	void prepare_for_drawing() override;	//РЕАЛИЗОВАТЬ
-//	std::unique_ptr<IStaticEntity> clone() const override;
-//};
-//
-//
-//class Enemy: public IDynamicEntity {
-//public:
-//	void draw_into(sf::RenderWindow& window) const override;	//РЕАЛИЗОВАТЬ
-//	void prepare_for_drawing() override;	//РЕАЛИЗОВАТЬ
-//	std::unique_ptr<IDynamicEntity> clone() const override;
-//	void action() override;
-//
-//private:
-//	sf::Clock m_stopwatch;
-//};
\ No newline at end of file
+//#include "../Room/Room.h"	//ОН ТУТ ЕСТЬ
+#include "../IDraw_n_IPrep/IDraw_n_IPrep.h"
+#include "../Events/IGameEvent.h"
+
+class Room;
+class Enemy;
+class Food;
+
+class IEntity: public IPreparable {	//мб entity отсюда надо убрать
+public:
+	void set_location(Room* ptr_room);
+	Room* get_location();
+
+protected:
+	Room* m_ptr_room;	//не unique тк room без него живет
+	sf::CircleShape m_circle;
+};
+
+
+class IVisitor {
+public:
+	virtual std::unique_ptr<IGameEvent> visit(Food* ptr_food) = 0;
+	virtual std::unique_ptr<IGameEvent> visit(Enemy* ptr_enemy) = 0;
+};
+
+
+class IVisitable {
+public:
+	virtual std::unique_ptr<IGameEvent> accept(IVisitor* ptr_visitor) = 0;
+};
+
+
+class IStaticEntity: public IEntity, public IVisitable {
+public:
+	virtual ~IStaticEntity() = default;
+
+	virtual std::unique_ptr<IStaticEntity> clone() const = 0;
+};
+
+
+class IDynamicEntity: public IEntity, public IVisitable {
+public:
+	virtual ~IDynamicEntity() = default;
+
+	virtual std::unique_ptr<IDynamicEntity> clone() const = 0;
+	virtual void action() = 0;
+};
+
+
+class Enemy: public IDynamicEntity {
+public:
+	Enemy();
+
+	void draw_into(sf::RenderWindow& window) const override;
+	void prepare_for_drawing() override;
+	std::unique_ptr<IDynamicEntity> clone() const override;
+	void action() override;
+	std::unique_ptr<IGameEvent> accept(IVisitor* ptr_visitor) override;
+
+private:
+	sf::Clock m_stopwatch;
+};
+
+
+class Food : public IStaticEntity {
+public:
+	Food();
+
+	void draw_into(sf::RenderWindow& window) const override;
+	void prepare_for_drawing() override;
+	std::unique_ptr<IStaticEntity> clone() const override;
+	std::unique_ptr<IGameEvent> accept(IVisitor* ptr_visitor) override;
+};
\ No newline at end of file

Sources/Entities/Pacman.cpp

+#include "pacman.h"
+
+#include "../Context/Context.h"
+
+//PACMAN
+Pacman::Pacman() {
+	m_circle = sf::CircleShape(config::GAME_PACMAN_SIZE/2);
+	m_circle.setOrigin({ config::GAME_PACMAN_SIZE/2, config::GAME_PACMAN_SIZE/2 });
+	m_circle.setFillColor(config::GAME_COLOR_PACMAN);
+}
+
+void Pacman::move(Room::Direction direction) {
+	m_ptr_room->get_side(direction)->enter(this);
+}
+
+void Pacman::draw_into(sf::RenderWindow& window) const {
+	window.draw(m_circle);
+}
+
+void Pacman::prepare_for_drawing() {
+	m_circle.setPosition(m_ptr_room->get_position());
+}
+
+
+std::unique_ptr<IGameEvent> Pacman::visit(Food* ptr_food) {
+	if (ptr_food->get_location() != this->get_location())
+		return {};
+	return std::make_unique<DeleteStaticEntity>(std::move(std::unique_ptr<IStaticEntity>(ptr_food)));
+}
+
+std::unique_ptr<IGameEvent> Pacman::visit(Enemy* ptr_enemy) {
+	if (ptr_enemy->get_location() != this->get_location())
+		return {};
+	return std::make_unique<LostGame>();
+}
+
+//DELETESTATIC
+DeleteStaticEntity::DeleteStaticEntity(std::unique_ptr<IStaticEntity> ptr) : m_ptr_entity(std::move(ptr)) {};
+
+void DeleteStaticEntity::handle(GameContext& context) const {
+	for (auto it = context.static_objects.begin(); it != context.static_objects.end(); ++it) {
+		if (m_ptr_entity == (*it)) {
+			context.static_objects.erase(it);
+		}
+	}
+}
+
+
+//LOSTGAME
+void LostGame::handle(GameContext& context) const {
+	context.state = GameContext::LOST;
+}
+
+
+//WINGAME
+void WinGame::handle(GameContext& context) const {
+	context.state = GameContext::WIN;
+}
\ No newline at end of file

Sources/Entities/Pacman.h

+#pragma once
+
+//#include "Entities.h" //он тут есть
+//#include "../Events/Events.h"
+#include "../Room/Room.h"
+
+
+#include "../Events/IGameEvent.h"
+
+class GameContext;
+class IStaticEntity;
+
+class DeleteStaticEntity : public IGameEvent {
+public:
+	DeleteStaticEntity(std::unique_ptr<IStaticEntity> ptr);
+
+	void handle(GameContext& context) const override;
+
+private:
+	std::unique_ptr<IStaticEntity> m_ptr_entity;
+};
+
+
+class LostGame : public IGameEvent {
+public:
+	void handle(GameContext& context) const override;
+};
+
+
+class WinGame: public IGameEvent {
+public:
+	void handle(GameContext& context) const override;
+};
+
+
+
+class Pacman : public IEntity, public IVisitor {
+public:
+	Pacman();	
+
+	void move(Room::Direction direction);
+	void draw_into(sf::RenderWindow& window) const override;
+	void prepare_for_drawing() override;
+	std::unique_ptr<IGameEvent> visit(Food* ptr_food) override;
+	std::unique_ptr<IGameEvent> visit(Enemy* ptr_enemy) override;
+};

Sources/Events/IGameEvent.h

+#pragma once
+
+class GameContext;
+
+class IGameEvent {
+public:
+	virtual void IGameEvent::handle(GameContext& context) const = 0;
+};
\ No newline at end of file

Sources/Font/MyFont.h

 #pragma once
 
-#include <SFML/Graphics.hpp>//УБРАТЬ
-
 #include "../../config.h"
 
 class MyFont {	//здесь реализуем singleton

Sources/Menu/Menu.cpp

 #include "Menu.h"
 
 Menu::Menu(IStateManager& state_manager) {
-	auto easy_director = std::make_unique<GameBuilderDirector>();
-	auto medium_director = std::make_unique<GameBuilderDirector>();
-	auto hard_director = std::make_unique<GameBuilderDirector>();
+	auto simple_builder = std::make_unique<SimpleBuilder>(config::GAME_VIDEO_MODE.width, config::GAME_VIDEO_MODE.height, config::ROOM_SIZE); 
+	auto medium_builder = std::make_unique<SimpleBuilder>(config::GAME_VIDEO_MODE.width, config::GAME_VIDEO_MODE.height, config::ROOM_SIZE); 
+	auto complex_builder = std::make_unique<ComplexBuilder>(config::GAME_VIDEO_MODE.width, config::GAME_VIDEO_MODE.height, config::ROOM_SIZE);
 
-	m_buttons.at(0).set(sf::Vector2f(200, 120), config::BUTTON_SIZE, config::BUTTON_TEXT_EASY, config::BUTTON_FONT_SIZE, std::make_unique<GameCommand>(state_manager, std::move(easy_director)));
-	m_buttons.at(1).set(sf::Vector2f(200, 240), config::BUTTON_SIZE, config::BUTTON_TEXT_MEDIUM, config::BUTTON_FONT_SIZE, std::make_unique<GameCommand>(state_manager, std::move(medium_director)));
-	m_buttons.at(2).set(sf::Vector2f(200, 360), config::BUTTON_SIZE, config::BUTTON_TEXT_HARD, config::BUTTON_FONT_SIZE, std::make_unique<GameCommand>(state_manager, std::move(hard_director)));
-	m_buttons.at(3).set(sf::Vector2f(200, 480), config::BUTTON_SIZE, config::BUTTON_TEXT_EXIT, config::BUTTON_FONT_SIZE, std::make_unique<ExitCommand>(state_manager));
+	auto easy_director = std::make_unique<GameBuilderDirector>(std::move(simple_builder), config::GAME_VIDEO_MODE,	config::EASY_GAME_TITLE, config::EASY_GAME_ENEMY_RATIO);
+	auto medium_director = std::make_unique<GameBuilderDirector>(std::move(simple_builder),config::GAME_VIDEO_MODE, config::MEDIUM_GAME_TITLE, config::MEDIUM_GAME_ENEMY_RATIO);
+	auto hard_director = std::make_unique<GameBuilderDirector>(std::move(complex_builder), config::GAME_VIDEO_MODE, config::HARD_GAME_TITLE, config::HARD_GAME_ENEMY_RATIO);
+
+	std::unique_ptr<ISelectCommand> easy_command = std::make_unique<GameCommand>(state_manager, std::move(easy_director));
+	std::unique_ptr<ISelectCommand> medium_command = std::make_unique<GameCommand>(state_manager, std::move(medium_director));
+	std::unique_ptr<ISelectCommand> hard_command = std::make_unique<GameCommand>(state_manager, std::move(hard_director));
+	std::unique_ptr<ISelectCommand> exit_command = std::make_unique<ExitCommand>(state_manager);
+
+	m_buttons.at(0).set(sf::Vector2f(200, 120), config::BUTTON_SIZE, config::BUTTON_TEXT_EASY, config::BUTTON_FONT_SIZE, std::move(easy_command));
+	m_buttons.at(1).set(sf::Vector2f(200, 240), config::BUTTON_SIZE, config::BUTTON_TEXT_MEDIUM, config::BUTTON_FONT_SIZE, std::move(medium_command));
+	m_buttons.at(2).set(sf::Vector2f(200, 360), config::BUTTON_SIZE, config::BUTTON_TEXT_HARD, config::BUTTON_FONT_SIZE, std::move(hard_command));
+	m_buttons.at(3).set(sf::Vector2f(200, 480), config::BUTTON_SIZE, config::BUTTON_TEXT_EXIT, config::BUTTON_FONT_SIZE, std::move(exit_command));
 }
 
 void Menu::draw_into(sf::RenderWindow& window) const {

Sources/Menu/Menu.h

@@ -6,12 +6,13 @@
 #include "../IDraw_n_IPrep/IDraw_n_IPrep.h"
 #include "../States/IState.h"
 #include "../Button/Button.h"
-#include "../Builders/Game.h"
-#include "../SelectCommand/SelectCommand.h"
+#include "../Builders/Game_n_common.h"
+//#include "../SelectCommand/SelectCommand.h"
+//#include "../Builders/Simple_n_Complex.h"
 
 class Menu: public IDrawable {
 public:
-	Menu(IStateManager& state_manager);
+	Menu(IStateManager& state_manager);	//ДОДЕЛАТЬ
 
 	void draw_into(sf::RenderWindow& window) const override;
 	void process_mouse(sf::Vector2f pos, bool is_pressed); 

Sources/Room/Room.cpp

 #include "Room.h"
 
 
-////MAZE
-//Maze::Maze(std::vector<std::unique_ptr<Room>>& rooms): m_rooms(std::move(rooms)) {} //move потому что вектор с unique
-//
-//void Maze::draw_into(sf::RenderWindow& window) const {
-//	for (const std::unique_ptr<Room>& ptr_room : m_rooms)
-//		ptr_room->draw_into(window);	//-> потому что в ptr_room указатель, который надо разыменовать
-//}
-//
-//
-////PASS
-//Pass::Pass(Room& room1, Room& room2): m_room1(room1), m_room2(room2) {}
-//
-//void Pass::draw_into(sf::RenderWindow& window) const {};
-//
-//void Pass::prepare_for_drawing() {};
-//
-//
-////WALL
-//Wall::Wall(Room& room): m_room(room) {}
\ No newline at end of file
+//MAZE
+Maze::Maze(std::vector<std::unique_ptr<Room>> rooms): m_rooms(std::move(rooms)) {} //move потому что вектор с unique
+
+void Maze::draw_into(sf::RenderWindow& window) const {
+	for (auto& ptr_room : m_rooms)
+		ptr_room->draw_into(window);	//-> потому что в ptr_room указатель, который надо разыменовать
+}
+
+
+//PASS
+Pass::Pass(Room& room1, Room& room2): m_room1(room1), m_room2(room2) {}
+
+void Pass::draw_into(sf::RenderWindow& window) const {};
+
+void Pass::prepare_for_drawing() {};
+
+void Pass::enter(IEntity* entity) {
+	if (entity->get_location() == &m_room1) {
+		entity->set_location(&m_room2);
+	}
+	else {
+		entity->set_location(&m_room1);
+	}
+}
+
+
+//WALL
+Wall::Wall(Room& room): m_room(room) {}
+
+void Wall::draw_into(sf::RenderWindow& window) const {
+	window.draw(m_line, 2, sf::Lines);
+}
+
+void Wall::prepare_for_drawing() {
+	sf::Vector2f pos = m_room.get_position();
+	float size = config::ROOM_SIZE;
+
+	switch (m_room.get_direction(this)) {
+	case Room::UP:
+		m_line[0] = sf::Vertex({ pos.x - size / 2, pos.y - size / 2 }, config::GAME_COLOR_WALL);
+		m_line[1] = sf::Vertex({ pos.x + size / 2, pos.y - size / 2 }, config::GAME_COLOR_WALL);
+		break;
+	
+	case Room::RIGHT:
+		m_line[0] = sf::Vertex({ pos.x + size / 2, pos.y - size / 2 }, config::GAME_COLOR_WALL);
+		m_line[1] = sf::Vertex({ pos.x + size / 2, pos.y + size / 2 }, config::GAME_COLOR_WALL);
+		break;
+	
+	case Room::DOWN:
+		m_line[0] = sf::Vertex({ pos.x + size / 2, pos.y + size / 2 }, config::GAME_COLOR_WALL);
+		m_line[1] = sf::Vertex({ pos.x - size / 2, pos.y + size / 2 }, config::GAME_COLOR_WALL);
+		break;
+
+	case Room::LEFT:
+		m_line[0] = sf::Vertex({ pos.x - size / 2, pos.y + size / 2 }, config::GAME_COLOR_WALL);
+		m_line[1] = sf::Vertex({ pos.x - size / 2, pos.y - size / 2 }, config::GAME_COLOR_WALL);
+		break;
+
+	default:
+		throw std::runtime_error("There is invalid side in some room");
+	}
+}
+
+void Wall::enter(IEntity* entity) {
+}
+
+
+//ROOM
+Room::Room(float size) : m_rectangle{ {size, size} } {
+	m_rectangle.setOrigin(size/2, size/2);
+	m_rectangle.setFillColor(config::GAME_COLOR_ROOM);
+}
+
+float Room::get_size() { 
+	return m_rectangle.getSize().x; 
+}
+
+void Room::set_position(sf::Vector2f pos) {
+	m_rectangle.setPosition(pos);
+}
+
+sf::Vector2f Room::get_position() { 
+	return m_rectangle.getPosition(); 
+}
+
+void Room::set_side(Direction side, std::shared_ptr<IRoomSide> ptr_side) {
+	if (side == INVALID) return;
+	m_sides.at(side) = std::move(ptr_side);	//возможно надо без move
+}
+
+std::shared_ptr<IRoomSide> Room::get_side(Direction side) {
+	return m_sides.at(side);
+}
+
+Room::Direction Room::get_direction(IRoomSide* ptr_side) {
+	if (ptr_side == m_sides.at(UP).get()) { return UP; }
+	if (ptr_side == m_sides.at(RIGHT).get()) { return RIGHT; }
+	if (ptr_side == m_sides.at(DOWN).get()) { return DOWN; }
+	if (ptr_side == m_sides.at(LEFT).get()) { return LEFT; }
+	return INVALID;
+}
+
+void Room::draw_into(sf::RenderWindow& window) const {
+	for (const std::shared_ptr<IRoomSide>& room_side: m_sides) {
+		room_side->draw_into(window);
+	}
+}
\ No newline at end of file

Sources/Room/Room.h

@@ -3,72 +3,74 @@
 #include <array>
 #include <vector>
 
-//#include "../IDraw_n_IPrep/IDraw_n_IPrep.h"
-//#include "../Entities/Entities.h"
-
-//class Room;
-//
-//class Maze: public IDrawable {
-//public:
-//	Maze(std::vector<std::unique_ptr<Room>>& rooms);
-//	void draw_into(sf::RenderWindow& window) const override;
-//
-//private:
-//	std::vector<std::unique_ptr<Room>> m_rooms;
-//};
-//
-//
-//class IRoomSide: public IPreparable {
-//public:
-//	virtual ~IRoomSide() = default;
-//
-//	virtual void enter(IEntity* entity) = 0; //эта функция будет перемещать сущностей: в классе Wall перемещения не будет, в Pass перемещение в соседнюю клетку
-//};
-//
-//
-//class Pass: public IRoomSide {
-//public:
-//	Pass(Room& room1, Room& room2);
-//	void draw_into(sf::RenderWindow& window) const override;
-//	void prepare_for_drawing() override;
-//	void enter(IEntity* entity) override;		//РЕАЛИЗОВАТЬ
-//
-//private:
-//	Room& m_room1;
-//	Room& m_room2;
-//};
-//
-//
-//class Wall : public IRoomSide {
-//public:
-//	Wall(Room& room);
-//	void draw_into(sf::RenderWindow& window) const override;	//РЕАЛИЗОВАТЬ
-//	void prepare_for_drawing() override;	//РЕАЛИЗОВАТЬ
-//	void enter(IEntity* entity) override;		//РЕАЛИЗОВАТЬ
-//	
-//private:
-//	Room& m_room;
-//	sf::Vertex m_line[2];
-//};
-//
-//
-//class Room: public IDrawable {
-//public:
-//	enum Direction { INVALID = -1, LEFT, RIGHT, UP, DOWN };
-//
-//	Room(float size); //РЕАЛИЗОВАТЬ
-//
-//	float get_size();	//РЕАЛИЗОВАТЬ
-//	void set_position(sf::Vector2f pos);	//РЕАЛИЗОВАТЬ
-//	sf::Vector2f get_position();	//РЕАЛИЗОВАТЬ
-//	void set_side(Direction side, std::shared_ptr<IRoomSide> ptr_side);	//РЕАЛИЗОВАТЬ	// shared_ptr, потому что одна IRoomSide будет у нескольких комнат
-//	IRoomSide* get_side(Direction side);	//РЕАЛИЗОВАТЬ
-//	Direction get_direction(IRoomSide* ptr_side); //РЕАЛИЗОВАТЬ
-//	void draw_into(sf::RenderWindow& window) const override; //РЕАЛИЗОВАТЬ
-//
-//public:
-//	std::array<std::shared_ptr<IRoomSide>,4> m_sides;
-//
-//private:
-//	sf::RectangleShape m_rectangle;
-//};
\ No newline at end of file
+#include "../IDraw_n_IPrep/IDraw_n_IPrep.h"
+#include "../Entities/Entities.h"
+#include "../../Config.h"
+
+class Room;
+
+class Maze: public IDrawable {
+public:
+	Maze() = default;
+	Maze(std::vector<std::unique_ptr<Room>> rooms);
+	void draw_into(sf::RenderWindow& window) const override;
+
+private:
+	std::vector<std::unique_ptr<Room>> m_rooms;
+};
+
+
+class IRoomSide: public IPreparable {
+public:
+	virtual ~IRoomSide() = default;
+
+	virtual void enter(IEntity* entity) = 0; //эта функция будет перемещать сущностей: в классе Wall перемещения не будет, в Pass перемещение в соседнюю клетку
+};
+
+
+class Pass: public IRoomSide {
+public:
+	Pass(Room& room1, Room& room2);
+	void draw_into(sf::RenderWindow& window) const override;
+	void prepare_for_drawing() override;
+	void enter(IEntity* entity) override;	
+
+private:
+	Room& m_room1;
+	Room& m_room2;
+};
+
+
+class Wall : public IRoomSide {
+public:
+	Wall(Room& room);
+	void draw_into(sf::RenderWindow& window) const override;	
+	void prepare_for_drawing() override;
+	void enter(IEntity* entity) override;		
+	
+private:
+	Room& m_room;
+	sf::Vertex m_line[2];
+};
+
+
+class Room: public IDrawable {
+public:
+	enum Direction { INVALID = -1, LEFT, RIGHT, UP, DOWN };
+
+	Room(float size);
+
+	float get_size();
+	void set_position(sf::Vector2f pos);
+	sf::Vector2f get_position();
+	void set_side(Direction side, std::shared_ptr<IRoomSide> ptr_side);	// shared_ptr, потому что одна IRoomSide будет у нескольких комнат
+	std::shared_ptr<IRoomSide> get_side(Direction side);
+	Direction get_direction(IRoomSide* ptr_side);
+	void draw_into(sf::RenderWindow& window) const override;
+
+public:
+	std::array<std::shared_ptr<IRoomSide>,4> m_sides;
+
+private:
+	sf::RectangleShape m_rectangle;
+};
\ No newline at end of file

Sources/SelectCommand/SelectCommand.cpp

 #include "SelectCommand.h"
 
+#include "../States/States.h"
+
 //CHANGE
 ChangeStateCommand::ChangeStateCommand(IStateManager& state_manager): m_state_manager(state_manager) {};
 
@@ -8,7 +10,7 @@ ChangeStateCommand::ChangeStateCommand(IStateManager& state_manager): m_state_ma
 ExitCommand::ExitCommand(IStateManager& state_manager): ChangeStateCommand(state_manager) {}
 
 void ExitCommand::execute() {	//задаем след. состояние как выход
-	//m_state_manager.set_next_state(std::make_unique<ExitState>(m_state_manager));
+	m_state_manager.set_next_state(std::make_unique<ExitState>(m_state_manager));
 }
 
 
@@ -17,5 +19,6 @@ GameCommand::GameCommand(IStateManager& state_manager, std::unique_ptr<GameBuild
 	ChangeStateCommand(state_manager), m_ptr_director(std::move(ptr_director)) {}
 
 void GameCommand::execute() {	//задаем следующее состояние как игру
-	//m_state_manager.set_next_state(std::make_unique<GameState>(m_state_manager, config::SELECT_LEVEL_VIDEO_MODE, config::SELECT_LEVEL_TITLE));
+	std::unique_ptr<GameState> state = m_ptr_director->build(m_state_manager); //поручаем директору создать состояние
+	m_state_manager.set_next_state(std::move(state));
 }
\ No newline at end of file