From bf55f21d7946d0bc9148a9e7b863fb0409ddeb39 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Fri, 22 Sep 2023 02:06:39 +0300
Subject: [PATCH 01/13] one file rough game MVP

---
 CMakeLists.txt                                |    2 +
 battle_tanks/client/CMakeLists.txt            |   27 +
 battle_tanks/client/battle_tanks.cpp          |  645 ++++
 .../client/game_data/atlases/bullet_1.png     |  Bin 0 -> 7045 bytes
 .../client/game_data/atlases/tank.png         |  Bin 0 -> 4403 bytes
 .../client/game_data/atlases/tower.png        |  Bin 0 -> 2588 bytes
 battle_tanks/client/headers/debug_draw.hpp    |   46 +
 battle_tanks/client/sources/debug_draw.cpp    |  111 +
 external/headers/boost/di.hpp                 | 3355 +++++++++++++++++
 gitattributes                                 |    2 +
 vcpkg.json                                    |    5 +-
 11 files changed, 4192 insertions(+), 1 deletion(-)
 create mode 100644 battle_tanks/client/CMakeLists.txt
 create mode 100644 battle_tanks/client/battle_tanks.cpp
 create mode 100644 battle_tanks/client/game_data/atlases/bullet_1.png
 create mode 100644 battle_tanks/client/game_data/atlases/tank.png
 create mode 100644 battle_tanks/client/game_data/atlases/tower.png
 create mode 100644 battle_tanks/client/headers/debug_draw.hpp
 create mode 100644 battle_tanks/client/sources/debug_draw.cpp
 create mode 100644 external/headers/boost/di.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index af072a7..e8e749d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,3 +38,5 @@ add_subdirectory ("lesson_22")
 add_subdirectory ("lesson_23")
 add_subdirectory ("lesson_26")
 add_subdirectory ("lesson_27")
+
+add_subdirectory ("battle_tanks/client")
diff --git a/battle_tanks/client/CMakeLists.txt b/battle_tanks/client/CMakeLists.txt
new file mode 100644
index 0000000..7f7f248
--- /dev/null
+++ b/battle_tanks/client/CMakeLists.txt
@@ -0,0 +1,27 @@
+project(battle_tanks_client)
+
+file(GLOB_RECURSE SOURCES "./*.cpp")
+
+include_directories(${PROJECT_SOURCE_DIR}/headers)
+
+find_package(SFML COMPONENTS system window graphics CONFIG REQUIRED)
+find_package(box2d CONFIG REQUIRED)
+
+add_executable (${PROJECT_NAME} ${SOURCES})
+
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/game_data DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
+if (CMAKE_VERSION VERSION_GREATER 3.12)
+  set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
+endif()
+
+target_link_libraries(${PROJECT_NAME}
+    PRIVATE
+        sfml-system
+        sfml-network
+        sfml-graphics
+        sfml-window
+        box2d::box2d
+)
+
+target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../external/headers)
\ No newline at end of file
diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
new file mode 100644
index 0000000..7da50bc
--- /dev/null
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -0,0 +1,645 @@
+#include <cmath>
+#include <numbers>
+#include <chrono>
+
+#include <SFML/Graphics.hpp>
+#include <box2d/box2d.h>
+
+#include "boost/di.hpp"
+
+#include "debug_draw.hpp"
+
+typedef long long unsigned uuid;
+static uuid current_uuid{ 1 };
+uuid generate_uuid()
+{
+    return current_uuid++;
+}
+
+float deg_to_rad(float rotation)
+{
+    return static_cast<float>(std::numbers::pi * static_cast<double>(rotation) / 180.0);
+}
+
+class container;
+class render_object;
+
+enum class move_action
+{
+    stop = 0,
+    forward,
+    backward,
+};
+
+enum rotate_action
+{
+    stop = 0,
+    left,
+    right,
+};
+
+enum class game_object_type : unsigned
+{
+    unknown = 0,
+    tank,
+    bullet,
+    wall,
+    brick
+};
+
+struct game_object_b2d_link
+{
+	game_object_type type{ game_object_type::unknown };
+	uuid id{ 0 };
+};
+
+class game_object
+{
+public:
+    explicit game_object(uuid id) : id_{ id }
+    {
+    }
+
+    virtual ~game_object() = default;
+
+public:
+    virtual void initialize() = 0;
+    virtual void update(float delta_time) = 0;
+    virtual void free() = 0;
+
+public:
+    const std::shared_ptr<render_object>& get_render_object() const
+    {
+        return render_object_;
+    }
+
+    const b2Body* get_physics_body() const
+    {
+        return physics_body_;
+    }
+
+protected:
+    std::shared_ptr<render_object> render_object_{ nullptr };
+    b2Body* physics_body_{ nullptr };
+    uuid id_;
+};
+
+class game_scene
+{
+public:
+    void update(float delta_time) const
+    {
+        //physics_world_.Step(delta_time, 8, 3);
+        for (const auto& game_object : game_objects_)
+        {
+            game_object->update(delta_time);
+        }
+    }
+
+    void add_game_object(const std::shared_ptr<game_object>& game_object)
+    {
+        game_objects_.push_back(game_object);
+    }
+
+    void remove_game_object(const std::shared_ptr<game_object>& game_object)
+    {
+        for (auto it = game_objects_.begin(); it != game_objects_.end(); ++it)
+        {
+            if (*it == game_object)
+            {
+                game_objects_.erase(it);
+                break;
+            }
+        }
+    }
+
+private:
+    std::vector<std::shared_ptr<game_object>> game_objects_{};
+
+    //b2World physics_world_{ { 0.0f, 0.0f } };
+};
+
+class render_object : public sf::Transformable
+{
+    friend container;
+
+public:
+    virtual ~render_object() override = default;
+
+public:
+    void free()
+    {
+        if (parent_ != nullptr)
+        {
+            //TODO: fix
+            //parent_->remove_child(std::shared_ptr<render_object>(this));
+            //parent_ = nullptr;
+        }
+    }
+
+protected:
+    virtual void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const = 0;
+
+private:
+    std::shared_ptr<container> parent_{ nullptr };
+};
+
+class container : public render_object
+{
+public:
+    virtual ~container() override = default;
+
+public:
+    void add_child(const std::shared_ptr<render_object>& child)
+    {
+        if (child->parent_ != nullptr)
+        {
+            child->parent_->remove_child(child);
+        }
+
+        children_.push_back(child);
+        //child->parent_ = std::shared_ptr<container>(this); //TODO: fix
+    }
+
+    void remove_child(const std::shared_ptr<render_object>& child)
+    {
+        for (auto it = children_.begin(); it != children_.end(); ++it)
+        {
+            if (*it == child)
+            {
+                children_.erase(it);
+                break;
+            }
+        }
+    }
+
+protected:
+    void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
+    {
+        const sf::Transform transform = parent_transform * getTransform();
+        for (const auto& ch : children_)
+        {
+            ch->draw(render_target, transform);
+        }
+    }
+
+protected:
+    std::vector<std::shared_ptr<render_object>> children_{};
+};
+
+class render_scene final : public container
+{
+public:
+    explicit render_scene(const std::shared_ptr<sf::RenderTarget>& render_target) : render_target_{ render_target }
+    {
+    }
+
+    virtual ~render_scene() override = default;
+
+public:
+    void draw_scene() const
+    {
+        container::draw(render_target_, getTransform());
+    }
+
+private:
+    std::shared_ptr<sf::RenderTarget> render_target_{ nullptr };
+};
+
+class texture_render_data
+{
+public:
+    explicit texture_render_data(const std::string& path)
+    {
+        texture_ = std::make_shared<sf::Texture>();
+        texture_->loadFromFile(path);
+        texture_->setSmooth(true);
+        texture_size_ = texture_->getSize();
+    }
+
+public:
+    std::shared_ptr<sf::Texture> get_texture() const
+    {
+        return texture_;
+    }
+
+    sf::Vector2u get_size() const
+    {
+        return texture_size_;
+    }
+
+private:
+    std::shared_ptr<sf::Texture> texture_{ nullptr };
+    sf::Vector2u texture_size_{};
+};
+
+
+class sprite : public render_object
+{
+public:
+    explicit sprite(const std::string& path)
+    {
+        texture_render_data_ = std::make_shared<texture_render_data>(path);
+        sprite_.setTexture(*texture_render_data_->get_texture());
+    }
+
+    explicit sprite(const std::shared_ptr<texture_render_data>& texture_render_data)
+    {
+        texture_render_data_ = texture_render_data;
+        sprite_.setTexture(*texture_render_data_->get_texture());
+    }
+
+    virtual ~sprite() override = default;
+
+protected:
+    void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
+    {
+        if (texture_render_data_ == nullptr)
+        {
+            return;
+        }
+        render_target->draw(sprite_, parent_transform * getTransform());
+    }
+
+private:
+    sf::Sprite sprite_{};
+    std::shared_ptr<texture_render_data> texture_render_data_{ nullptr };
+};
+
+//TODO:: create object poll for such objects
+class bullet : public game_object
+{
+public:
+    bullet(const uuid id, float velocity, const std::shared_ptr<texture_render_data>& render_data, b2Body* body) :
+        game_object(id), velocity_{ velocity }, render_data_{ render_data }
+    {
+        physics_body_ = body ;
+    }
+
+    virtual ~bullet() override = default;
+
+public:
+    virtual void initialize() override
+    {
+        render_object_ = std::make_shared<sprite>(render_data_);
+    }
+
+    virtual void update(float delta_time) override
+    {
+        if (render_object_ == nullptr || velocity_ == 0.0f)
+        {
+            return;
+        }
+
+        /*
+        const auto position = render_object_->getPosition();
+        const auto rotation = render_object_->getRotation();
+        const auto rad_rotation = static_cast<float>(std::numbers::pi * static_cast<double>(rotation) / 180.0);
+
+        const auto new_position_x = position.x + std::sin(rad_rotation) * velocity_ * delta_time;
+        const auto new_position_y = position.y + -std::cos(rad_rotation) * velocity_ * delta_time;
+
+        render_object_->setPosition(new_position_x, new_position_y);
+        */
+        auto& ph_body_pos = physics_body_->GetPosition();
+        const float ph_body_rot = physics_body_->GetAngle();
+
+        render_object_->setPosition({ ph_body_pos.x * 10.0f, ph_body_pos.y * 10.0f });
+        render_object_->setRotation(std::fmod(
+            static_cast<float>(static_cast<double>(ph_body_rot) * 180.0f / std::numbers::pi), 360.0f)
+        );
+
+        //TODO: delete bullet if it out of game field (field_size_)
+    }
+
+    virtual void free() override
+    {
+        if (render_object_ != nullptr)
+        {
+            render_object_->free();
+            render_object_ = nullptr;
+        }
+    }
+
+private:
+    float velocity_{ 0.0f };
+    sf::Vector2f position_{};
+    sf::Vector2u field_size_{};
+
+    std::shared_ptr<texture_render_data> render_data_{ nullptr };
+};
+
+class physics_contact_listener final : public b2ContactListener
+{
+    void BeginContact(b2Contact* contact) override
+    {
+        b2Fixture* fixture_a = contact->GetFixtureA();
+        b2Fixture* fixture_b = contact->GetFixtureB();
+
+        // Check if fixtureA or fixtureB is your object, and perform actions accordingly.
+        // For example, you can check user data associated with the fixtures.
+        b2Body* body_a = fixture_a->GetBody();
+        b2Body* body_b = fixture_b->GetBody();
+        b2BodyUserData user_data_a = body_a->GetUserData();
+        b2BodyUserData user_data_b = body_b->GetUserData();
+
+        const game_object_b2d_link* link_a{ nullptr };
+        const game_object_b2d_link* link_b{ nullptr };
+
+        if (user_data_a.pointer != 0)
+        {
+            link_a = reinterpret_cast<game_object_b2d_link*>(user_data_a.pointer);
+            if (link_a->type == game_object_type::bullet)
+            {
+                //std::cout << "Bullet collision detected!" << std::endl;
+            }
+        }
+
+        if (user_data_b.pointer != 0)
+        {
+            link_b = reinterpret_cast<game_object_b2d_link*>(user_data_b.pointer);
+            if (link_b->type == game_object_type::bullet)
+            {
+                //std::cout << "Bullet collision detected!" << std::endl;
+            }
+        }
+
+        // Perform collision handling here.
+        //std::cout << "Collision detected!" << std::endl;
+    }
+};
+
+int main()
+{
+    constexpr float pixels_per_meters{ 10.0f }; // 1 meter = 10 pixels
+    const sf::Vector2u game_field_size{ 800, 600 };
+
+    auto window = std::make_shared<sf::RenderWindow>(sf::VideoMode(game_field_size.x, game_field_size.y), "Battle Tanks");
+    //window->setFramerateLimit(20);
+
+    sf::Clock clock;
+    game_scene game;
+    render_scene root_node{window};
+    b2World physics_world{ { 0.0f, 0.0f } };
+    physics_world.SetAllowSleeping(true);
+    //physics_world.SetContinuousPhysics(true);
+    auto* contact_listener = new physics_contact_listener();
+    physics_world.SetContactListener(contact_listener);
+    SFMLDebugDraw draw{ *window, pixels_per_meters };
+    draw.AppendFlags(b2Draw::e_shapeBit);
+    physics_world.SetDebugDraw(&draw);
+
+    // <TEXTURES>
+    auto tank_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/tank.png");
+    auto tower_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/tower.png");
+    auto bullet_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/bullet_1.png");
+    // </TEXTURES>
+
+    // <TANK>
+    move_action tank_move_action{};
+    rotate_action tank_rotate_action{};
+    rotate_action tower_rotate_action{};
+    bool tank_fire{ false };
+
+    sf::Vector2u tank_texture_size = tank_texture_render_data->get_size();
+
+    const auto tank_container = std::make_shared<container>();
+    tank_container->setPosition(100.0, 100.0);
+    tank_container->setOrigin(static_cast<float>(tank_texture_size.x) / 2.0f, static_cast<float>(tank_texture_size.y) / 2.0f);
+    root_node.add_child(tank_container);
+
+    const auto tank_base_sprite = std::make_shared<sprite>(tank_texture_render_data);
+    tank_container->add_child(tank_base_sprite);
+
+    const auto tank_tower_sprite = std::make_shared<sprite>(tower_texture_render_data);
+    tank_tower_sprite->setPosition(16.5f, 27.0f);
+    tank_tower_sprite->setOrigin(10.0f, 67.0f);
+    tank_container->add_child(tank_tower_sprite);
+
+    b2BodyDef tank_body_def;
+    tank_body_def.type = b2_dynamicBody;
+    tank_body_def.position.Set(100.0f / pixels_per_meters, 100.0f / pixels_per_meters);
+    auto tank_body = physics_world.CreateBody(&tank_body_def);
+    b2PolygonShape tank_shape;
+    tank_shape.SetAsBox(
+        static_cast<float>(tank_texture_size.x) / pixels_per_meters / 2,
+        static_cast<float>(tank_texture_size.y) / pixels_per_meters / 2
+    );
+    tank_body->CreateFixture(&tank_shape, 1.0f);
+    // </TANK>
+
+    // <EDGES>
+    b2Vec2 bottom_right_point = b2Vec2{
+            static_cast<float>(game_field_size.x) / pixels_per_meters,
+            static_cast<float>(game_field_size.y) / pixels_per_meters
+    };
+    b2BodyDef edge_body_def;
+    edge_body_def.type = b2_staticBody;
+    auto edges_body = physics_world.CreateBody(&edge_body_def);
+
+    b2EdgeShape top_edge_shape;
+    top_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(bottom_right_point.x, 0.0f));
+    edges_body->CreateFixture(&top_edge_shape, 1.0f);
+
+    b2EdgeShape bottom_edge_shape;
+    bottom_edge_shape.SetTwoSided(b2Vec2(0.0f, bottom_right_point.y), bottom_right_point);
+    edges_body->CreateFixture(&bottom_edge_shape, 1.0f);
+
+    b2EdgeShape left_edge_shape;
+    left_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(0.0f, bottom_right_point.y));
+    edges_body->CreateFixture(&left_edge_shape, 1.0f);
+
+    b2EdgeShape right_edge_shape;
+    right_edge_shape.SetTwoSided(b2Vec2(bottom_right_point.x, 0.0f), bottom_right_point);
+    edges_body->CreateFixture(&right_edge_shape, 1.0f);
+    // </EDGES>
+
+    auto bullet_creation_time = std::chrono::high_resolution_clock::now();
+    while (window->isOpen())
+    {
+        float delta_time = clock.restart().asSeconds();
+
+        sf::Event event;
+        while (window->pollEvent(event))
+        {
+            if (event.type == sf::Event::Closed ||
+                (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Key::Escape))
+            {
+                window->close();
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W))
+            {
+                tank_move_action = move_action::forward;
+            }
+            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::S))
+            {
+                tank_move_action = move_action::backward;
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A))
+            {
+                tank_rotate_action = left;
+            }
+            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D))
+            {
+                tank_rotate_action = right;
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left))
+            {
+                tower_rotate_action = left;
+            }
+            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right))
+            {
+                tower_rotate_action = right;
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Space))
+            {
+                tank_fire = true;
+            }
+
+            if (event.type == sf::Event::KeyReleased)
+            {
+                if (event.key.code == sf::Keyboard::W || event.key.code == sf::Keyboard::S)
+                {
+                    tank_move_action = move_action::stop;
+                }
+
+                if (event.key.code == sf::Keyboard::A || event.key.code == sf::Keyboard::D)
+                {
+                    tank_rotate_action = stop;
+                }
+
+                if (event.key.code == sf::Keyboard::Left || event.key.code == sf::Keyboard::Right)
+                {
+                    tower_rotate_action = stop;
+                }
+
+                if (event.key.code == sf::Keyboard::Space)
+                {
+                    tank_fire = false;
+                }
+            }
+        }
+
+        if (tank_fire)
+        {
+            auto bullet_current_time = std::chrono::high_resolution_clock::now();
+
+            if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time).count() >= 1000)
+            {
+                bullet_creation_time = bullet_current_time;
+                const float bullet_rotation_rad = deg_to_rad(tank_tower_sprite->getRotation() + tank_container->getRotation());
+                const b2Vec2 bullet_pos{
+                (tank_container->getPosition().x + 80 * std::sin(bullet_rotation_rad)) / pixels_per_meters,
+                (tank_container->getPosition().y - 80 * std::cos(bullet_rotation_rad)) / pixels_per_meters
+                };
+                b2BodyDef bullet_body_def;
+                bullet_body_def.type = b2_dynamicBody;
+                bullet_body_def.position.Set(bullet_pos.x, bullet_pos.y);
+                auto bullet_body = physics_world.CreateBody(&bullet_body_def);
+                b2PolygonShape bullet_shape;
+                bullet_shape.SetAsBox(
+                    static_cast<float>(bullet_texture_render_data->get_size().x) / pixels_per_meters / 2,
+                    static_cast<float>(bullet_texture_render_data->get_size().y) / pixels_per_meters / 2
+                );
+                bullet_body->CreateFixture(&bullet_shape, 1.0f);
+                uuid bullet_id = generate_uuid();
+                auto* bullet_link = new game_object_b2d_link{ game_object_type::bullet, bullet_id };
+                bullet_body->GetUserData().pointer = reinterpret_cast<uintptr_t>(bullet_link);
+
+                auto force = b2Vec2{
+                    std::sin(bullet_rotation_rad) * 500.0f / pixels_per_meters,
+                    -std::cos(bullet_rotation_rad) * 500.0f / pixels_per_meters
+                };
+                bullet_body->SetTransform(bullet_pos, bullet_rotation_rad);
+                bullet_body->SetLinearVelocity(force);
+
+                const auto bt = std::make_shared<bullet>(bullet_id, 500.0f, bullet_texture_render_data, bullet_body);
+                bt->initialize();
+                bt->get_render_object()->setOrigin(
+                    static_cast<float>(bullet_texture_render_data->get_size().x) / 2.0f,
+                    static_cast<float>(bullet_texture_render_data->get_size().y) / 2.0f
+                );
+                game.add_game_object(bt);
+                root_node.add_child(bt->get_render_object());
+            }
+        }
+
+        const auto rad_rotation = tank_body->GetAngle();
+        auto tower_rotation = tank_tower_sprite->getRotation();
+
+        constexpr float move_speed = 100.0;
+        if (tank_move_action == move_action::forward)
+        {
+            auto force = b2Vec2{
+                    std::sin(rad_rotation) * move_speed / pixels_per_meters,
+                    -std::cos(rad_rotation) * move_speed / pixels_per_meters
+            };
+
+            tank_body->SetLinearVelocity(force);
+        }
+        else if (tank_move_action == move_action::backward)
+        {
+            auto force = b2Vec2{
+                    -std::sin(rad_rotation) * move_speed / pixels_per_meters,
+                    std::cos(rad_rotation) * move_speed / pixels_per_meters
+            };
+
+            tank_body->SetLinearVelocity(force);
+        }
+        else
+        {
+            tank_body->SetLinearVelocity({ 0.0f, 0.0f });
+        }
+
+        constexpr float rotate_speed = 90.0f;
+        constexpr float rotate_speed_rad = static_cast<float>(std::numbers::pi) / 2.0f;
+        if (tank_rotate_action == left)
+        {
+            tank_body->SetAngularVelocity(-rotate_speed_rad);
+        }
+        else if (tank_rotate_action == right)
+        {
+            tank_body->SetAngularVelocity(rotate_speed_rad);
+        }
+        else
+        {
+            tank_body->SetAngularVelocity(0.0f);
+        }
+
+        if (tower_rotate_action == left)
+        {
+            tower_rotation -= rotate_speed * delta_time;
+        }
+        else if (tower_rotate_action == right)
+        {
+            tower_rotation += rotate_speed * delta_time;
+        }
+
+        auto& ph_body_pos = tank_body->GetPosition();
+        float ph_body_rot = tank_body->GetAngle();
+
+        tank_container->setPosition({ph_body_pos.x * pixels_per_meters, ph_body_pos.y * pixels_per_meters});
+        tank_container->setRotation(std::fmod(
+            static_cast<float>(static_cast<double>(ph_body_rot) * 180.0f / std::numbers::pi), 360.0f)
+        );
+        tank_tower_sprite->setRotation(tower_rotation);
+
+        window->clear(sf::Color::Black);
+
+        physics_world.Step(delta_time, 8, 3);
+        game.update(delta_time);
+        root_node.draw_scene();
+        physics_world.DebugDraw();
+
+        window->display();
+    }
+
+    physics_world.DestroyBody(tank_body);
+    tank_body = nullptr;
+
+    return 0;
+}
diff --git a/battle_tanks/client/game_data/atlases/bullet_1.png b/battle_tanks/client/game_data/atlases/bullet_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ac6687fe5282930c22547164244c3076363edc7b
GIT binary patch
literal 7045
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
Z;6(E6Ypf3NuQLe5%*e{HV3$Y4{{Z69Z^8fo

literal 0
HcmV?d00001

diff --git a/battle_tanks/client/game_data/atlases/tank.png b/battle_tanks/client/game_data/atlases/tank.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f6b814592913325e7592c2cdaf0b90460c7f474
GIT binary patch
literal 4403
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

literal 0
HcmV?d00001

diff --git a/battle_tanks/client/game_data/atlases/tower.png b/battle_tanks/client/game_data/atlases/tower.png
new file mode 100644
index 0000000000000000000000000000000000000000..f02bacbd65a2202c1b2c045e36dbd7da0dab87cd
GIT binary patch
literal 2588
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

literal 0
HcmV?d00001

diff --git a/battle_tanks/client/headers/debug_draw.hpp b/battle_tanks/client/headers/debug_draw.hpp
new file mode 100644
index 0000000..590448f
--- /dev/null
+++ b/battle_tanks/client/headers/debug_draw.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <Box2D/Box2D.h>
+
+class SFMLDebugDraw : public b2Draw
+{
+private:
+	sf::RenderWindow* m_window;
+	//float m_pixels_per_meter;
+	static float pixels_per_meter;
+
+public:
+	SFMLDebugDraw(sf::RenderWindow& window, float pixels_per_meters);
+
+	/// Convert Box2D's OpenGL style color definition[0-1] to SFML's color definition[0-255], with optional alpha byte[Default - opaque]
+	static sf::Color GLColorToSFML(const b2Color& color, sf::Uint8 alpha = 255)
+	{
+		return sf::Color(static_cast<sf::Uint8>(color.r * 255), static_cast<sf::Uint8>(color.g * 255), static_cast<sf::Uint8>(color.b * 255), alpha);
+	}
+
+	/// Convert Box2D's vector to SFML vector [Default - scales the vector up by SCALE constants amount]
+	static sf::Vector2f B2VecToSFVec(const b2Vec2& vector, bool scaleToPixels = true)
+	{
+		return sf::Vector2f(vector.x * (scaleToPixels ? pixels_per_meter : 1.f), vector.y * (scaleToPixels ? pixels_per_meter : 1.f));
+	}
+
+	/// Draw a closed polygon provided in CCW order.
+	void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color);
+
+	/// Draw a solid closed polygon provided in CCW order.
+	void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color);
+
+	/// Draw a circle.
+	void DrawCircle(const b2Vec2& center, float radius, const b2Color& color);
+
+	/// Draw a solid circle.
+	void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color);
+
+	/// Draw a line segment.
+	void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color);
+
+	/// Draw a transform. Choose your own length scale.
+	void DrawTransform(const b2Transform& xf);
+
+	void DrawPoint(const b2Vec2& p, float size, const b2Color& color) override;
+};
diff --git a/battle_tanks/client/sources/debug_draw.cpp b/battle_tanks/client/sources/debug_draw.cpp
new file mode 100644
index 0000000..5c7f13a
--- /dev/null
+++ b/battle_tanks/client/sources/debug_draw.cpp
@@ -0,0 +1,111 @@
+#include "SFML/Graphics.hpp"
+
+#include "debug_draw.hpp"
+
+float SFMLDebugDraw::pixels_per_meter = 30.f;
+
+SFMLDebugDraw::SFMLDebugDraw(sf::RenderWindow& window, float pixels_per_meters) : m_window(&window)
+{
+	pixels_per_meter = pixels_per_meters;
+}
+
+void SFMLDebugDraw::DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color)
+{
+	sf::ConvexShape polygon(vertexCount);
+	sf::Vector2f center;
+	for (int i = 0; i < vertexCount; i++)
+	{
+		//polygon.setPoint(i, SFMLDraw::B2VecToSFVec(vertices[i]));
+		sf::Vector2f transformedVec = SFMLDebugDraw::B2VecToSFVec(vertices[i]);
+		polygon.setPoint(i, sf::Vector2f(std::floor(transformedVec.x), std::floor(transformedVec.y))); // flooring the coords to fix distorted lines on flat surfaces
+	}																								   // they still show up though.. but less frequently
+	polygon.setOutlineThickness(-1.f);
+	polygon.setFillColor(sf::Color::Transparent);
+	polygon.setOutlineColor(SFMLDebugDraw::GLColorToSFML(color));
+
+	m_window->draw(polygon);
+}
+void SFMLDebugDraw::DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color)
+{
+	sf::ConvexShape polygon(vertexCount);
+	for (int i = 0; i < vertexCount; i++)
+	{
+		//polygon.setPoint(i, SFMLDraw::B2VecToSFVec(vertices[i]));
+		sf::Vector2f transformedVec = SFMLDebugDraw::B2VecToSFVec(vertices[i]);
+		polygon.setPoint(i, sf::Vector2f(std::floor(transformedVec.x), std::floor(transformedVec.y))); // flooring the coords to fix distorted lines on flat surfaces
+	}																								   // they still show up though.. but less frequently
+	polygon.setOutlineThickness(-1.f);
+	polygon.setFillColor(SFMLDebugDraw::GLColorToSFML(color, 60));
+	polygon.setOutlineColor(SFMLDebugDraw::GLColorToSFML(color));
+
+	m_window->draw(polygon);
+}
+void SFMLDebugDraw::DrawCircle(const b2Vec2& center, float radius, const b2Color& color)
+{
+	sf::CircleShape circle(radius * pixels_per_meter);
+	circle.setOrigin(radius * pixels_per_meter, radius * pixels_per_meter);
+	circle.setPosition(SFMLDebugDraw::B2VecToSFVec(center));
+	circle.setFillColor(sf::Color::Transparent);
+	circle.setOutlineThickness(-1.f);
+	circle.setOutlineColor(SFMLDebugDraw::GLColorToSFML(color));
+
+	m_window->draw(circle);
+}
+void SFMLDebugDraw::DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color)
+{
+	sf::CircleShape circle(radius * pixels_per_meter);
+	circle.setOrigin(radius * pixels_per_meter, radius * pixels_per_meter);
+	circle.setPosition(SFMLDebugDraw::B2VecToSFVec(center));
+	circle.setFillColor(SFMLDebugDraw::GLColorToSFML(color, 60));
+	circle.setOutlineThickness(1.f);
+	circle.setOutlineColor(SFMLDebugDraw::GLColorToSFML(color));
+
+	b2Vec2 endPoint = center + radius * axis;
+	sf::Vertex line[2] =
+	{
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(center), SFMLDebugDraw::GLColorToSFML(color)),
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(endPoint), SFMLDebugDraw::GLColorToSFML(color)),
+	};
+
+	m_window->draw(circle);
+	m_window->draw(line, 2, sf::Lines);
+}
+void SFMLDebugDraw::DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color)
+{
+	sf::Vertex line[] =
+	{
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(p1), SFMLDebugDraw::GLColorToSFML(color)),
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(p2), SFMLDebugDraw::GLColorToSFML(color))
+	};
+
+	m_window->draw(line, 2, sf::Lines);
+}
+void SFMLDebugDraw::DrawTransform(const b2Transform& xf)
+{
+	float lineLength = 0.4;
+
+	/*b2Vec2 xAxis(b2Vec2(xf.p.x + (lineLength * xf.q.c), xf.p.y + (lineLength * xf.q.s)));*/
+	b2Vec2 xAxis = xf.p + lineLength * xf.q.GetXAxis();
+	sf::Vertex redLine[] =
+	{
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(xf.p), sf::Color::Red),
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(xAxis), sf::Color::Red)
+	};
+
+	// You might notice that the ordinate(Y axis) points downward unlike the one in Box2D testbed
+	// That's because the ordinate in SFML coordinate system points downward while the OpenGL(testbed) points upward
+	/*b2Vec2 yAxis(b2Vec2(xf.p.x + (lineLength * -xf.q.s), xf.p.y + (lineLength * xf.q.c)));*/
+	b2Vec2 yAxis = xf.p + lineLength * xf.q.GetYAxis();
+	sf::Vertex greenLine[] =
+	{
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(xf.p), sf::Color::Green),
+		sf::Vertex(SFMLDebugDraw::B2VecToSFVec(yAxis), sf::Color::Green)
+	};
+
+	m_window->draw(redLine, 2, sf::Lines);
+	m_window->draw(greenLine, 2, sf::Lines);
+}
+
+void SFMLDebugDraw::DrawPoint(const b2Vec2& p, float size, const b2Color& color)
+{
+}
diff --git a/external/headers/boost/di.hpp b/external/headers/boost/di.hpp
new file mode 100644
index 0000000..a07a2eb
--- /dev/null
+++ b/external/headers/boost/di.hpp
@@ -0,0 +1,3355 @@
+//
+// Copyright (c) 2012-2020 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#pragma once
+#if (__cplusplus < 201305L && _MSC_VER < 1900)
+#error "[Boost::ext].DI requires C++14 support (Clang-3.4+, GCC-5.1+, MSVC-2015+)"
+#else
+#define BOOST_DI_VERSION 1'3'0
+#define BOOST_DI_NAMESPACE_BEGIN \
+  namespace boost {              \
+  inline namespace ext {         \
+  namespace di {                 \
+  inline namespace v1_3_0 {
+#define BOOST_DI_NAMESPACE_END \
+  }                            \
+  }                            \
+  }                            \
+  }
+#if !defined(BOOST_DI_CFG_DIAGNOSTICS_LEVEL)
+#define BOOST_DI_CFG_DIAGNOSTICS_LEVEL 1
+#endif
+#if defined(BOOST_DI_CFG_FWD)
+BOOST_DI_CFG_FWD
+#endif
+#define __BOOST_DI_COMPILER(arg, ...) __BOOST_DI_COMPILER_IMPL(arg, __VA_ARGS__)
+#define __BOOST_DI_COMPILER_IMPL(arg, ...) arg##__VA_ARGS__
+#if defined(__clang__)
+#define __CLANG__ __BOOST_DI_COMPILER(__clang_major__, __clang_minor__)
+#define __BOOST_DI_UNUSED __attribute__((unused))
+#define __BOOST_DI_DEPRECATED(...) [[deprecated(__VA_ARGS__)]]
+#define __BOOST_DI_TYPE_WKND(T)
+#define __BOOST_DI_ACCESS_WKND private
+#define __BOOST_DI_VARIABLE_TEMPLATE_INIT_WKND \
+  {}
+#elif defined(__GNUC__)
+#define __GCC__
+#define __BOOST_DI_UNUSED __attribute__((unused))
+#define __BOOST_DI_DEPRECATED(...) [[deprecated(__VA_ARGS__)]]
+#define __BOOST_DI_TYPE_WKND(T)
+#define __BOOST_DI_ACCESS_WKND private
+#define __BOOST_DI_VARIABLE_TEMPLATE_INIT_WKND \
+  {}
+#elif defined(_MSC_VER)
+#define __MSVC__
+#if !defined(__has_include)
+#define __has_include(...) 0
+#endif
+#define __BOOST_DI_UNUSED
+#define __BOOST_DI_DEPRECATED(...) __declspec(deprecated(__VA_ARGS__))
+#define __BOOST_DI_TYPE_WKND(T) (T &&)
+#define __BOOST_DI_ACCESS_WKND public
+#define __BOOST_DI_VARIABLE_TEMPLATE_INIT_WKND
+#endif
+#if !defined(__has_builtin)
+#define __has_builtin(...) 0
+#endif
+#if !defined(__has_extension)
+#define __has_extension(...) 0
+#endif
+#if defined(__CLANG__)
+#if (!BOOST_DI_CFG_DIAGNOSTICS_LEVEL)
+#pragma clang diagnostic error "-Wdeprecated-declarations"
+#else
+#pragma clang diagnostic warning "-Wdeprecated-declarations"
+#endif
+#pragma clang diagnostic push
+#pragma clang diagnostic error "-Wundefined-inline"
+#pragma clang diagnostic error "-Wundefined-internal"
+#pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#elif defined(__GCC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic error "-Wdeprecated-declarations"
+#if (__GNUC__ < 6)
+#pragma GCC diagnostic error "-Werror"
+#endif
+#elif defined(__MSVC__)
+#pragma warning(disable : 4503)
+#pragma warning(disable : 4822)
+#pragma warning(disable : 4505)
+#endif
+#if defined(_LIBCPP_VERSION)
+#define NAMESPACE_STD_BEGIN _LIBCPP_BEGIN_NAMESPACE_STD {
+#else
+#define NAMESPACE_STD_BEGIN namespace std {
+#endif
+#if defined(_LIBCPP_VERSION)
+#define NAMESPACE_STD_END _LIBCPP_END_NAMESPACE_STD
+#else
+#define NAMESPACE_STD_END }
+#endif
+#if __has_include(<__config>)
+#include <__config>
+#endif
+#if __has_include(<memory>)
+#include <memory>
+#else
+NAMESPACE_STD_BEGIN
+template <class>
+class shared_ptr;
+template <class>
+class weak_ptr;
+template <class, class>
+class unique_ptr;
+NAMESPACE_STD_END
+#endif
+#if __has_include(<vector>)
+#include <vector>
+#else
+NAMESPACE_STD_BEGIN
+template <class, class>
+class vector;
+NAMESPACE_STD_END
+#endif
+#if __has_include(<set>)
+#include <set>
+#else
+NAMESPACE_STD_BEGIN
+template <class, class, class>
+class set;
+NAMESPACE_STD_END
+#endif
+#if __has_include(<initializer_list>)
+#include <initializer_list>
+#else
+NAMESPACE_STD_BEGIN
+template <class>
+class initializer_list;
+NAMESPACE_STD_END
+#endif
+#if __has_include(<tuple>)
+#include <tuple>
+#else
+NAMESPACE_STD_BEGIN
+template <class...>
+class tuple;
+NAMESPACE_STD_END
+#endif
+#if __has_include(<iterator>)
+#include <iterator>
+#else
+NAMESPACE_STD_BEGIN
+template <class>
+class move_iterator;
+NAMESPACE_STD_END
+#endif
+#if __has_include(<string>)
+#include <string>
+#else
+NAMESPACE_STD_BEGIN
+template <class>
+struct char_traits;
+NAMESPACE_STD_END
+#endif
+// clang-format off
+#if __has_include(<boost/shared_ptr.hpp>)
+// clang-format on
+#include <boost/shared_ptr.hpp>
+#else
+namespace boost {
+template <class>
+class shared_ptr;
+}
+#endif
+BOOST_DI_NAMESPACE_BEGIN
+struct _ {
+  _(...) {}
+};
+namespace aux {
+using swallow = int[];
+template <class T>
+using owner = T;
+template <class...>
+struct valid {
+  using type = int;
+};
+template <class... Ts>
+using valid_t = typename valid<Ts...>::type;
+template <class...>
+struct type {};
+struct none_type {};
+template <class T, T>
+struct non_type {};
+template <class...>
+struct always {
+  static constexpr auto value = true;
+};
+template <class...>
+struct never {
+  static constexpr auto value = false;
+};
+template <class T, class...>
+struct identity {
+  using type = T;
+};
+template <class...>
+struct type_list {
+  using type = type_list;
+};
+template <bool...>
+struct bool_list {
+  using type = bool_list;
+};
+template <class T1, class T2>
+struct pair {
+  using type = pair;
+  using first = T1;
+  using second = T2;
+};
+template <class... Ts>
+struct inherit : Ts... {
+  using type = inherit;
+};
+template <class... Ts>
+struct join {
+  using type = type_list<>;
+};
+template <class T>
+struct join<T> {
+  using type = T;
+};
+template <class... T1s, class... T2s, class... Ts>
+struct join<type_list<T1s...>, type_list<T2s...>, Ts...> : join<type_list<T1s..., T2s...>, Ts...> {};
+template <class... Ts, class... T1s, class... T2s, class... T3s, class... T4s, class... T5s, class... T6s, class... T7s,
+          class... T8s, class... T9s, class... T10s, class... T11s, class... T12s, class... T13s, class... T14s, class... T15s,
+          class... T16s, class... Us>
+struct join<type_list<Ts...>, type_list<T1s...>, type_list<T2s...>, type_list<T3s...>, type_list<T4s...>, type_list<T5s...>,
+            type_list<T6s...>, type_list<T7s...>, type_list<T8s...>, type_list<T9s...>, type_list<T10s...>, type_list<T11s...>,
+            type_list<T12s...>, type_list<T13s...>, type_list<T14s...>, type_list<T15s...>, type_list<T16s...>, Us...>
+    : join<type_list<Ts..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s..., T8s..., T9s..., T10s..., T11s..., T12s...,
+                     T13s..., T14s..., T15s..., T16s...>,
+           Us...> {};
+template <class... TArgs>
+using join_t = typename join<TArgs...>::type;
+template <int...>
+struct index_sequence {
+  using type = index_sequence;
+};
+#if __has_builtin(__make_integer_seq)
+template <class T, T... Ns>
+struct integer_sequence {
+  using type = index_sequence<Ns...>;
+};
+template <int N>
+struct make_index_sequence_impl {
+  using type = typename __make_integer_seq<integer_sequence, int, N>::type;
+};
+#else
+template <class...>
+struct build_index_sequence;
+template <int... Cs1, int... Cs2>
+struct build_index_sequence<index_sequence<Cs1...>, index_sequence<Cs2...>> {
+  using type = index_sequence<Cs1..., sizeof...(Cs1) + Cs1..., 2 * sizeof...(Cs1) + Cs2...>;
+};
+template <int N>
+struct make_index_sequence_impl {
+  using type = typename build_index_sequence<typename make_index_sequence_impl<N / 2>::type,
+                                             typename make_index_sequence_impl<N % 2>::type>::type;
+};
+template <>
+struct make_index_sequence_impl<0> : index_sequence<> {};
+template <>
+struct make_index_sequence_impl<1> : index_sequence<0> {};
+template <>
+struct make_index_sequence_impl<2> : index_sequence<0, 1> {};
+template <>
+struct make_index_sequence_impl<3> : index_sequence<0, 1, 2> {};
+template <>
+struct make_index_sequence_impl<4> : index_sequence<0, 1, 2, 3> {};
+template <>
+struct make_index_sequence_impl<5> : index_sequence<0, 1, 2, 3, 4> {};
+template <>
+struct make_index_sequence_impl<6> : index_sequence<0, 1, 2, 3, 4, 5> {};
+template <>
+struct make_index_sequence_impl<7> : index_sequence<0, 1, 2, 3, 4, 5, 6> {};
+template <>
+struct make_index_sequence_impl<8> : index_sequence<0, 1, 2, 3, 4, 5, 6, 7> {};
+template <>
+struct make_index_sequence_impl<9> : index_sequence<0, 1, 2, 3, 4, 5, 6, 7, 8> {};
+template <>
+struct make_index_sequence_impl<10> : index_sequence<0, 1, 2, 3, 4, 5, 6, 7, 8, 9> {};
+#endif
+template <int N>
+using make_index_sequence = typename make_index_sequence_impl<N>::type;
+}
+namespace placeholders {
+__BOOST_DI_UNUSED static const struct arg {
+} _{};
+}
+template <class, class = void>
+struct named {};
+struct no_name {
+  constexpr auto operator()() const noexcept { return ""; }
+};
+template <class, class = int>
+struct ctor_traits;
+template <class>
+struct self {};
+struct ignore_policies {};
+namespace core {
+template <class>
+struct any_type_fwd;
+template <class>
+struct any_type_ref_fwd;
+template <class>
+struct any_type_1st_fwd;
+template <class>
+struct any_type_1st_ref_fwd;
+struct dependency_base {};
+struct injector_base {};
+template <class T>
+struct dependency__ : T {
+  using T::create;
+  using T::is_referable;
+  using T::try_create;
+};
+template <class T>
+struct injector__ : T {
+  using T::cfg;
+  using T::create_impl;
+  using T::create_successful_impl;
+#if defined(__MSVC__)
+  template <class... Ts>
+  using is_creatable = typename T::template is_creatable<Ts...>;
+  template <class... Ts>
+  using try_create = typename T::template try_create<Ts...>;
+#else
+  using T::is_creatable;
+  using T::try_create;
+#endif
+};
+template <class, class...>
+struct array;
+struct deduced {};
+struct none {};
+template <class, class TExpected = deduced, class = TExpected, class = no_name, class = void, class = none>
+class dependency;
+}
+namespace scopes {
+class deduce;
+class instance;
+class singleton;
+class unique;
+}
+#define __BOOST_DI_REQUIRES(...) typename ::boost::ext::di::v1_3_0::aux::enable_if<__VA_ARGS__, int>::type
+#define __BOOST_DI_REQUIRES_MSG(...) typename ::boost::ext::di::v1_3_0::aux::concept_check<__VA_ARGS__>::type
+namespace aux {
+template <class T>
+T&& declval();
+template <class T, T V>
+struct integral_constant {
+  using type = integral_constant;
+  static constexpr T value = V;
+};
+using true_type = integral_constant<bool, true>;
+using false_type = integral_constant<bool, false>;
+template <bool B, class T, class F>
+struct conditional {
+  using type = T;
+};
+template <class T, class F>
+struct conditional<false, T, F> {
+  using type = F;
+};
+template <bool B, class T, class F>
+using conditional_t = typename conditional<B, T, F>::type;
+template <bool B, class T = void>
+struct enable_if {};
+template <class T>
+struct enable_if<true, T> {
+  using type = T;
+};
+template <bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+template <class T>
+struct concept_check {
+  static_assert(T::value, "constraint not satisfied");
+};
+template <>
+struct concept_check<true_type> {
+  using type = int;
+};
+template <class T>
+struct remove_reference {
+  using type = T;
+};
+template <class T>
+struct remove_reference<T&> {
+  using type = T;
+};
+template <class T>
+struct remove_reference<T&&> {
+  using type = T;
+};
+template <class T>
+using remove_reference_t = typename remove_reference<T>::type;
+template <class T>
+struct remove_pointer {
+  using type = T;
+};
+template <class T>
+struct remove_pointer<T*> {
+  using type = T;
+};
+template <class T>
+using remove_pointer_t = typename remove_pointer<T>::type;
+template <class T>
+struct remove_smart_ptr {
+  using type = T;
+};
+template <class T, class TDeleter>
+struct remove_smart_ptr<std::unique_ptr<T, TDeleter>> {
+  using type = T;
+};
+template <class T>
+struct remove_smart_ptr<std::shared_ptr<T>> {
+  using type = T;
+};
+template <class T>
+struct remove_smart_ptr<std::weak_ptr<T>> {
+  using type = T;
+};
+template <class T>
+struct remove_smart_ptr<boost::shared_ptr<T>> {
+  using type = T;
+};
+template <class T>
+using remove_smart_ptr_t = typename remove_smart_ptr<T>::type;
+template <class T>
+struct remove_qualifiers {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<const T> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<T&> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<const T&> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<T*> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<const T*> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<T* const&> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<T* const> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<const T* const> {
+  using type = T;
+};
+template <class T>
+struct remove_qualifiers<T&&> {
+  using type = T;
+};
+template <class T>
+using remove_qualifiers_t = typename remove_qualifiers<T>::type;
+template <class T>
+struct remove_extent {
+  using type = T;
+};
+template <class T>
+struct remove_extent<T[]> {
+  using type = T;
+};
+template <class T>
+using remove_extent_t = typename remove_extent<T>::type;
+template <class T>
+struct deref_type {
+  using type = T;
+};
+template <class T, class TDeleter>
+struct deref_type<std::unique_ptr<T, TDeleter>> {
+  using type = remove_qualifiers_t<typename deref_type<T>::type>;
+};
+template <class T>
+struct deref_type<std::shared_ptr<T>> {
+  using type = remove_qualifiers_t<typename deref_type<T>::type>;
+};
+template <class T>
+struct deref_type<boost::shared_ptr<T>> {
+  using type = remove_qualifiers_t<typename deref_type<T>::type>;
+};
+template <class T>
+struct deref_type<std::weak_ptr<T>> {
+  using type = remove_qualifiers_t<typename deref_type<T>::type>;
+};
+template <class T, class TAllocator>
+struct deref_type<std::vector<T, TAllocator>> {
+  using type = core::array<remove_qualifiers_t<typename deref_type<T>::type>>;
+};
+template <class TKey, class TCompare, class TAllocator>
+struct deref_type<std::set<TKey, TCompare, TAllocator>> {
+  using type = core::array<remove_qualifiers_t<typename deref_type<TKey>::type>>;
+};
+template <class T>
+struct deref_type<std::initializer_list<T>> {
+  using type = core::array<remove_qualifiers_t<typename deref_type<T>::type>>;
+};
+template <class T>
+using decay_t = typename deref_type<remove_qualifiers_t<T>>::type;
+template <class, class>
+struct is_same : false_type {};
+template <class T>
+struct is_same<T, T> : true_type {};
+template <class T, class U>
+struct is_base_of : integral_constant<bool, __is_base_of(T, U)> {};
+template <class T>
+struct is_class : integral_constant<bool, __is_class(T)> {};
+template <class T>
+struct is_abstract : integral_constant<bool, __is_abstract(T)> {};
+template <class T>
+struct is_polymorphic : integral_constant<bool, __is_polymorphic(T)> {};
+template <class T>
+struct is_final : integral_constant<bool, __is_final(T)> {};
+template <class...>
+using is_valid_expr = true_type;
+#if __has_extension(is_constructible) && !((__clang_major__ == 3) && (__clang_minor__ == 5))
+template <class T, class... TArgs>
+using is_constructible = integral_constant<bool, __is_constructible(T, TArgs...)>;
+#else
+template <class T, class... TArgs>
+decltype(void(T(declval<TArgs>()...)), true_type{}) test_is_constructible(int);
+template <class, class...>
+false_type test_is_constructible(...);
+template <class T, class... TArgs>
+struct is_constructible : decltype(test_is_constructible<T, TArgs...>(0)) {};
+#endif
+template <class T, class... TArgs>
+using is_constructible_t = typename is_constructible<T, TArgs...>::type;
+template <class T, class... TArgs>
+decltype(void(T{declval<TArgs>()...}), true_type{}) test_is_braces_constructible(int);
+template <class, class...>
+false_type test_is_braces_constructible(...);
+template <class T, class... TArgs>
+using is_braces_constructible = decltype(test_is_braces_constructible<T, TArgs...>(0));
+template <class T, class... TArgs>
+using is_braces_constructible_t = typename is_braces_constructible<T, TArgs...>::type;
+#if defined(__MSVC__)
+template <class T>
+struct is_copy_constructible : integral_constant<bool, __is_constructible(T, const T&)> {};
+template <class T>
+struct is_default_constructible : integral_constant<bool, __is_constructible(T)> {};
+#else
+template <class T>
+using is_copy_constructible = is_constructible<T, const T&>;
+template <class T>
+using is_default_constructible = is_constructible<T>;
+#endif
+#if defined(__CLANG__) || defined(__MSVC__)
+template <class T, class U>
+struct is_convertible : integral_constant<bool, __is_convertible_to(T, U)> {};
+#else
+struct test_is_convertible__ {
+  template <class T>
+  static void test(T);
+};
+template <class T, class U, class = decltype(test_is_convertible__::test<U>(declval<T>()))>
+true_type test_is_convertible(int);
+template <class, class>
+false_type test_is_convertible(...);
+template <class T, class U>
+using is_convertible = decltype(test_is_convertible<T, U>(0));
+#endif
+template <class TSrc, class TDst, class U = remove_qualifiers_t<TDst>>
+using is_narrowed = integral_constant<bool, !is_class<TSrc>::value && !is_class<U>::value && !is_same<TSrc, U>::value>;
+template <class, class...>
+struct is_array : false_type {};
+template <class T, class... Ts>
+struct is_array<T[], Ts...> : true_type {};
+template <class T, class = decltype(sizeof(T))>
+true_type is_complete_impl(int);
+template <class T>
+false_type is_complete_impl(...);
+template <class T>
+struct is_complete : decltype(is_complete_impl<T>(0)) {};
+template <class T, class U, class = decltype(sizeof(U))>
+is_base_of<T, U> is_a_impl(int);
+template <class T, class U>
+false_type is_a_impl(...);
+template <class T, class U>
+struct is_a : decltype(is_a_impl<T, U>(0)) {};
+template <class, class...>
+struct is_unique_impl;
+template <class...>
+struct not_unique : false_type {
+  using type = not_unique;
+};
+template <>
+struct not_unique<> : true_type {
+  using type = not_unique;
+};
+template <class T>
+struct is_unique_impl<T> : not_unique<> {};
+template <class T1, class T2, class... Ts>
+struct is_unique_impl<T1, T2, Ts...>
+    : conditional_t<is_base_of<type<T2>, T1>::value, not_unique<T2>, is_unique_impl<inherit<T1, type<T2>>, Ts...>> {};
+template <class... Ts>
+using is_unique = is_unique_impl<none_type, Ts...>;
+template <class...>
+struct unique;
+template <class... Rs, class T, class... Ts>
+struct unique<type<Rs...>, T, Ts...> : conditional_t<is_base_of<type<T>, inherit<type<Rs>...>>::value,
+                                                     unique<type<Rs...>, Ts...>, unique<type<Rs..., T>, Ts...>> {};
+template <class... Rs>
+struct unique<type<Rs...>> : type_list<Rs...> {};
+template <class... Ts>
+using unique_t = typename unique<type<>, Ts...>::type;
+false_type has_shared_ptr__(...);
+#if !defined(BOOST_DI_DISABLE_SHARED_PTR_DEDUCTION)
+template <class T>
+auto has_shared_ptr__(T&&) -> is_valid_expr<decltype(std::shared_ptr<T>{})>;
+#endif
+template <class T, class... TArgs>
+decltype(::boost::ext::di::v1_3_0::aux::declval<T>().operator()(::boost::ext::di::v1_3_0::aux::declval<TArgs>()...),
+         ::boost::ext::di::v1_3_0::aux::true_type())
+is_invocable_impl(int);
+template <class, class...>
+::boost::ext::di::v1_3_0::aux::false_type is_invocable_impl(...);
+template <class T, class... TArgs>
+struct is_invocable : decltype(is_invocable_impl<T, TArgs...>(0)) {};
+struct callable_base_impl {
+  void operator()(...) {}
+};
+template <class T>
+struct callable_base : callable_base_impl,
+                       aux::conditional_t<aux::is_class<T>::value && !aux::is_final<T>::value, T, aux::none_type> {};
+template <typename T>
+aux::false_type is_callable_impl(T*, aux::non_type<void (callable_base_impl::*)(...), &T::operator()>* = 0);
+aux::true_type is_callable_impl(...);
+template <class T>
+struct is_callable : decltype(is_callable_impl(aux::declval<callable_base<T>*>())) {};
+template <class, class = int>
+struct is_empty_expr : false_type {};
+template <class TExpr>
+#if defined(__MSVC__)
+struct is_empty_expr<TExpr, valid_t<decltype(declval<TExpr>()())>> : integral_constant<bool, sizeof(TExpr) == 1> {
+};
+#else
+struct is_empty_expr<TExpr, valid_t<decltype(+declval<TExpr>()), decltype(declval<TExpr>()())>> : true_type {
+};
+#endif
+template <class>
+struct function_traits;
+template <class R, class... TArgs>
+struct function_traits<R (*)(TArgs...)> {
+  using result_type = R;
+  using args = type_list<TArgs...>;
+};
+template <class R, class... TArgs>
+struct function_traits<R(TArgs...)> {
+  using result_type = R;
+  using args = type_list<TArgs...>;
+};
+template <class R, class T, class... TArgs>
+struct function_traits<R (T::*)(TArgs...)> {
+  using result_type = R;
+  using args = type_list<TArgs...>;
+};
+template <class R, class T, class... TArgs>
+struct function_traits<R (T::*)(TArgs...) const> {
+  using result_type = R;
+  using args = type_list<TArgs...>;
+};
+template <class T>
+using function_traits_t = typename function_traits<T>::args;
+}
+namespace core {
+template <class T, class = typename aux::is_a<injector_base, T>::type>
+struct bindings_impl;
+template <class T>
+struct bindings_impl<T, aux::true_type> {
+  using type = typename T::deps;
+};
+template <class T>
+struct bindings_impl<T, aux::false_type> {
+  using type = aux::type_list<T>;
+};
+#if defined(__MSVC__)
+template <class... Ts>
+struct bindings : aux::join_t<typename bindings_impl<Ts>::type...> {};
+template <class... Ts>
+using bindings_t = typename bindings<Ts...>::type;
+#else
+template <class... Ts>
+using bindings_t = aux::join_t<typename bindings_impl<Ts>::type...>;
+#endif
+}
+namespace concepts {
+template <class T, class...>
+struct type_ {
+  template <class TName>
+  struct named {
+    struct is_bound_more_than_once : aux::false_type {};
+  };
+  struct is_bound_more_than_once : aux::false_type {};
+  struct is_neither_a_dependency_nor_an_injector : aux::false_type {};
+  struct has_disallowed_qualifiers : aux::false_type {};
+  struct is_abstract :
+#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL >= 2)
+      // clang-format off
+      decltype(
+    T{}
+   ),
+// clang-format on
+#endif
+      aux::false_type {
+  };
+  template <class>
+  struct is_not_related_to : aux::false_type {};
+};
+template <class...>
+struct any_of : aux::false_type {};
+template <class... TDeps>
+struct is_supported
+    : aux::is_same<aux::bool_list<aux::always<TDeps>::value...>,
+                   aux::bool_list<(aux::is_constructible<TDeps, TDeps&&>::value &&
+                                   (aux::is_a<core::injector_base, TDeps>::value ||
+                                    aux::is_a<core::dependency_base, TDeps>::value || aux::is_empty_expr<TDeps>::value))...>> {
+};
+template <class...>
+struct get_not_supported;
+template <class T>
+struct get_not_supported<T> {
+  using type = T;
+};
+template <class T, class... TDeps>
+struct get_not_supported<T, TDeps...>
+    : aux::conditional<aux::is_a<core::injector_base, T>::value || aux::is_a<core::dependency_base, T>::value,
+                       typename get_not_supported<TDeps...>::type, T> {};
+template <class>
+struct is_unique;
+template <class T, class = int>
+struct unique_dependency : aux::type<T> {};
+template <class T>
+struct unique_dependency<T, __BOOST_DI_REQUIRES(aux::is_a<core::dependency_base, T>::value)>
+    : aux::pair<aux::pair<typename T::expected, typename T::name>, typename T::priority> {};
+template <class... TDeps>
+struct is_unique<aux::type_list<TDeps...>> : aux::is_unique<typename unique_dependency<TDeps>::type...> {};
+template <class>
+struct get_is_unique_error_impl : aux::true_type {};
+template <class T, class TName, class TPriority>
+struct get_is_unique_error_impl<aux::not_unique<aux::pair<aux::pair<T, TName>, TPriority>>> {
+  using type = typename type_<T>::template named<TName>::is_bound_more_than_once;
+};
+template <class T, class TPriority>
+struct get_is_unique_error_impl<aux::not_unique<aux::pair<aux::pair<T, no_name>, TPriority>>> {
+  using type = typename type_<T>::is_bound_more_than_once;
+};
+template <class T>
+struct get_is_unique_error_impl<aux::not_unique<T>> {
+  using type = typename type_<T>::is_bound_more_than_once;
+};
+template <class>
+struct get_is_unique_error;
+template <class... TDeps>
+struct get_is_unique_error<aux::type_list<TDeps...>>
+    : get_is_unique_error_impl<typename aux::is_unique<typename unique_dependency<TDeps>::type...>::type> {};
+template <class... TDeps>
+using boundable_bindings =
+    aux::conditional_t<is_supported<TDeps...>::value, typename get_is_unique_error<core::bindings_t<TDeps...>>::type,
+                       typename type_<typename get_not_supported<TDeps...>::type>::is_neither_a_dependency_nor_an_injector>;
+template <class... Ts>
+struct get_any_of_error : aux::conditional<aux::is_same<aux::bool_list<aux::always<Ts>::value...>,
+                                                        aux::bool_list<aux::is_same<aux::true_type, Ts>::value...>>::value,
+                                           aux::true_type, any_of<Ts...>> {};
+template <bool, class...>
+struct is_related {
+  static constexpr auto value = true;
+};
+template <class I, class T>
+struct is_related<true, I, T> {
+  static constexpr auto value =
+      aux::is_base_of<I, T>::value || (aux::is_convertible<T, I>::value && !aux::is_narrowed<I, T>::value);
+};
+template <bool, class>
+struct is_abstract {
+  static constexpr auto value = false;
+};
+template <class T>
+struct is_abstract<true, T> {
+  static constexpr auto value = aux::is_abstract<T>::value;
+};
+auto boundable_impl(any_of<>&&) -> aux::true_type;
+template <class T, class... Ts>
+auto boundable_impl(any_of<T, Ts...>&&)
+    -> aux::conditional_t<aux::is_same<T, aux::decay_t<T>>::value, decltype(boundable_impl(aux::declval<any_of<Ts...>>())),
+                          typename type_<T>::has_disallowed_qualifiers>;
+template <class I, class T>
+using boundable_impl__ = aux::conditional_t<
+    is_related<aux::is_complete<I>::value && aux::is_complete<T>::value, I, T>::value,
+    aux::conditional_t<is_abstract<aux::is_complete<T>::value, T>::value, typename type_<T>::is_abstract, aux::true_type>,
+    typename type_<T>::template is_not_related_to<I>>;
+template <class I, class T>
+auto boundable_impl(I&&, T&&) -> aux::conditional_t<aux::is_same<T, aux::decay_t<T>>::value || !aux::is_complete<I>::value,
+                                                    boundable_impl__<I, T>, typename type_<T>::has_disallowed_qualifiers>;
+template <class I, class T>
+auto boundable_impl(I&&, T&&, aux::valid<>&&)
+    -> aux::conditional_t<is_related<aux::is_complete<I>::value && aux::is_complete<T>::value, I, T>::value, aux::true_type,
+                          typename type_<T>::template is_not_related_to<I>>;
+template <class I, class T>
+auto boundable_impl(I*[], T&&) -> aux::conditional_t<aux::is_same<I, aux::decay_t<I>>::value, boundable_impl__<I, T>,
+                                                     typename type_<I>::has_disallowed_qualifiers>;
+template <class I, class T>
+auto boundable_impl(I[], T&&) -> aux::conditional_t<aux::is_same<I, aux::decay_t<I>>::value, boundable_impl__<I, T>,
+                                                    typename type_<I>::has_disallowed_qualifiers>;
+template <class... TDeps>
+auto boundable_impl(aux::type_list<TDeps...>&&) -> boundable_bindings<TDeps...>;
+template <class T, class... Ts>
+auto boundable_impl(concepts::any_of<Ts...>&&, T&&) ->
+    typename get_any_of_error<decltype(boundable_impl(aux::declval<Ts>(), aux::declval<T>()))...>::type;
+template <class... TDeps>
+auto boundable_impl(aux::type<TDeps...>&&) -> typename get_is_unique_error_impl<typename aux::is_unique<TDeps...>::type>::type;
+aux::true_type boundable_impl(...);
+template <class... Ts>
+struct boundable__ {
+  using type = decltype(boundable_impl(aux::declval<Ts>()...));
+};
+template <class... Ts>
+using boundable = typename boundable__<Ts...>::type;
+}
+namespace type_traits {
+struct stack {};
+struct heap {};
+template <class T, class = int>
+struct memory_traits {
+  using type = stack;
+};
+template <class T>
+struct memory_traits<T*> {
+  using type = heap;
+};
+template <class T>
+struct memory_traits<const T&> {
+  using type = typename memory_traits<T>::type;
+};
+template <class T, class TDeleter>
+struct memory_traits<std::unique_ptr<T, TDeleter>> {
+  using type = heap;
+};
+template <class T>
+struct memory_traits<std::shared_ptr<T>> {
+  using type = heap;
+};
+template <class T>
+struct memory_traits<boost::shared_ptr<T>> {
+  using type = heap;
+};
+template <class T>
+struct memory_traits<std::weak_ptr<T>> {
+  using type = heap;
+};
+template <class T>
+struct memory_traits<T, __BOOST_DI_REQUIRES(aux::is_polymorphic<T>::value)> {
+  using type = heap;
+};
+}
+namespace concepts {
+template <class...>
+struct scope {
+  struct is_referable {};
+  struct try_create {};
+  struct create {};
+  template <class...>
+  struct requires_ : aux::false_type {};
+};
+template <class>
+struct scope__ {
+  template <class...>
+  struct scope {
+    template <class...>
+    using is_referable = aux::true_type;
+    template <class T, class, class TProvider>
+    T try_create(const TProvider&);
+    template <class T, class, class TProvider>
+    T create(const TProvider&);
+  };
+};
+template <class>
+struct config__ {
+  template <class T>
+  struct scope_traits {
+    using type = scope__<T>;
+  };
+  template <class T>
+  struct memory_traits {
+    using type = type_traits::heap;
+  };
+};
+template <class T>
+struct provider__ {
+  using config = config__<T>;
+  template <class TMemory = type_traits::heap>
+  aux::conditional_t<aux::is_same<TMemory, type_traits::stack>::value, T, T*> try_get(const TMemory& = {}) const;
+  template <class TMemory = type_traits::heap>
+  T* get(const TMemory& = {}) const {
+    return nullptr;
+  }
+  config& cfg() const;
+};
+template <class T>
+typename scope<T>::template requires_<typename scope<_, _>::is_referable, typename scope<_, _>::try_create,
+                                      typename scope<_, _>::create>
+scopable_impl(...);
+template <class T>
+auto scopable_impl(T&&)
+    -> aux::is_valid_expr<typename T::template scope<_, _>::template is_referable<_, config__<_>>,
+                          decltype(T::template scope<_, _>::template try_create<_, _>(provider__<_>{})),
+                          decltype(aux::declval<typename T::template scope<_, _>>().template create<_, _>(provider__<_>{}))>;
+template <class T>
+struct scopable__ {
+  using type = decltype(scopable_impl<T>(aux::declval<T>()));
+};
+template <class T>
+using scopable = typename scopable__<T>::type;
+}
+namespace core {
+template <class = aux::type_list<>>
+struct pool;
+template <class... TArgs>
+using pool_t = pool<aux::type_list<TArgs...>>;
+template <class... TArgs>
+struct pool<aux::type_list<TArgs...>> : TArgs... {
+  template <class... Ts>
+  explicit pool(Ts... args) noexcept : Ts(static_cast<Ts&&>(args))... {}
+  template <class... Ts, class TPool>
+  pool(const aux::type_list<Ts...>&, TPool p) noexcept : pool(static_cast<Ts&&>(p)...) {
+    (void)p;
+  }
+  template <class T>
+  pool& operator=(T&& other) noexcept {
+    (void)aux::swallow{0, (static_cast<TArgs&>(*this).operator=(static_cast<TArgs&&>(other)), 0)...};
+    return *this;
+  }
+};
+}
+#if !defined(BOOST_DI_CFG_CTOR_LIMIT_SIZE)
+#define BOOST_DI_CFG_CTOR_LIMIT_SIZE 10
+#endif
+namespace type_traits {
+template <class, class = int>
+struct is_injectable : ::boost::ext::di::v1_3_0::aux::false_type {};
+template <class T>
+struct is_injectable<T, ::boost::ext::di::v1_3_0::aux::valid_t<typename T::boost_di_inject__>>
+    : ::boost::ext::di::v1_3_0::aux::true_type {};
+struct direct {};
+struct uniform {};
+template <class T, int>
+using get = T;
+template <template <class...> class, class, class, class = int>
+struct ctor_impl;
+template <template <class...> class TIsConstructible, class T>
+struct ctor_impl<TIsConstructible, T, aux::index_sequence<>> : aux::type_list<> {};
+template <template <class...> class TIsConstructible, class T>
+struct ctor_impl<TIsConstructible, T, aux::index_sequence<0>,
+                 __BOOST_DI_REQUIRES(TIsConstructible<T, core::any_type_1st_fwd<T>>::value)>
+    : aux::type_list<core::any_type_1st_fwd<T>> {};
+template <template <class...> class TIsConstructible, class T>
+struct ctor_impl<TIsConstructible, T, aux::index_sequence<0>,
+                 __BOOST_DI_REQUIRES(!TIsConstructible<T, core::any_type_1st_fwd<T>>::value)>
+    : aux::conditional_t<TIsConstructible<T, core::any_type_1st_ref_fwd<T>>::value,
+                         aux::type_list<core::any_type_1st_ref_fwd<T>>, aux::type_list<>> {};
+template <template <class...> class TIsConstructible, class T, int... Ns>
+struct ctor_impl<TIsConstructible, T, aux::index_sequence<Ns...>,
+                 __BOOST_DI_REQUIRES((sizeof...(Ns) > 1) && TIsConstructible<T, get<core::any_type_fwd<T>, Ns>...>::value)>
+    : aux::type_list<get<core::any_type_fwd<T>, Ns>...> {};
+template <template <class...> class TIsConstructible, class T, int... Ns>
+struct ctor_impl<TIsConstructible, T, aux::index_sequence<Ns...>,
+                 __BOOST_DI_REQUIRES((sizeof...(Ns) > 1) && !TIsConstructible<T, get<core::any_type_fwd<T>, Ns>...>::value)>
+    : aux::conditional<TIsConstructible<T, get<core::any_type_ref_fwd<T>, Ns>...>::value,
+                       aux::type_list<get<core::any_type_ref_fwd<T>, Ns>...>,
+                       typename ctor_impl<TIsConstructible, T, aux::make_index_sequence<sizeof...(Ns) - 1>>::type> {};
+template <template <class...> class TIsConstructible, class T>
+using ctor_impl_t = typename ctor_impl<TIsConstructible, T, aux::make_index_sequence<BOOST_DI_CFG_CTOR_LIMIT_SIZE>>::type;
+template <class...>
+struct ctor;
+template <class T>
+struct ctor<T, aux::type_list<>> : aux::pair<uniform, ctor_impl_t<aux::is_braces_constructible, T>> {};
+template <class T, class... TArgs>
+struct ctor<T, aux::type_list<TArgs...>> : aux::pair<direct, aux::type_list<TArgs...>> {};
+template <class T, class, class = typename is_injectable<ctor_traits<T>>::type>
+struct ctor_traits_impl;
+template <class T, class = void, class = void, class = typename is_injectable<T>::type>
+struct ctor_traits__;
+template <class T, class _1, class _2>
+struct ctor_traits__<T, _1, _2, aux::true_type> : aux::pair<T, aux::pair<direct, typename T::boost_di_inject__::type>> {};
+template <class T, class _1, class _2>
+struct ctor_traits__<T, _1, _2, aux::false_type> : ctor_traits_impl<T, _1> {};
+template <class T, class _1, class... Ts>
+struct ctor_traits__<T, _1, core::pool_t<Ts...>, aux::false_type> : aux::pair<T, aux::pair<uniform, aux::type_list<Ts...>>> {};
+template <class T, class _>
+struct ctor_traits_impl<T, _, aux::true_type>
+    : aux::pair<T, aux::pair<direct, typename ctor_traits<T>::boost_di_inject__::type>> {};
+template <class T, class _>
+struct ctor_traits_impl<T, _, aux::false_type> : aux::pair<T, typename ctor_traits<T>::type> {};
+}
+template <class T, class>
+struct ctor_traits : type_traits::ctor<T, type_traits::ctor_impl_t<aux::is_constructible, T>> {};
+template <class T>
+struct ctor_traits<std::initializer_list<T>> {
+  using boost_di_inject__ = aux::type_list<>;
+};
+template <class... Ts>
+struct ctor_traits<std::tuple<Ts...>> {
+  using boost_di_inject__ = aux::type_list<Ts...>;
+};
+template <class T>
+struct ctor_traits<T, __BOOST_DI_REQUIRES(aux::is_same<std::char_traits<char>, typename T::traits_type>::value)> {
+  using boost_di_inject__ = aux::type_list<>;
+};
+template <class T>
+struct ctor_traits<T, __BOOST_DI_REQUIRES(!aux::is_class<T>::value)> {
+  using boost_di_inject__ = aux::type_list<>;
+};
+namespace type_traits {
+template <class T>
+struct remove_named {
+  using type = T;
+};
+template <class TName, class T>
+struct remove_named<named<TName, T>> {
+  using type = T;
+};
+template <class T>
+using remove_named_t = typename remove_named<T>::type;
+template <class T>
+struct add_named {
+  using type = named<no_name, T>;
+};
+template <class TName, class T>
+struct add_named<named<TName, T>> {
+  using type = named<TName, T>;
+};
+template <class T>
+using add_named_t = typename add_named<T>::type;
+template <class T>
+struct named_decay {
+  using type = aux::decay_t<T>;
+};
+template <class TName, class T>
+struct named_decay<named<TName, T>> {
+  using type = named<TName, aux::decay_t<T>>;
+};
+template <class T>
+using named_decay_t = typename named_decay<T>::type;
+}
+namespace type_traits {
+template <class, class T>
+struct rebind_traits {
+  using type = T;
+};
+template <class T, class TName, class _>
+struct rebind_traits<T, named<TName, _>> {
+  using type = named<TName, T>;
+};
+template <class T, class D, class U>
+struct rebind_traits<std::unique_ptr<T, D>, U> {
+  using type = std::unique_ptr<U, D>;
+};
+template <class T, class D, class TName, class _>
+struct rebind_traits<std::unique_ptr<T, D>, named<TName, _>> {
+  using type = named<TName, std::unique_ptr<T, D>>;
+};
+template <class T, class U>
+struct rebind_traits<std::shared_ptr<T>, U> {
+  using type = std::shared_ptr<U>;
+};
+template <class T, class TName, class _>
+struct rebind_traits<std::shared_ptr<T>, named<TName, _>> {
+  using type = named<TName, std::shared_ptr<T>>;
+};
+template <class T, class U>
+struct rebind_traits<std::weak_ptr<T>, U> {
+  using type = std::weak_ptr<U>;
+};
+template <class T, class TName, class _>
+struct rebind_traits<std::weak_ptr<T>, named<TName, _>> {
+  using type = named<TName, std::weak_ptr<T>>;
+};
+template <class T, class U>
+struct rebind_traits<boost::shared_ptr<T>, U> {
+  using type = boost::shared_ptr<U>;
+};
+template <class T, class TName, class _>
+struct rebind_traits<boost::shared_ptr<T>, named<TName, _>> {
+  using type = named<TName, boost::shared_ptr<T>>;
+};
+template <class T, class U>
+using rebind_traits_t = typename rebind_traits<T, U>::type;
+}
+namespace core {
+template <class T, class... Ts>
+struct array_impl : _ {
+  using boost_di_inject__ = aux::type_list<Ts...>;
+  explicit array_impl(type_traits::remove_named_t<Ts>&&... args)
+      : array{static_cast<type_traits::remove_named_t<Ts>&&>(args)...} {}
+  T array[sizeof...(Ts)];
+};
+template <class T, class... Ts>
+struct array<T(), Ts...> : T {
+  using value_type = typename aux::identity<T>::type::value_type;
+  using array_t = array_impl<value_type, type_traits::rebind_traits_t<value_type, Ts>...>;
+  using boost_di_inject__ = aux::type_list<array_t&&>;
+  template <__BOOST_DI_REQUIRES(
+                aux::is_constructible<T, std::move_iterator<value_type*>, std::move_iterator<value_type*>>::value) = 0>
+  explicit array(array_t&& a)
+      : T(std::move_iterator<value_type*>(a.array), std::move_iterator<value_type*>(a.array + sizeof...(Ts))) {}
+};
+template <class T>
+struct array<T()> : T {
+  using boost_di_inject__ = aux::type_list<>;
+};
+template <class T>
+struct array<T> {};
+}
+namespace type_traits {
+template <class _, class T, class _1, class... Ts>
+struct ctor_traits__<core::array<_, Ts...>, T, _1, aux::false_type>
+    : type_traits::ctor_traits__<core::array<aux::remove_smart_ptr_t<aux::remove_qualifiers_t<T>>(), Ts...>> {};
+}
+namespace scopes {
+class deduce {
+ public:
+  template <class TExpected, class TGiven>
+  class scope {
+   public:
+    template <class T, class TConfig>
+    using is_referable =
+        typename TConfig::template scope_traits<T>::type::template scope<TExpected, TGiven>::template is_referable<T, TConfig>;
+    template <class T, class TName, class TProvider>
+    static decltype(typename TProvider::config::template scope_traits<T>::type::template scope<TExpected, TGiven>{}
+                        .template try_create<T, TName>(aux::declval<TProvider>()))
+    try_create(const TProvider&);
+    template <class T, class TName, class TProvider>
+    auto create(const TProvider& provider) {
+      using scope_traits = typename TProvider::config::template scope_traits<T>::type;
+      using scope = typename scope_traits::template scope<TExpected, TGiven>;
+      return scope{}.template create<T, TName>(provider);
+    }
+  };
+};
+}
+static constexpr __BOOST_DI_UNUSED scopes::deduce deduce{};
+namespace concepts {
+template <class T>
+struct abstract_type {
+  struct is_not_bound {
+    operator T*() const {
+      using constraint_not_satisfied = is_not_bound;
+      return constraint_not_satisfied{}.error();
+    }
+    // clang-format off
+    static inline T*
+ error(_ = "type is not bound, did you forget to add: 'di::bind<interface>.to<implementation>()'?");
+    // clang-format on
+  };
+  template <class TName>
+  struct named {
+    struct is_not_bound {
+      operator T*() const {
+        using constraint_not_satisfied = is_not_bound;
+        return constraint_not_satisfied{}.error();
+      }
+      // clang-format off
+      static inline T*
+   error(_ = "type is not bound, did you forget to add: 'di::bind<interface>.named(name).to<implementation>()'?");
+      // clang-format on
+    };
+  };
+};
+template <class TScope, class T>
+struct scoped {
+  template <class To>
+  struct is_not_convertible_to {
+    operator To() const {
+      using constraint_not_satisfied = is_not_convertible_to;
+      return constraint_not_satisfied{}.error();
+    }
+    // clang-format off
+    static inline To
+ error(_ = "scoped object is not convertible to the requested type, did you mistake the scope: 'di::bind<T>.in(scope)'?");
+    // clang-format on
+  };
+};
+template <class T>
+struct scoped<scopes::instance, T> {
+  template <class To>
+  struct is_not_convertible_to {
+    operator To() const {
+      using constraint_not_satisfied = is_not_convertible_to;
+      return constraint_not_satisfied{}.error();
+    }
+    // clang-format off
+    static inline To
+ error(_ = "instance is not convertible to the requested type, verify binding: 'di::bind<T>.to(value)'?");
+    // clang-format on
+  };
+};
+template <class T>
+struct type {
+  struct has_ambiguous_number_of_constructor_parameters {
+    template <int Given>
+    struct given {
+      template <int Expected>
+      struct expected {
+        operator T*() const {
+          using constraint_not_satisfied = expected;
+          return constraint_not_satisfied{}.error();
+        }
+        // clang-format off
+        static inline T*
+  error(_ = "verify BOOST_DI_INJECT_TRAITS or di::ctor_traits");
+        // clang-format on
+      };
+    };
+  };
+  struct has_to_many_constructor_parameters {
+    template <int TMax>
+    struct max {
+      operator T*() const {
+        using constraint_not_satisfied = max;
+        return constraint_not_satisfied{}.error();
+      }
+      // clang-format off
+      static inline T*
+   error(_ = "increase BOOST_DI_CFG_CTOR_LIMIT_SIZE value or reduce number of constructor parameters");
+      // clang-format on
+    };
+  };
+  struct is_not_exposed {
+    operator T() const {
+      using constraint_not_satisfied = is_not_exposed;
+      return constraint_not_satisfied{}.error();
+    }
+    // clang-format off
+      static inline T
+   error(_ = "type is not exposed, did you forget to add: 'di::injector<T>'?");
+    // clang-format on
+  };
+  template <class TName>
+  struct named {
+    struct is_not_exposed {
+      operator T() const {
+        using constraint_not_satisfied = is_not_exposed;
+        return constraint_not_satisfied{}.error();
+      }
+      // clang-format off
+      static inline T
+   error(_ = "type is not exposed, did you forget to add: 'di::injector<BOOST_DI_EXPOSE((named = name)T)>'?");
+      // clang-format on
+    };
+  };
+};
+template <class>
+struct ctor_size;
+template <class TInit, class... TCtor>
+struct ctor_size<aux::pair<TInit, aux::type_list<TCtor...>>> : aux::integral_constant<int, sizeof...(TCtor)> {};
+template <class... TCtor>
+struct ctor_size<aux::type_list<TCtor...>> : aux::integral_constant<int, sizeof...(TCtor)> {};
+template <class T>
+using ctor_size_t = ctor_size<typename type_traits::ctor<T, type_traits::ctor_impl_t<aux::is_constructible, T>>::type>;
+template <class TInitialization, class TName, class _, class TCtor, class T = aux::decay_t<_>>
+struct creatable_error_impl
+    : aux::conditional_t<
+          aux::is_polymorphic<T>::value,
+          aux::conditional_t<aux::is_same<TName, no_name>::value, typename abstract_type<T>::is_not_bound,
+                             typename abstract_type<T>::template named<TName>::is_not_bound>,
+          aux::conditional_t<ctor_size_t<T>::value == ctor_size<TCtor>::value,
+                             typename type<T>::has_to_many_constructor_parameters::template max<BOOST_DI_CFG_CTOR_LIMIT_SIZE>,
+                             typename type<T>::has_ambiguous_number_of_constructor_parameters::template given<
+                                 ctor_size<TCtor>::value>::template expected<ctor_size_t<T>::value>>> {};
+template <class TInit, class T, class... TArgs>
+struct creatable {
+  static constexpr auto value = aux::is_constructible<T, TArgs...>::value;
+};
+template <class T, class... TArgs>
+struct creatable<type_traits::uniform, T, TArgs...> {
+  static constexpr auto value = aux::is_braces_constructible<T, TArgs...>::value;
+};
+template <class TInitialization, class TName, class T, class... TArgs>
+T creatable_error() {
+  return creatable_error_impl<TInitialization, TName, T, aux::type_list<TArgs...>>{};
+}
+}
+namespace wrappers {
+template <class TScope, class T, class TObject = std::shared_ptr<T>>
+struct shared {
+  using scope = TScope;
+  template <class>
+  struct is_referable_impl : aux::true_type {};
+  template <class I>
+  struct is_referable_impl<std::shared_ptr<I>> : aux::is_same<I, T> {};
+  template <class I>
+  struct is_referable_impl<boost::shared_ptr<I>> : aux::false_type {};
+  template <class T_>
+  using is_referable = is_referable_impl<aux::remove_qualifiers_t<T_>>;
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator std::shared_ptr<I>() const noexcept {
+    return object;
+  }
+  inline operator std::shared_ptr<T>&() noexcept { return object; }
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator boost::shared_ptr<I>() const noexcept {
+    struct sp_holder {
+      std::shared_ptr<T> object;
+      void operator()(...) noexcept { object.reset(); }
+    };
+    return {object.get(), sp_holder{object}};
+  }
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator std::weak_ptr<I>() const noexcept {
+    return object;
+  }
+  inline operator T&() noexcept { return *object; }
+  inline operator const T&() const noexcept { return *object; }
+  TObject object;
+};
+template <class TScope, class T>
+struct shared<TScope, T&> {
+  using scope = TScope;
+  template <class>
+  struct is_referable : aux::true_type {};
+  explicit shared(T& object) : object(&object) {}
+  template <class I>
+  explicit shared(I);
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T, I>::value) = 0>
+  inline operator I() const noexcept {
+    return *object;
+  }
+  inline operator T&() const noexcept { return *object; }
+  T* object = nullptr;
+};
+}
+namespace wrappers {
+template <class TScope, class T>
+struct unique {
+  using scope = TScope;
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T, I>::value) = 0>
+  inline operator I() const noexcept {
+    return object;
+  }
+  inline operator T&&() noexcept { return static_cast<T&&>(object); }
+  T object;
+};
+template <class TScope, class T>
+struct unique<TScope, T*> {
+  using scope = TScope;
+#if defined(__MSVC__)
+  explicit unique(T* object) : object(object) {}
+#endif
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T, I>::value) = 0>
+  inline operator I() const noexcept {
+    struct scoped_ptr {
+      aux::owner<T*> ptr;
+      ~scoped_ptr() noexcept { delete ptr; }
+    };
+    return static_cast<T&&>(*scoped_ptr{object}.ptr);
+  }
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator aux::owner<I*>() const noexcept {
+    return object;
+  }
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, const I*>::value) = 0>
+  inline operator aux::owner<const I*>() const noexcept {
+    return object;
+  }
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator std::shared_ptr<I>() const noexcept {
+    return std::shared_ptr<I>{object};
+  }
+  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator boost::shared_ptr<I>() const noexcept {
+    return boost::shared_ptr<I>{object};
+  }
+  template <class I, class D, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
+  inline operator std::unique_ptr<I, D>() const noexcept {
+    return std::unique_ptr<I, D>{object};
+  }
+  T* object = nullptr;
+};
+}
+namespace scopes {
+class instance;
+namespace detail {
+template <class T, class TExpected, class TGiven>
+struct arg {
+  using type = T;
+  using expected = TExpected;
+  using given = TGiven;
+};
+template <class T>
+struct wrapper_traits {
+  using type = wrappers::unique<instance, T>;
+};
+template <class T>
+struct wrapper_traits<std::shared_ptr<T>> {
+  using type = wrappers::shared<instance, T>;
+};
+template <class T>
+using wrapper_traits_t = typename wrapper_traits<T>::type;
+template <class, class = int>
+struct has_result_type : ::boost::ext::di::v1_3_0::aux::false_type {};
+template <class T>
+struct has_result_type<T, ::boost::ext::di::v1_3_0::aux::valid_t<typename T::result_type>>
+    : ::boost::ext::di::v1_3_0::aux::true_type {};
+template <class TGiven, class TProvider, class... Ts>
+struct is_expr : aux::integral_constant<bool, aux::is_invocable<TGiven, typename TProvider::injector, Ts...>::value &&
+                                                  !has_result_type<TGiven>::value> {};
+}
+template <class T>
+struct wrapper {
+  inline operator T() noexcept { return static_cast<T&&>(object); }
+  T object;
+};
+class instance {
+ public:
+  template <class, class TGiven, class = int>
+  struct scope {
+    template <class...>
+    using is_referable = aux::false_type;
+    explicit scope(const TGiven& object) : object_{object} {}
+    template <class, class, class TProvider>
+    static wrappers::unique<instance, TGiven> try_create(const TProvider&);
+    template <class, class, class TProvider>
+    auto create(const TProvider&) const noexcept {
+      return wrappers::unique<instance, TGiven>{object_};
+    }
+    TGiven object_;
+  };
+  template <class TExpected, class TGiven>
+  struct scope<TExpected, std::shared_ptr<TGiven>> {
+    template <class T, class>
+    using is_referable = typename wrappers::shared<instance, TGiven>::template is_referable<aux::remove_qualifiers_t<T>>;
+    explicit scope(const std::shared_ptr<TGiven>& object) : object_{object} {}
+    template <class, class, class TProvider>
+    static wrappers::shared<instance, TGiven> try_create(const TProvider&);
+    template <class, class, class TProvider>
+    auto create(const TProvider&) const noexcept {
+      return wrappers::shared<instance, TGiven>{object_};
+    }
+    std::shared_ptr<TGiven> object_;
+  };
+  template <class TExpected, class TGiven>
+  struct scope<TExpected, std::initializer_list<TGiven>> {
+    template <class...>
+    using is_referable = aux::false_type;
+    scope(const std::initializer_list<TGiven>& object) : object_(object) {}
+    template <class, class, class TProvider>
+    static std::initializer_list<TGiven> try_create(const TProvider&);
+    template <class, class, class TProvider>
+    auto create(const TProvider&) const noexcept {
+      return wrappers::unique<instance, std::initializer_list<TGiven>>{object_};
+    }
+    std::initializer_list<TGiven> object_;
+  };
+  template <class TExpected, class TGiven>
+  struct scope<TExpected, TGiven&, __BOOST_DI_REQUIRES(!aux::is_callable<TGiven>::value)> {
+    template <class...>
+    using is_referable = aux::true_type;
+    explicit scope(TGiven& object) : object_{object} {}
+    template <class, class, class TProvider>
+    static wrappers::shared<instance, TGiven&> try_create(const TProvider&);
+    template <class, class, class TProvider>
+    auto create(const TProvider&) const noexcept {
+      return object_;
+    }
+    wrappers::shared<instance, TGiven&> object_;
+  };
+  template <class TExpected, class TGiven>
+  struct scope<TExpected, TGiven, __BOOST_DI_REQUIRES(aux::is_callable<TGiven>::value)> {
+    template <class...>
+    using is_referable =
+        aux::integral_constant<bool, !aux::is_callable<TExpected>::value || !detail::has_result_type<TExpected>::value>;
+    explicit scope(const TGiven& object) : object_(object) {}
+#if defined(__MSVC__)
+    template <class T, class, class TProvider>
+    static T try_create(const TProvider&) noexcept;
+#else
+    template <class, class, class TProvider,
+              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_callable<TGiven>::value &&
+                                  aux::is_callable<TExpected>::value) = 0>
+    static wrappers::unique<instance, TExpected> try_create(const TProvider&) noexcept;
+    template <class T, class, class TProvider,
+              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_invocable<TGiven>::value &&
+                                  !aux::is_callable<TExpected>::value) = 0>
+    static auto try_create(const TProvider&) noexcept
+        -> detail::wrapper_traits_t<decltype(aux::declval<typename aux::identity<TGiven, T>::type>()())>;
+    template <class, class, class TProvider, __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider>::value) = 0>
+    static detail::wrapper_traits_t<decltype(aux::declval<TGiven>()(aux::declval<typename TProvider::injector>()))> try_create(
+        const TProvider&) noexcept;
+    template <class T, class, class TProvider,
+              __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider, const detail::arg<T, TExpected, TGiven>&>::value) = 0>
+    static detail::wrapper_traits_t<decltype(aux::declval<TGiven>()(aux::declval<typename TProvider::injector>(),
+                                                                    aux::declval<detail::arg<T, TExpected, TGiven>>()))>
+    try_create(const TProvider&) noexcept;
+#endif
+    template <class, class, class TProvider,
+              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_callable<TGiven>::value &&
+                                  aux::is_callable<TExpected>::value) = 0>
+    auto create(const TProvider&) const noexcept {
+      return wrappers::unique<instance, TExpected>{object_};
+    }
+    template <class T, class, class TProvider,
+              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_invocable<TGiven>::value &&
+                                  !aux::is_callable<TExpected>::value) = 0>
+    auto create(const TProvider&) const {
+      using wrapper = detail::wrapper_traits_t<decltype(aux::declval<TGiven>()())>;
+      return wrapper{object_()};
+    }
+    template <class, class, class TProvider, __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider>::value) = 0>
+    auto create(const TProvider& provider) {
+      using wrapper = detail::wrapper_traits_t<decltype((object_)(provider.super()))>;
+      return wrapper{(object_)(provider.super())};
+    }
+    template <class T, class, class TProvider,
+              __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider, const detail::arg<T, TExpected, TGiven>&>::value) = 0>
+    auto create(const TProvider& provider) {
+      using wrapper = detail::wrapper_traits_t<decltype((object_)(provider.super(), detail::arg<T, TExpected, TGiven>{}))>;
+      return wrapper{(object_)(provider.super(), detail::arg<T, TExpected, TGiven>{})};
+    }
+    TGiven object_;
+  };
+  template <class _, class... Ts>
+  class scope<_, aux::type_list<Ts...>> {
+    template <class>
+    struct injector__;
+    template <class TName, class T>
+    struct injector__<named<TName, T>> {
+      T (*f)(const injector__*) = nullptr;
+      explicit injector__(const decltype(f)& ptr) : f(ptr) {}
+    };
+    struct injector : injector__<Ts>... {
+      void (*dtor)(injector*) = nullptr;
+      ~injector() noexcept { static_cast<injector*>(this)->dtor(this); }
+      template <class TName, class T>
+      T create(const named<TName, T>&, const aux::true_type&) const {
+        return static_cast<const injector__<named<TName, T>>*>(this)->f(static_cast<const injector__<named<TName, T>>*>(this));
+      }
+      template <class T>
+      T create(const named<no_name, T>&, const aux::false_type&) const {
+        return typename concepts::type<T>::is_not_exposed{};
+      }
+      template <class TName, class T>
+      T create(const named<TName, T>&, const aux::false_type&) const {
+        return typename concepts::type<T>::template named<TName>::is_not_exposed{};
+      }
+    };
+    template <class TInjector>
+    class injector_impl : injector__<Ts>... {
+      void (*dtor)(injector_impl*) = nullptr;
+      static void dtor_impl(injector_impl* object) { object->~injector_impl(); }
+      template <class, class>
+      struct create;
+      template <class TName, class T>
+      struct create<named<TName, T>, aux::true_type> {
+        static T impl(const injector__<named<TName, T>>* object) {
+          using type = aux::type<aux::conditional_t<aux::is_same<TName, no_name>::value, T, named<TName, T>>>;
+          return static_cast<const core::injector__<TInjector>&>(static_cast<const injector_impl*>(object)->injector_)
+              .create_successful_impl(type{});
+        }
+      };
+      template <class TName, class T>
+      struct create<named<TName, T>, aux::false_type> {
+        static T impl(const injector__<named<TName, T>>* object) {
+          using type = aux::type<aux::conditional_t<aux::is_same<TName, no_name>::value, T, named<TName, T>>>;
+          return static_cast<const core::injector__<TInjector>&>(static_cast<const injector_impl*>(object)->injector_)
+              .create_impl(type{});
+        }
+      };
+      template <class T>
+      struct is_creatable : aux::integral_constant<bool, core::injector__<TInjector>::template is_creatable<T>::value> {};
+      template <class TName, class T>
+      struct is_creatable<named<TName, T>>
+          : aux::integral_constant<bool, core::injector__<TInjector>::template is_creatable<T, TName>::value> {};
+
+     public:
+      explicit injector_impl(TInjector&& injector) noexcept
+          : injector__<Ts>(&injector_impl::template create<Ts, typename is_creatable<Ts>::type>::impl)...,
+            dtor(&injector_impl::dtor_impl),
+            injector_(static_cast<TInjector&&>(injector)) {}
+
+     private:
+      TInjector injector_;
+    };
+
+   public:
+    template <class...>
+    using is_referable = aux::true_type;
+    template <class TInjector, __BOOST_DI_REQUIRES(aux::is_a<core::injector_base, TInjector>::value) = 0>
+    explicit scope(TInjector&& i) noexcept : injector_((injector*)new injector_impl<TInjector>{static_cast<TInjector&&>(i)}) {}
+    scope(scope&& other) noexcept : injector_(other.injector_) { other.injector_ = nullptr; }
+    ~scope() noexcept { delete injector_; }
+    template <class T, class TName, class TProvider>
+    static aux::conditional_t<aux::is_base_of<injector__<named<TName, T>>, injector>::value, T, void> try_create(
+        const TProvider&);
+    template <class T, class TName, class TProvider>
+    auto create(const TProvider&) {
+      return wrapper<T>{injector_->create(named<TName, T>{}, aux::is_base_of<injector__<named<TName, T>>, injector>{})};
+    }
+
+   private:
+    injector* injector_;
+  };
+};
+}
+namespace core {
+template <class, int, class T>
+struct ctor_arg {
+  explicit ctor_arg(T&& t) : value(static_cast<T&&>(t)) {}
+  constexpr operator T() const { return value; }
+
+ private:
+  T value;
+};
+template <class, class>
+struct dependency_concept {};
+template <class T, class TDependency>
+struct dependency_impl : aux::pair<T, TDependency> {};
+template <class T>
+struct make_dependency_concept {
+  using type = dependency_concept<T, no_name>;
+};
+template <class TName, class T>
+struct make_dependency_concept<named<TName, T>> {
+  using type = dependency_concept<T, TName>;
+};
+template <class... Ts, class TName, class TDependency>
+struct dependency_impl<dependency_concept<concepts::any_of<Ts...>, TName>, TDependency>
+    : aux::pair<dependency_concept<Ts, TName>, TDependency>... {};
+template <class... Ts, class TDependency>
+struct dependency_impl<dependency_concept<aux::type_list<Ts...>, no_name>, TDependency>
+    : aux::pair<typename make_dependency_concept<Ts>::type, TDependency>... {};
+struct override {};
+template <class TScope, class TExpected, class TGiven, class TName, class TPriority, class TCtor>
+class dependency : dependency_base,
+                   public TScope::template scope<TExpected, TGiven>,
+                   public dependency_impl<dependency_concept<TExpected, TName>,
+                                          dependency<TScope, TExpected, TGiven, TName, TPriority, TCtor>>,
+                   protected TCtor {
+  template <class, class, class, class, class, class>
+  friend class dependency;
+  using scope_t = typename TScope::template scope<TExpected, TGiven>;
+  template <class T>
+  using externable = aux::integral_constant<bool, aux::always<T>::value && aux::is_same<TScope, scopes::deduce>::value &&
+                                                      aux::is_same<TExpected, TGiven>::value>;
+  template <class T>
+  struct ref_traits {
+    using type = T;
+  };
+  template <int N>
+  struct ref_traits<const char (&)[N]> {
+    using type = TExpected;
+  };
+  template <class R, class... Ts>
+  struct ref_traits<R (&)(Ts...)> {
+    using type = TExpected;
+  };
+  template <class T>
+  struct ref_traits<std::shared_ptr<T>&> {
+    using type = std::shared_ptr<T>;
+  };
+  template <class T, class>
+  struct deduce_traits {
+    using type = T;
+  };
+  template <class T>
+  struct deduce_traits<deduced, T> {
+    using type = aux::decay_t<T>;
+  };
+  template <class T, class U>
+  using deduce_traits_t = typename deduce_traits<T, U>::type;
+  template <class TParent, int N, class T>
+  using ctor_arg_traits = ctor_arg<TParent, N, T>;
+
+ public:
+  using scope = TScope;
+  using expected = TExpected;
+  using given = TGiven;
+  using name = TName;
+  using priority = TPriority;
+  using ctor = TCtor;
+  dependency() noexcept {}
+  template <class T>
+  explicit dependency(T&& object) noexcept : scope_t(static_cast<T&&>(object)) {}
+  explicit dependency(TCtor&& ctor) noexcept : TCtor{static_cast<TCtor&&>(ctor)} {}
+  template <class T, __BOOST_DI_REQUIRES(aux::is_same<TName, no_name>::value && !aux::is_same<T, no_name>::value) = 0>
+  auto named() noexcept {
+    return dependency<TScope, TExpected, TGiven, T, TPriority, TCtor>{static_cast<dependency&&>(*this)};
+  }
+  template <class T, __BOOST_DI_REQUIRES(aux::is_same<TName, no_name>::value && !aux::is_same<T, no_name>::value) = 0>
+  auto named(const T&) noexcept {
+    return dependency<TScope, TExpected, TGiven, T, TPriority, TCtor>{static_cast<dependency&&>(*this)};
+  }
+  template <class T, __BOOST_DI_REQUIRES_MSG(concepts::scopable<T>) = 0>
+  auto in(const T&) noexcept {
+    return dependency<T, TExpected, TGiven, TName, TPriority, TCtor>{};
+  }
+  template <class T, __BOOST_DI_REQUIRES(!aux::is_array<TExpected, T>::value) = 0,
+            __BOOST_DI_REQUIRES_MSG(concepts::boundable<TExpected, T>) = 0>
+  auto to() noexcept {
+    return dependency<TScope, TExpected, T, TName, TPriority, TCtor>{};
+  }
+  template <class... Ts, __BOOST_DI_REQUIRES(aux::is_array<TExpected, Ts...>::value) = 0>
+  auto to() noexcept {
+    using type = aux::remove_pointer_t<aux::remove_extent_t<TExpected>>;
+    return dependency<TScope, array<type>, array<type, Ts...>, TName, TPriority, TCtor>{};
+  }
+  template <class T, __BOOST_DI_REQUIRES_MSG(concepts::boundable<TExpected, T>) = 0>
+  auto to(std::initializer_list<T> il) noexcept {
+    using type = aux::remove_pointer_t<aux::remove_extent_t<TExpected>>;
+    using dependency = dependency<scopes::instance, array<type>, std::initializer_list<T>, TName, TPriority, TCtor>;
+    return dependency{il};
+  }
+  template <class T, __BOOST_DI_REQUIRES(externable<T>::value && !aux::is_callable<T>::value) = 0,
+            __BOOST_DI_REQUIRES_MSG(concepts::boundable<deduce_traits_t<TExpected, T>, aux::decay_t<T>, aux::valid<>>) = 0>
+  auto to(T&& object) noexcept {
+    using dependency =
+        dependency<scopes::instance, deduce_traits_t<TExpected, T>, typename ref_traits<T>::type, TName, TPriority, TCtor>;
+    return dependency{static_cast<T&&>(object)};
+  }
+  template <class T, __BOOST_DI_REQUIRES(externable<T>::value&& aux::is_callable<T>::value) = 0>
+  auto to(T&& object) noexcept {
+    using dependency =
+        dependency<scopes::instance, deduce_traits_t<TExpected, T>, typename ref_traits<T>::type, TName, TPriority, TCtor>;
+    return dependency{static_cast<T&&>(object)};
+  }
+  template <class TConcept, class T, __BOOST_DI_REQUIRES(externable<T>::value && !aux::is_callable<T>::value) = 0,
+            __BOOST_DI_REQUIRES_MSG(concepts::boundable<deduce_traits_t<TExpected, T>, aux::decay_t<T>, aux::valid<>>) = 0>
+  auto to(T&& object) noexcept {
+    using dependency = dependency<scopes::instance, deduce_traits_t<concepts::any_of<TExpected, TConcept>, T>,
+                                  typename ref_traits<T>::type, TName, TPriority, TCtor>;
+    return dependency{static_cast<T&&>(object)};
+  }
+  template <class TConcept, class T, __BOOST_DI_REQUIRES(externable<T>::value&& aux::is_callable<T>::value) = 0>
+  auto to(T&& object) noexcept {
+    using dependency = dependency<scopes::instance, deduce_traits_t<concepts::any_of<TExpected, TConcept>, T>,
+                                  typename ref_traits<T>::type, TName, TPriority, TCtor>;
+    return dependency{static_cast<T&&>(object)};
+  }
+  template <class T, class... Ts, __BOOST_DI_REQUIRES(!aux::is_array<TExpected, T>::value) = 0>
+  auto to(Ts&&... args) noexcept {
+    return to_impl<T>(aux::make_index_sequence<sizeof...(Ts)>{}, static_cast<Ts&&>(args)...);
+  }
+  template <template <class...> class T>
+  auto to() noexcept {
+    return dependency<TScope, TExpected, aux::identity<T<>>, TName, TPriority, TCtor>{};
+  }
+  template <class...>
+  dependency& to(...) const noexcept;
+  auto operator[](const override&) noexcept {
+    return dependency<TScope, TExpected, TGiven, TName, override>{static_cast<dependency&&>(*this)};
+  }
+#if defined(__cpp_variable_templates)
+  dependency& operator()() noexcept { return *this; }
+#endif
+  template <class... Ts, __BOOST_DI_REQUIRES(sizeof...(Ts) && !aux::is_array<TExpected, Ts...>::value) = 0>
+  auto operator()(Ts&&... args) noexcept {
+    return to_impl<TExpected>(aux::make_index_sequence<sizeof...(Ts)>{}, static_cast<Ts&&>(args)...);
+  }
+
+ protected:
+  using scope_t::create;
+  using scope_t::is_referable;
+  using scope_t::try_create;
+  template <class, class>
+  static void try_create(...);
+
+ private:
+  template <class T, int... Ns, class... Ts>
+  auto to_impl(aux::index_sequence<Ns...>, Ts&&... args) noexcept {
+    using ctor_t = core::pool_t<ctor_arg_traits<T, Ns, Ts>...>;
+    using dependency = dependency<TScope, TExpected, T, TName, TPriority, ctor_t>;
+    return dependency{ctor_t{ctor_arg_traits<T, Ns, Ts>(static_cast<Ts&&>(args))...}};
+  }
+};
+}
+namespace concepts {
+struct call_operator_with_one_argument {};
+template <class>
+struct policy {
+  template <class>
+  struct requires_ : aux::false_type {};
+};
+struct arg_wrapper {
+  using type = _;
+  using expected = _;
+  using given = _;
+  using name = no_name;
+  using arity = aux::integral_constant<int, 0>;
+  using scope = scopes::deduce;
+  using is_root = aux::false_type;
+  template <class, class, class>
+  struct resolve;
+};
+aux::false_type callable_impl(...);
+template <class T, class TArg>
+auto callable_impl(const T&& t, TArg&& arg) -> aux::is_valid_expr<decltype(t(arg))>;
+template <class...>
+struct is_callable_impl;
+template <class T, class... Ts>
+struct is_callable_impl<T, Ts...> {
+  using callable_with_arg = decltype(callable_impl(aux::declval<T>(), arg_wrapper{}));
+  using type = aux::conditional_t<callable_with_arg::value, typename is_callable_impl<Ts...>::type,
+                                  typename policy<T>::template requires_<call_operator_with_one_argument>>;
+};
+template <>
+struct is_callable_impl<> : aux::true_type {};
+template <class... Ts>
+struct is_callable : is_callable_impl<Ts...> {};
+template <class... Ts>
+struct is_callable<core::pool<aux::type_list<Ts...>>> : is_callable_impl<Ts...> {};
+template <>
+struct is_callable<void> {
+  using type = policy<void>::requires_<call_operator_with_one_argument>;
+};
+template <class... Ts>
+using callable = typename is_callable<Ts...>::type;
+}
+namespace providers {
+class stack_over_heap {
+ public:
+  template <class TInitialization, class T, class... TArgs>
+  struct is_creatable {
+    static constexpr auto value = concepts::creatable<TInitialization, T, TArgs...>::value;
+  };
+  template <class T, class... TArgs>
+  auto get(const type_traits::direct&, const type_traits::heap&, TArgs&&... args) const {
+    return new T(static_cast<TArgs&&>(args)...);
+  }
+  template <class T, class... TArgs>
+  auto get(const type_traits::uniform&, const type_traits::heap&, TArgs&&... args) const {
+    return new T{static_cast<TArgs&&>(args)...};
+  }
+  template <class T, class... TArgs>
+  auto get(const type_traits::direct&, const type_traits::stack&, TArgs&&... args) const {
+    return T(static_cast<TArgs&&>(args)...);
+  }
+  template <class T, class... TArgs>
+  auto get(const type_traits::uniform&, const type_traits::stack&, TArgs&&... args) const {
+    return T{static_cast<TArgs&&>(args)...};
+  }
+};
+}
+namespace scopes {
+class singleton {
+  template <class T, class = decltype(aux::has_shared_ptr__(aux::declval<T>()))>
+  class scope_impl {
+   public:
+    template <class T_, class>
+    using is_referable = typename wrappers::shared<singleton, T&>::template is_referable<T_>;
+    template <class, class, class TProvider>
+    static decltype(wrappers::shared<singleton, T&>{aux::declval<TProvider>().get(type_traits::stack{})}) try_create(
+        const TProvider&);
+    template <class, class, class TProvider>
+    auto create(const TProvider& provider) {
+      return create_impl(provider);
+    }
+
+   private:
+    template <class TProvider>
+    wrappers::shared<singleton, T&> create_impl(const TProvider& provider) {
+      static auto object(provider.get(type_traits::stack{}));
+      return wrappers::shared<singleton, T&>(object);
+    }
+  };
+  template <class T>
+  class scope_impl<T, aux::true_type> {
+   public:
+    template <class T_, class>
+    using is_referable = typename wrappers::shared<singleton, T>::template is_referable<T_>;
+    template <class, class, class TProvider, class T_ = aux::decay_t<decltype(aux::declval<TProvider>().get())>>
+    static decltype(wrappers::shared<singleton, T_>{std::shared_ptr<T_>{std::shared_ptr<T_>{aux::declval<TProvider>().get()}}})
+    try_create(const TProvider&);
+    template <class, class, class TProvider>
+    auto create(const TProvider& provider) {
+      return create_impl<aux::decay_t<decltype(provider.get())>>(provider);
+    }
+
+   private:
+    template <class T_, class TProvider>
+    auto create_impl(const TProvider& provider) {
+      static std::shared_ptr<T_> object{provider.get()};
+      return wrappers::shared<singleton, T_, std::shared_ptr<T_>&>{object};
+    }
+  };
+
+ public:
+  template <class, class T>
+  using scope = scope_impl<T>;
+};
+}
+static constexpr __BOOST_DI_UNUSED scopes::singleton singleton{};
+namespace scopes {
+class unique {
+ public:
+  template <class, class>
+  class scope {
+   public:
+    template <class...>
+    using is_referable = aux::false_type;
+    template <class T, class, class TProvider>
+    static decltype(wrappers::unique<unique, decltype(aux::declval<TProvider>().get(
+                                                 typename TProvider::config::template memory_traits<T>::type{}))>{
+        aux::declval<TProvider>().get(typename TProvider::config::template memory_traits<T>::type{})})
+    try_create(const TProvider&);
+    template <class T, class, class TProvider>
+    auto create(const TProvider& provider) const {
+      using memory = typename TProvider::config::template memory_traits<T>::type;
+      using wrapper = wrappers::unique<unique, decltype(provider.get(memory{}))>;
+      return wrapper{provider.get(memory{})};
+    }
+  };
+};
+}
+static constexpr __BOOST_DI_UNUSED scopes::unique unique{};
+namespace type_traits {
+template <class T>
+struct scope_traits {
+  using type = scopes::unique;
+};
+template <class T>
+struct scope_traits<T&> {
+  using type = scopes::singleton;
+};
+template <class T>
+struct scope_traits<std::shared_ptr<T>> {
+  using type = scopes::singleton;
+};
+template <class T>
+struct scope_traits<boost::shared_ptr<T>> {
+  using type = scopes::singleton;
+};
+template <class T>
+struct scope_traits<std::weak_ptr<T>> {
+  using type = scopes::singleton;
+};
+}
+#if !defined(BOOST_DI_CFG)
+#define BOOST_DI_CFG ::boost::ext::di::v1_3_0::config
+#endif
+template <class... TPolicies, __BOOST_DI_REQUIRES_MSG(concepts::callable<TPolicies...>) = 0>
+inline auto make_policies(TPolicies... args) noexcept {
+  return core::pool_t<TPolicies...>(static_cast<TPolicies&&>(args)...);
+}
+struct config {
+  template <class T>
+  auto provider(T*) noexcept {
+    return providers::stack_over_heap{};
+  }
+  template <class T>
+  auto policies(T*) noexcept {
+    return make_policies();
+  }
+  template <class T>
+  using scope_traits = type_traits::scope_traits<T>;
+  template <class T>
+  using memory_traits = type_traits::memory_traits<T>;
+};
+namespace detail {
+template <class...>
+struct bind;
+template <class TScope>
+struct bind<int, TScope> {
+  using type = core::dependency<TScope>;
+};
+template <class TScope, class T>
+struct bind<int, TScope, T> {
+  using type = core::dependency<TScope, T>;
+};
+template <class TScope, class... Ts>
+struct bind<int, TScope, Ts...> {
+  using type = core::dependency<TScope, concepts::any_of<Ts...>>;
+};
+}
+template <class... Ts>
+#if defined(__cpp_variable_templates)
+typename
+#else
+struct bind :
+#endif
+    detail::bind<__BOOST_DI_REQUIRES_MSG(concepts::boundable<concepts::any_of<Ts...>>), scopes::deduce, Ts...>::type
+#if defined(__cpp_variable_templates)
+        bind
+#endif
+{};
+static constexpr __BOOST_DI_UNUSED core::override override{};
+namespace concepts {
+struct get {};
+struct is_creatable {};
+template <class>
+struct provider {
+  template <class...>
+  struct requires_ : aux::false_type {};
+};
+template <class T>
+typename provider<T>::template requires_<get, is_creatable> providable_impl(...);
+template <class T>
+auto providable_impl(T&& t)
+    -> aux::is_valid_expr<decltype(t.template get<_>(type_traits::direct{}, type_traits::heap{})),
+                          decltype(t.template get<_>(type_traits::direct{}, type_traits::heap{}, int{})),
+                          decltype(t.template get<_>(type_traits::uniform{}, type_traits::stack{})),
+                          decltype(t.template get<_>(type_traits::uniform{}, type_traits::stack{}, int{})),
+                          decltype(T::template is_creatable<type_traits::direct, type_traits::heap, _>::value),
+                          decltype(T::template is_creatable<type_traits::uniform, type_traits::stack, _, int>::value)>;
+template <class T>
+struct providable__ {
+  using type = decltype(providable_impl<T>(aux::declval<T>()));
+};
+template <class T>
+using providable = typename providable__<T>::type;
+}
+namespace concepts {
+template <class>
+struct policies {};
+struct providable_type {};
+struct callable_type {};
+template <class>
+struct config {
+  template <class...>
+  struct requires_ : aux::false_type {};
+};
+template <class TConfig>
+struct injector {
+  using config = TConfig;
+  using deps = aux::type_list<>;
+  template <class T>
+  T create() const;
+};
+aux::false_type configurable_impl(...);
+template <class T>
+auto configurable_impl(T&&) -> aux::is_valid_expr<decltype(aux::declval<T>().provider(aux::declval<injector<T>*>())),
+                                                  decltype(aux::declval<T>().policies(aux::declval<injector<T>*>()))>;
+template <class T1, class T2>
+struct get_configurable_error : aux::type_list<T1, T2> {};
+template <class T>
+struct get_configurable_error<aux::true_type, T> {
+  using type = T;
+};
+template <class T>
+struct get_configurable_error<T, aux::true_type> {
+  using type = T;
+};
+template <>
+struct get_configurable_error<aux::true_type, aux::true_type> : aux::true_type {};
+template <class T>
+auto is_configurable(const aux::true_type&) {
+  return typename get_configurable_error<decltype(providable<decltype(aux::declval<T>().provider(aux::declval<injector<T>*>()))>()),
+                                         decltype(callable<decltype(aux::declval<T>().policies(aux::declval<injector<T>*>()))>())>::type{};
+}
+template <class T>
+auto is_configurable(const aux::false_type&) {
+  return typename config<T>::template requires_<provider<providable_type(...)>, policies<callable_type(...)>>{};
+}
+template <class T>
+struct configurable__ {
+  using type = decltype(is_configurable<T>(decltype(configurable_impl(aux::declval<T>())){}));
+};
+template <class T>
+using configurable = typename configurable__<T>::type;
+}
+namespace core {
+struct binder {
+  template <class TDefault, class>
+  static TDefault resolve_impl(...) noexcept {
+    return {};
+  }
+  template <class, class TConcept, class TDependency>
+  static decltype(auto) resolve_impl(aux::pair<TConcept, TDependency>* dep) noexcept {
+    return static_cast<TDependency&>(*dep);
+  }
+  template <class, class TConcept, class TScope, class TExpected, class TGiven, class TName, class TCtor,
+            template <class, class, class, class, class, class> class TDependency>
+  static decltype(auto) resolve_impl(
+      aux::pair<TConcept, TDependency<TScope, TExpected, TGiven, TName, override, TCtor>>* dep) noexcept {
+    return static_cast<TDependency<TScope, TExpected, TGiven, TName, override, TCtor>&>(*dep);
+  }
+  template <class TDefault, class>
+  static TDefault resolve_impl__(...);
+  template <class, class TConcept, class TDependency>
+  static TDependency resolve_impl__(aux::pair<TConcept, TDependency>*);
+  template <class, class TConcept, class TScope, class TExpected, class TGiven, class TName, class TCtor,
+            template <class, class, class, class, class, class> class TDependency>
+  static dependency<TScope, TExpected, TGiven, TName, override, TCtor> resolve_impl__(
+      aux::pair<TConcept, TDependency<TScope, TExpected, TGiven, TName, override, TCtor>>*);
+  template <class TDeps, class T, class TName, class TDefault>
+  struct resolve__ {
+    using type = decltype(resolve_impl__<TDefault, dependency_concept<aux::decay_t<T>, TName>>(aux::declval<TDeps*>()));
+  };
+#if (defined(__CLANG__) && __CLANG__ >= 3'9)  //
+  template <class TDeps, class T>
+  static T& resolve_(TDeps* deps, const aux::type<T&>&) noexcept {
+    return static_cast<T&>(*deps);
+  }
+  template <class TDeps, class T>
+  static T resolve_(TDeps*, const aux::type<T>&) noexcept {
+    return {};
+  }
+#endif
+  template <class, class T>
+  struct resolve_template_impl {
+    using type = T;
+  };
+  template <class TDeps, template <class...> class T, class... Ts>
+  struct resolve_template_impl<TDeps, aux::identity<T<Ts...>>> {
+    using type = T<typename resolve_template_impl<
+        TDeps, aux::remove_qualifiers_t<typename resolve__<
+                   TDeps, Ts, no_name, dependency<scopes::deduce, aux::decay_t<Ts>>>::type::given>>::type...>;
+  };
+  template <class T, class TName = no_name, class TDefault = dependency<scopes::deduce, aux::decay_t<T>>, class TDeps>
+  static decltype(auto) resolve(TDeps* deps) noexcept {
+    using dependency = dependency_concept<aux::decay_t<T>, TName>;
+#if (defined(__CLANG__) && __CLANG__ >= 3'9)  //
+    return resolve_(deps, aux::type<decltype(resolve_impl<TDefault, dependency>(aux::declval<TDeps*>()))>{});
+#else
+    return resolve_impl<TDefault, dependency>(deps);
+#endif
+  }
+  template <class TDeps, class T, class TName = no_name, class TDefault = dependency<scopes::deduce, aux::decay_t<T>>>
+  using resolve_t = typename resolve__<TDeps, T, TName, TDefault>::type;
+  template <class TDeps, class T>
+  using resolve_template_t = typename resolve_template_impl<TDeps, aux::remove_qualifiers_t<T>>::type;
+};
+}
+namespace core {
+template <class T, class TInjector, class TError = aux::false_type>
+struct is_referable__ {
+  static constexpr auto value =
+      dependency__<binder::resolve_t<TInjector, T>>::template is_referable<T, typename TInjector::config>::value;
+};
+template <class T, class TInjector>
+struct is_referable__<T, TInjector, aux::true_type> {
+  static constexpr auto value = true;
+};
+template <class T, class TInjector, class TError>
+struct is_creatable__ {
+  static constexpr auto value = injector__<TInjector>::template is_creatable<T>::value;
+};
+template <class T, class TInjector>
+struct is_creatable__<T, TInjector, aux::false_type> {
+  static constexpr auto value = true;
+};
+template <class, class>
+struct is_copy_ctor__ : aux::false_type {};
+template <class T>
+struct is_copy_ctor__<T, T> : aux::true_type {};
+template <class T>
+struct is_copy_ctor__<T, const T> : aux::true_type {};
+template <class TParent, class TInjector, class TError = aux::false_type>
+struct any_type {
+  template <class T, class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
+  }
+  const TInjector& injector_;
+};
+template <class TParent, class TInjector, class TError = aux::false_type, class TRefError = aux::false_type>
+struct any_type_ref {
+  template <class T, class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector, TRefError>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<T&&, TInjector, TError>::value)>
+  operator T&&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector, TRefError>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<T&, TInjector, TError>::value)>
+  operator T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector, TRefError>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<const T&, TInjector, TError>::value)>
+  operator const T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<const T&>{});
+  }
+  const TInjector& injector_;
+};
+template <class TParent, class TInjector, class TError = aux::false_type>
+struct any_type_1st {
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
+  }
+  const TInjector& injector_;
+};
+template <class TParent, class TInjector, class TError = aux::false_type, class TRefError = aux::false_type>
+struct any_type_1st_ref {
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector, TRefError>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<T&&, TInjector, TError>::value)>
+  operator T&&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector, TRefError>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<T&, TInjector, TError>::value)>
+  operator T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector, TRefError>::value),
+            class = __BOOST_DI_REQUIRES(is_creatable__<const T&, TInjector, TError>::value)>
+  operator const T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<const T&>{});
+  }
+  const TInjector& injector_;
+};
+namespace successful {
+template <class TParent, class TInjector>
+struct any_type {
+  template <class T>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
+  }
+  const TInjector& injector_;
+};
+template <class TParent, class TInjector>
+struct any_type_ref {
+  template <class T>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector>::value)>
+  operator T&&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector>::value)>
+  operator T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector>::value)>
+  operator const T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<const T&>{});
+  }
+  const TInjector& injector_;
+};
+template <class TParent, class TInjector>
+struct any_type_1st {
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
+  }
+  const TInjector& injector_;
+};
+template <class TParent, class TInjector>
+struct any_type_1st_ref {
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator T() {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector>::value)>
+  operator T&&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector>::value)>
+  operator T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&>{});
+  }
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
+            class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector>::value)>
+  operator const T&() const {
+    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<const T&>{});
+  }
+  const TInjector& injector_;
+};
+}
+template <class>
+struct any_type_fwd {
+  template <class T>
+  operator T();
+
+ private:
+  template <class T>
+  operator const T&() const;
+};
+template <class>
+struct any_type_ref_fwd {
+  template <class T>
+  operator T();
+  template <class T>
+  operator T&() const;
+  template <class T>
+  operator T&&() const;
+  template <class T>
+  operator const T&() const;
+};
+template <class TParent>
+struct any_type_1st_fwd {
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator T();
+
+ private:
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator const T&() const;
+};
+template <class TParent>
+struct any_type_1st_ref_fwd {
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator T();
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator T&() const;
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator T&&() const;
+  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
+  operator const T&() const;
+};
+}
+namespace core {
+template <class...>
+struct arg_wrapper;
+template <class T, class TName, class TIsRoot, template <class...> class TList, class... TCtor, class TDependency, class TDeps>
+struct arg_wrapper<T, TName, TIsRoot, TList<TCtor...>, TDependency, TDeps> {
+  using type __BOOST_DI_UNUSED = T;
+  using expected __BOOST_DI_UNUSED = typename TDependency::expected;
+  using given __BOOST_DI_UNUSED = typename TDependency::given;
+  using name __BOOST_DI_UNUSED = TName;
+  using arity __BOOST_DI_UNUSED = aux::integral_constant<int, sizeof...(TCtor)>;
+  using scope __BOOST_DI_UNUSED = typename TDependency::scope;
+  using is_root __BOOST_DI_UNUSED = TIsRoot;
+  template <class T_, class TName_, class TDefault_>
+  using resolve = decltype(core::binder::resolve<T_, TName_, TDefault_>(aux::declval<TDeps*>()));
+};
+template <class T>
+struct allow_void : T {};
+template <>
+struct allow_void<void> : aux::true_type {};
+class policy {
+  template <class TArg, class TPolicy, class TPolicies,
+            __BOOST_DI_REQUIRES(!aux::is_base_of<_, aux::remove_reference_t<typename TArg::type>>::value) = 0>
+  static void call_impl(const TPolicies& policies) noexcept {
+    static_cast<const TPolicy&>(policies)(TArg{});
+  }
+  template <class TArg, class, class TPolicies,
+            __BOOST_DI_REQUIRES(aux::is_base_of<_, aux::remove_reference_t<typename TArg::type>>::value) = 0>
+  static void call_impl(const TPolicies&) noexcept {}
+  template <class TArg, class TPolicy>
+  struct try_call_impl
+      : aux::conditional_t<aux::is_base_of<_, aux::remove_reference_t<typename TArg::type>>::value, aux::true_type,
+                           allow_void<decltype((aux::declval<TPolicy>())(aux::declval<TArg>()))>> {};
+
+ public:
+  template <class, class>
+  struct try_call;
+  template <class TArg, class... TPolicies>
+  struct try_call<TArg, pool_t<TPolicies...>> : aux::is_same<aux::bool_list<aux::always<TPolicies>::value...>,
+                                                             aux::bool_list<try_call_impl<TArg, TPolicies>::value...>> {};
+  template <class TArg, class... TPolicies>
+  static void call(__BOOST_DI_UNUSED const pool_t<TPolicies...>& policies) noexcept {
+    (void)aux::swallow{0, (call_impl<TArg, TPolicies>(policies), 0)...};
+  }
+};
+}
+namespace core {
+#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL >= 2)
+template <class T>
+struct creating {
+  creating() { type(); }
+  static inline T type(_ = "creating...");
+};
+#endif
+template <class, class, class>
+struct try_provider;
+template <class T, class TInjector, class TProvider, class TInitialization, template <class...> class TList, class... TCtor>
+struct try_provider<aux::pair<T, aux::pair<TInitialization, TList<TCtor...>>>, TInjector, TProvider> {
+  using injector = TInjector;
+  using config = typename TInjector::config;
+  template <class>
+  struct is_creatable {
+    static constexpr auto value =
+        TProvider::template is_creatable<TInitialization, T,
+                                         typename injector__<TInjector>::template try_create<TCtor>::type...>::value;
+  };
+  template <class TMemory = type_traits::heap>
+  auto get(const TMemory& = {}) const
+      -> aux::enable_if_t<is_creatable<TMemory>::value,
+                          aux::conditional_t<aux::is_same<TMemory, type_traits::stack>::value, T, aux::remove_reference_t<T>*>>;
+};
+template <class, class, class>
+struct provider;
+template <class T, class TName, class TInjector, class TInitialization, template <class...> class TList, class... TCtor>
+struct provider<aux::pair<T, aux::pair<TInitialization, TList<TCtor...>>>, TName, TInjector> {
+  using injector = TInjector;
+  using config = typename TInjector::config;
+  template <class, class... TArgs>
+  struct is_creatable {
+    using type = decltype(aux::declval<injector__<TInjector>>().cfg().provider(aux::declval<TInjector*>()));
+    static constexpr auto value = type::template is_creatable<TInitialization, T, TArgs...>::value;
+  };
+  template <class TMemory = type_traits::heap>
+  auto get(const TMemory& memory = {}) const {
+    return get_impl(memory, ((const injector__<TInjector>*)injector_)->create_impl(aux::type<TCtor>{})...);
+  }
+  template <class TMemory, class... TArgs, __BOOST_DI_REQUIRES(is_creatable<TMemory, TArgs...>::value) = 0>
+  auto get_impl(const TMemory& memory, TArgs&&... args) const {
+#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL >= 2)
+    (void)aux::conditional_t<injector__<TInjector>::template is_creatable<T>::value, _, creating<T>>{};
+#endif
+    return cfg().provider(injector_).template get<T>(TInitialization{}, memory, static_cast<TArgs&&>(args)...);
+  }
+  template <class TMemory, class... TArgs, __BOOST_DI_REQUIRES(!is_creatable<TMemory, TArgs...>::value) = 0>
+  auto get_impl(const TMemory&, TArgs&&...) const {
+#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL > 0)
+    return concepts::creatable_error<TInitialization, TName, T*, TArgs...>();
+#else
+    return nullptr;
+#endif
+  }
+  auto& super() const { return *injector_; }
+  auto& cfg() const { return ((injector__<TInjector>*)injector_)->cfg(); }
+  const TInjector* injector_;
+};
+namespace successful {
+template <class, class>
+struct provider;
+template <class T, class TInjector, class TInitialization, template <class...> class TList, class... TCtor>
+struct provider<aux::pair<T, aux::pair<TInitialization, TList<TCtor...>>>, TInjector> {
+  using injector = TInjector;
+  using config = typename TInjector::config;
+  template <class TMemory = type_traits::heap>
+  auto get(const TMemory& memory = {}) const {
+    return cfg().provider(injector_).template get<T>(
+        TInitialization{}, memory, ((const injector__<TInjector>*)injector_)->create_successful_impl(aux::type<TCtor>{})...);
+  }
+  auto& super() const { return *injector_; }
+  auto& cfg() const { return ((injector__<TInjector>*)injector_)->cfg(); }
+  const TInjector* injector_;
+};
+}
+}
+namespace core {
+namespace successful {
+template <class T, class TWrapper>
+struct wrapper {
+  inline operator T() noexcept { return wrapper_; }
+  TWrapper wrapper_;
+};
+}
+template <class T, class TWrapper, class = int>
+struct wrapper_impl {
+  inline operator T() noexcept { return wrapper_; }
+  TWrapper wrapper_;
+};
+template <class T, template <class...> class TWrapper, class TScope, class T_, class... Ts>
+struct wrapper_impl<T, TWrapper<TScope, T_, Ts...>,
+                    __BOOST_DI_REQUIRES(!aux::is_convertible<TWrapper<TScope, T_, Ts...>, T>::value)> {
+  inline operator T() noexcept {
+    return typename concepts::scoped<TScope, aux::remove_qualifiers_t<T_>>::template is_not_convertible_to<T>{};
+  }
+  TWrapper<TScope, T_, Ts...> wrapper_;
+};
+template <class T, class TWrapper>
+using wrapper = wrapper_impl<T, TWrapper>;
+}
+namespace core {
+struct from_injector {};
+struct from_deps {};
+struct init {};
+struct with_error {};
+template <class T, class, class>
+struct referable {
+  using type = T;
+};
+template <class T, class TConfig, class TDependency>
+struct referable<T&, TConfig, TDependency> {
+  using type = aux::conditional_t<TDependency::template is_referable<T&, TConfig>::value, T&, T>;
+};
+template <class T, class TConfig, class TDependency>
+struct referable<const T&, TConfig, TDependency> {
+  using type = aux::conditional_t<TDependency::template is_referable<const T&, TConfig>::value, const T&, T>;
+};
+#if defined(__MSVC__)
+template <class T, class TConfig, class TDependency>
+struct referable<T&&, TConfig, TDependency> {
+  using type = aux::conditional_t<TDependency::template is_referable<T&&, TConfig>::value, T&&, T>;
+};
+#endif
+template <class T, class TConfig, class TDependency>
+using referable_t = typename referable<T, TConfig, TDependency>::type;
+#if defined(__MSVC__)
+template <class T, class TInjector>
+inline auto build(TInjector&& injector) noexcept {
+  return T{static_cast<TInjector&&>(injector)};
+}
+#endif
+template <class TConfig, class TPolicies = pool<>, class... TDeps>
+class injector : public injector_base, public pool<bindings_t<TDeps...>> {
+  using pool_t = pool<bindings_t<TDeps...>>;
+
+ protected:
+  template <class T, class TName = no_name, class TIsRoot = aux::false_type>
+  struct is_creatable {
+    using dependency_t = binder::resolve_t<injector, T, TName>;
+    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
+                                                       typename dependency_t::ctor>::type;
+    using ctor_args_t = typename ctor_t::second::second;
+    static constexpr auto value =
+        aux::is_convertible<decltype(dependency__<dependency_t>::template try_create<T, TName>(
+                                try_provider<ctor_t, injector, decltype(aux::declval<TConfig>().provider(aux::declval<injector*>()))>{})),
+                            T>::value &&
+        policy::template try_call<arg_wrapper<T, TName, TIsRoot, ctor_args_t, dependency_t, pool_t>, TPolicies>::value;
+  };
+  auto& cfg() { return config_; }
+  const auto& cfg() const { return config_; }
+
+ public:
+  using deps = bindings_t<TDeps...>;
+  using config = TConfig;
+  injector(injector&&) = default;
+  template <class... TArgs>
+  explicit injector(const init&, TArgs... args) noexcept : injector{from_deps{}, static_cast<TArgs&&>(args)...} {}
+  template <class TConfig_, class TPolicies_, class... TDeps_>
+  explicit injector(injector<TConfig_, TPolicies_, TDeps_...>&& other) noexcept
+      : injector{from_injector{}, static_cast<injector<TConfig_, TPolicies_, TDeps_...>&&>(other), deps{}} {}
+  template <class T>
+  injector& operator=(T&& other) noexcept {
+    static_cast<pool_t&>(*this).operator=(static_cast<T&&>(other));
+    return *this;
+  }
+  template <class T, __BOOST_DI_REQUIRES(is_creatable<T, no_name, aux::true_type>::value) = 0>
+  T create() const {
+    return __BOOST_DI_TYPE_WKND(T) create_successful_impl<aux::true_type>(aux::type<T>{});
+  }
+  template <class T, __BOOST_DI_REQUIRES(!is_creatable<T, no_name, aux::true_type>::value) = 0>
+  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
+  T
+      // clang-format off
+  create
+      // clang-format on
+      () const {
+    return __BOOST_DI_TYPE_WKND(T) create_impl<aux::true_type>(aux::type<T>{});
+  }
+  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
+            __BOOST_DI_REQUIRES(is_creatable<R, no_name, aux::true_type>::value) = 0>
+  R
+  // clang-format off
+  create()
+      // clang-format on
+      const {
+    return __BOOST_DI_TYPE_WKND(R) create_successful_impl<aux::true_type>(aux::type<R>{});
+  }
+  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
+            __BOOST_DI_REQUIRES(!is_creatable<R, no_name, aux::true_type>::value) = 0>
+  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
+  R
+      // clang-format off
+  create()
+      // clang-format on
+      const {
+    return __BOOST_DI_TYPE_WKND(R) create_impl<aux::true_type>(aux::type<R>{});
+  }
+
+ protected:
+  template <class T>
+  struct try_create {
+    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
+  };
+  template <class TParent>
+  struct try_create<any_type_fwd<TParent>> {
+    using type = any_type<TParent, injector, with_error>;
+  };
+  template <class TParent>
+  struct try_create<any_type_ref_fwd<TParent>> {
+    using type = any_type_ref<TParent, injector, with_error>;
+  };
+  template <class TParent>
+  struct try_create<any_type_1st_fwd<TParent>> {
+    using type = any_type_1st<TParent, injector, with_error>;
+  };
+  template <class TParent>
+  struct try_create<any_type_1st_ref_fwd<TParent>> {
+    using type = any_type_1st_ref<TParent, injector, with_error>;
+  };
+  template <class TName, class T>
+  struct try_create<::boost::ext::di::v1_3_0::named<TName, T>> {
+    using type = aux::conditional_t<is_creatable<T, TName>::value, T, void>;
+  };
+  template <class TParent, int N, class T>
+  struct try_create<core::ctor_arg<TParent, N, T&&>> {
+    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
+  };
+  template <class TParent, int N>
+  struct try_create<core::ctor_arg<TParent, N, const placeholders::arg&>> {
+    using type = any_type_1st_ref<TParent, injector, with_error>;
+  };
+  template <class T>
+  struct try_create<self<T>> {
+    using type = injector;
+  };
+  template <class TIsRoot = aux::false_type, class T>
+  auto create_impl(const aux::type<T>&) const {
+    return create_impl__<TIsRoot, T>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_fwd<TParent>>&) const {
+    return any_type<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
+    return any_type_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
+    return any_type_1st<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
+    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T, class TName>
+  auto create_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
+    return create_impl__<TIsRoot, T, TName>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
+  auto create_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
+    auto& dependency = binder::resolve<TParent>((injector*)this);
+    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N>
+  auto create_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
+    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T>
+  auto create_successful_impl(const aux::type<T>&) const {
+    return create_successful_impl__<TIsRoot, T>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_fwd<TParent>>&) const {
+    return successful::any_type<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
+    return successful::any_type_ref<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
+    return successful::any_type_1st<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
+    return successful::any_type_1st_ref<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T, class TName>
+  auto create_successful_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
+    return create_successful_impl__<TIsRoot, T, TName>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
+  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
+    auto& dependency = binder::resolve<TParent>((injector*)this);
+    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N>
+  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
+    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T>
+  decltype(auto) create_successful_impl(const aux::type<self<T>>&) const {
+    return *this;
+  }
+
+ private:
+  explicit injector(const from_deps&) noexcept {}
+  template <class... TArgs>
+  explicit injector(const from_deps&, TArgs... args) noexcept
+      : pool_t{bindings_t<TArgs...>{}, core::pool_t<TArgs...>{static_cast<TArgs&&>(args)...}} {}
+  template <class TInjector, class... TArgs>
+  injector(const from_injector&, TInjector&& injector, const aux::type_list<TArgs...>&) noexcept
+#if defined(__MSVC__)
+      : pool_t{bindings_t<TArgs...>{},
+               pool_t {
+                 build<TArgs>(static_cast<TInjector&&>(injector))...
+               }}
+#else
+      : pool_t{bindings_t<TArgs...>{},
+               pool_t {
+                 TArgs{static_cast<TInjector&&>(injector)}...
+               }}
+#endif
+  {
+  }
+  template <class TInjector>
+  injector(const from_injector&, TInjector&&, const aux::type_list<>&) noexcept {}
+  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
+  auto create_impl__() const {
+    auto&& dependency = binder::resolve<T, TName>((injector*)this);
+    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
+    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
+                                                       typename dependency_t::ctor>::type;
+    using provider_t = core::provider<ctor_t, TName, injector>;
+    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
+    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
+    using ctor_args_t = typename ctor_t::second::second;
+    policy::template call<arg_wrapper<T, TName, TIsRoot, ctor_args_t, dependency_t, pool_t>>(
+        ((injector*)this)->cfg().policies(this));
+    return wrapper<T, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
+  }
+  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
+  auto create_successful_impl__() const {
+    auto&& dependency = binder::resolve<T, TName>((injector*)this);
+    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
+    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
+                                                       typename dependency_t::ctor>::type;
+    using provider_t = successful::provider<ctor_t, injector>;
+    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
+    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
+    using create_t = referable_t<T, config, dependency__<dependency_t>>;
+    using ctor_args_t = typename ctor_t::second::second;
+    policy::template call<arg_wrapper<T, TName, TIsRoot, ctor_args_t, dependency_t, pool_t>>(
+        ((injector*)this)->cfg().policies(this));
+    return successful::wrapper<create_t, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
+  }
+  config config_;
+};
+template <class TConfig, class... TDeps>
+class injector<TConfig, pool<>, TDeps...> : public injector_base, public pool<bindings_t<TDeps...>> {
+  using pool_t = pool<bindings_t<TDeps...>>;
+
+ protected:
+  template <class T, class TName = no_name, class TIsRoot = aux::false_type>
+  struct is_creatable {
+    using dependency_t = binder::resolve_t<injector, T, TName>;
+    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
+                                                       typename dependency_t::ctor>::type;
+    using ctor_args_t = typename ctor_t::second::second;
+    static constexpr auto value =
+        aux::is_convertible<decltype(dependency__<dependency_t>::template try_create<T, TName>(
+                                try_provider<ctor_t, injector, decltype(aux::declval<TConfig>().provider(aux::declval<injector*>()))>{})),
+                            T>::value;
+  };
+  auto& cfg() { return config_; }
+  const auto& cfg() const { return config_; }
+
+ public:
+  using deps = bindings_t<TDeps...>;
+  using config = TConfig;
+  injector(injector&&) = default;
+  template <class... TArgs>
+  explicit injector(const init&, TArgs... args) noexcept : injector{from_deps{}, static_cast<TArgs&&>(args)...} {}
+  template <class TConfig_, class TPolicies_, class... TDeps_>
+  explicit injector(injector<TConfig_, TPolicies_, TDeps_...>&& other) noexcept
+      : injector{from_injector{}, static_cast<injector<TConfig_, TPolicies_, TDeps_...>&&>(other), deps{}} {}
+  template <class T>
+  injector& operator=(T&& other) noexcept {
+    static_cast<pool_t&>(*this).operator=(static_cast<T&&>(other));
+    return *this;
+  }
+  template <class T, __BOOST_DI_REQUIRES(is_creatable<T, no_name, aux::true_type>::value) = 0>
+  T create() const {
+    return __BOOST_DI_TYPE_WKND(T) create_successful_impl<aux::true_type>(aux::type<T>{});
+  }
+  template <class T, __BOOST_DI_REQUIRES(!is_creatable<T, no_name, aux::true_type>::value) = 0>
+  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
+  T
+      // clang-format off
+  create
+      // clang-format on
+      () const {
+    return __BOOST_DI_TYPE_WKND(T) create_impl<aux::true_type>(aux::type<T>{});
+  }
+  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
+            __BOOST_DI_REQUIRES(is_creatable<R, no_name, aux::true_type>::value) = 0>
+  R
+  // clang-format off
+  create()
+      // clang-format on
+      const {
+    return __BOOST_DI_TYPE_WKND(R) create_successful_impl<aux::true_type>(aux::type<R>{});
+  }
+  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
+            __BOOST_DI_REQUIRES(!is_creatable<R, no_name, aux::true_type>::value) = 0>
+  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
+  R
+      // clang-format off
+  create()
+      // clang-format on
+      const {
+    return __BOOST_DI_TYPE_WKND(R) create_impl<aux::true_type>(aux::type<R>{});
+  }
+
+ protected:
+  template <class T>
+  struct try_create {
+    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
+  };
+  template <class TParent>
+  struct try_create<any_type_fwd<TParent>> {
+    using type = any_type<TParent, injector, with_error>;
+  };
+  template <class TParent>
+  struct try_create<any_type_ref_fwd<TParent>> {
+    using type = any_type_ref<TParent, injector, with_error>;
+  };
+  template <class TParent>
+  struct try_create<any_type_1st_fwd<TParent>> {
+    using type = any_type_1st<TParent, injector, with_error>;
+  };
+  template <class TParent>
+  struct try_create<any_type_1st_ref_fwd<TParent>> {
+    using type = any_type_1st_ref<TParent, injector, with_error>;
+  };
+  template <class TName, class T>
+  struct try_create<::boost::ext::di::v1_3_0::named<TName, T>> {
+    using type = aux::conditional_t<is_creatable<T, TName>::value, T, void>;
+  };
+  template <class TParent, int N, class T>
+  struct try_create<core::ctor_arg<TParent, N, T&&>> {
+    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
+  };
+  template <class TParent, int N>
+  struct try_create<core::ctor_arg<TParent, N, const placeholders::arg&>> {
+    using type = any_type_1st_ref<TParent, injector, with_error>;
+  };
+  template <class T>
+  struct try_create<self<T>> {
+    using type = injector;
+  };
+  template <class TIsRoot = aux::false_type, class T>
+  auto create_impl(const aux::type<T>&) const {
+    return create_impl__<TIsRoot, T>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_fwd<TParent>>&) const {
+    return any_type<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
+    return any_type_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
+    return any_type_1st<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
+    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T, class TName>
+  auto create_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
+    return create_impl__<TIsRoot, T, TName>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
+  auto create_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
+    auto& dependency = binder::resolve<TParent>((injector*)this);
+    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N>
+  auto create_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
+    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T>
+  auto create_successful_impl(const aux::type<T>&) const {
+    return create_successful_impl__<TIsRoot, T>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_fwd<TParent>>&) const {
+    return successful::any_type<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
+    return successful::any_type_ref<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
+    return successful::any_type_1st<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class TParent>
+  auto create_successful_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
+    return successful::any_type_1st_ref<TParent, injector>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T, class TName>
+  auto create_successful_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
+    return create_successful_impl__<TIsRoot, T, TName>();
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
+  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
+    auto& dependency = binder::resolve<TParent>((injector*)this);
+    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
+  }
+  template <class TIsRoot = aux::false_type, class TParent, int N>
+  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
+    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
+  }
+  template <class TIsRoot = aux::false_type, class T>
+  decltype(auto) create_successful_impl(const aux::type<self<T>>&) const {
+    return *this;
+  }
+
+ private:
+  explicit injector(const from_deps&) noexcept {}
+  template <class... TArgs>
+  explicit injector(const from_deps&, TArgs... args) noexcept
+      : pool_t{bindings_t<TArgs...>{}, core::pool_t<TArgs...>{static_cast<TArgs&&>(args)...}} {}
+  template <class TInjector, class... TArgs>
+  injector(const from_injector&, TInjector&& injector, const aux::type_list<TArgs...>&) noexcept
+#if defined(__MSVC__)
+      : pool_t{bindings_t<TArgs...>{},
+               pool_t {
+                 build<TArgs>(static_cast<TInjector&&>(injector))...
+               }}
+#else
+      : pool_t{bindings_t<TArgs...>{},
+               pool_t {
+                 TArgs{static_cast<TInjector&&>(injector)}...
+               }}
+#endif
+  {
+  }
+  template <class TInjector>
+  injector(const from_injector&, TInjector&&, const aux::type_list<>&) noexcept {}
+  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
+  auto create_impl__() const {
+    auto&& dependency = binder::resolve<T, TName>((injector*)this);
+    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
+    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
+                                                       typename dependency_t::ctor>::type;
+    using provider_t = core::provider<ctor_t, TName, injector>;
+    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
+    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
+    return wrapper<T, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
+  }
+  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
+  auto create_successful_impl__() const {
+    auto&& dependency = binder::resolve<T, TName>((injector*)this);
+    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
+    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
+                                                       typename dependency_t::ctor>::type;
+    using provider_t = successful::provider<ctor_t, injector>;
+    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
+    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
+    using create_t = referable_t<T, config, dependency__<dependency_t>>;
+    return successful::wrapper<create_t, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
+  }
+  config config_;
+};
+}
+template <class T, class TInjector>
+auto create(const TInjector& injector) -> decltype(injector.template create<T>()) {
+  return injector.template create<T>();
+}
+template <template <class...> class T, class TInjector>
+auto create(const TInjector& injector) -> decltype(injector.template create<T>()) {
+  return injector.template create<T>();
+}
+template <class T, class TInjector>
+constexpr auto is_creatable(const TInjector&) {
+  return core::injector__<TInjector>::template is_creatable<T, no_name, aux::true_type>::value;
+}
+template <template <class...> class T, class TInjector>
+constexpr auto is_creatable(const TInjector&) {
+  return core::injector__<TInjector>::template is_creatable<core::binder::resolve_template_t<TInjector, aux::identity<T<>>>,
+                                                            no_name, aux::true_type>::value;
+}
+namespace detail {
+template <class>
+void create(const aux::true_type&) {}
+// clang-format off
+template <class>
+__BOOST_DI_DEPRECATED("creatable constraint not satisfied") void
+create
+(const aux::false_type&) {}
+// clang-format on
+template <class, class, class...>
+struct injector;
+template <class, class>
+struct is_creatable_impl;
+template <class TInjector, class TName, class T>
+struct is_creatable_impl<TInjector, named<TName, T>> {
+  static constexpr auto value = core::injector__<TInjector>::template is_creatable<T, TName>::value;
+};
+template <class TConfig, class T, class... TGivens>
+struct injector<TConfig, int, core::dependency<scopes::instance, T, aux::type_list<TGivens...>>>
+    : core::injector<TConfig, core::pool<>, core::dependency<scopes::instance, T, aux::type_list<TGivens...>>> {
+  template <class... Ts>
+  injector(core::injector<Ts...>&& injector) noexcept
+      : core::injector<TConfig, core::pool<>, core::dependency<scopes::instance, T, aux::type_list<TGivens...>>>(
+            static_cast<core::injector<Ts...>&&>(injector)) {
+    using injector_t = core::injector<Ts...>;
+    int _[]{0,
+            // clang-format off
+            (detail::
+create<T> (
+     aux::integral_constant<bool, is_creatable_impl<injector_t, TGivens>::value>{}),
+             0)...};
+    // clang-format on
+    (void)_;
+  }
+};
+}
+#if defined(__MSVC__)
+template <class T, class... Ts>
+struct injector
+    : detail::injector<
+          BOOST_DI_CFG, __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type<T, Ts...>>),
+          core::dependency<scopes::instance, aux::unique_t<type_traits::named_decay_t<T>, type_traits::named_decay_t<Ts>...>,
+                           aux::type_list<type_traits::add_named_t<T>, type_traits::add_named_t<Ts>...>>> {
+  using detail::injector<
+      BOOST_DI_CFG, __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type<T, Ts...>>),
+      core::dependency<scopes::instance, aux::unique_t<type_traits::named_decay_t<T>, type_traits::named_decay_t<Ts>...>,
+                       aux::type_list<type_traits::add_named_t<T>, type_traits::add_named_t<Ts>...>>>::injector;
+};
+#else
+template <class T, class... Ts>
+using injector = detail::injector<
+    BOOST_DI_CFG, __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type<T, Ts...>>),
+    core::dependency<scopes::instance, aux::unique_t<type_traits::named_decay_t<T>, type_traits::named_decay_t<Ts>...>,
+                     aux::type_list<type_traits::add_named_t<T>, type_traits::add_named_t<Ts>...>>>;
+#endif
+// clang-format off
+#define __BOOST_DI_EXPOSE_IMPL__(...) decltype(::boost::ext::di::v1_3_0::detail::__VA_ARGS__),
+#define __BOOST_DI_EXPOSE_IMPL(...) ::boost::ext::di::v1_3_0::named<__BOOST_DI_EXPOSE_IMPL__ __VA_ARGS__>
+#define BOOST_DI_EXPOSE(...) __BOOST_DI_IF(__BOOST_DI_IBP(__VA_ARGS__), __BOOST_DI_EXPOSE_IMPL, __BOOST_DI_EXPAND)(__VA_ARGS__)
+// clang-format on
+#if defined(__MSVC__)
+#define __BOOST_DI_MAKE_INJECTOR(...) __VA_ARGS__
+#else
+namespace detail {
+static auto make_injector = [](auto injector) {
+  using injector_t = decltype(injector);
+  struct i : injector_t {
+    explicit i(injector_t&& other) : injector_t(static_cast<injector_t&&>(other)) {}
+  };
+  return i{static_cast<injector_t&&>(injector)};
+};
+}
+#define __BOOST_DI_MAKE_INJECTOR(...) detail::make_injector(__VA_ARGS__)
+#endif
+template <class TConfig = BOOST_DI_CFG, class... TDeps,
+          __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type_list<TDeps...>>) = 0,
+          __BOOST_DI_REQUIRES_MSG(concepts::configurable<TConfig>) = 0>
+inline auto make_injector(TDeps... args) noexcept {
+  return __BOOST_DI_MAKE_INJECTOR(
+      core::injector<TConfig, decltype(aux::declval<TConfig*>()->policies(aux::declval<concepts::injector<TConfig>*>())), TDeps...>{
+          core::init{}, static_cast<TDeps&&>(args)...});
+}
+namespace policies {
+namespace detail {
+struct type_op {};
+template <class T, class = int>
+struct apply_impl {
+  template <class>
+  struct apply : T {};
+};
+template <template <class...> class T, class... Ts>
+struct apply_impl<T<Ts...>, __BOOST_DI_REQUIRES(!aux::is_base_of<type_op, T<Ts...>>::value)> {
+  template <class TOp, class>
+  struct apply_placeholder_impl {
+    using type = TOp;
+  };
+  template <class TOp>
+  struct apply_placeholder_impl<_, TOp> {
+    using type = TOp;
+  };
+  template <template <class...> class TExpr, class TOp, class... TArgs>
+  struct apply_placeholder {
+    using type = TExpr<typename apply_placeholder_impl<TArgs, TOp>::type...>;
+  };
+  template <class TArg>
+  struct apply : apply_placeholder<T, typename TArg::type, Ts...>::type {};
+};
+template <class T>
+struct apply_impl<T, __BOOST_DI_REQUIRES(aux::is_base_of<type_op, T>::value)> {
+  template <class TArg>
+  struct apply : T::template apply<TArg>::type {};
+};
+template <class T>
+struct not_ : detail::type_op {
+  template <class TArg>
+  struct apply : aux::integral_constant<bool, !detail::apply_impl<T>::template apply<TArg>::value> {};
+};
+template <class... Ts>
+struct and_ : detail::type_op {
+  template <class TArg>
+  struct apply : aux::is_same<aux::bool_list<detail::apply_impl<Ts>::template apply<TArg>::value...>,
+                              aux::bool_list<aux::always<Ts>::value...>> {};
+};
+template <class... Ts>
+struct or_ : detail::type_op {
+  template <class TArg>
+  struct apply
+      : aux::integral_constant<bool, !aux::is_same<aux::bool_list<detail::apply_impl<Ts>::template apply<TArg>::value...>,
+                                                   aux::bool_list<aux::never<Ts>::value...>>::value> {};
+};
+}
+template <class T>
+struct type {
+  template <class TPolicy>
+  struct not_allowed_by {
+    operator aux::false_type() const {
+      using constraint_not_satisfied = not_allowed_by;
+      return constraint_not_satisfied{}.error();
+    }
+    // clang-format off
+    static inline aux::false_type
+ error(_ = "type disabled by constructible policy, added by BOOST_DI_CFG or make_injector<CONFIG>!");
+    // clang-format on
+  };
+};
+template <class>
+struct is_root : detail::type_op {
+  template <class TArg>
+  struct apply : TArg::is_root {};
+};
+template <class T>
+struct is_bound : detail::type_op {
+  struct not_resolved {};
+  template <class TArg>
+  struct apply
+      : aux::integral_constant<
+            bool,
+            !aux::is_same<typename TArg::template resolve<aux::conditional_t<aux::is_same<T, _>::value, typename TArg::type, T>,
+                                                          typename TArg::name, not_resolved>,
+                          not_resolved>::value> {};
+};
+template <class T>
+struct is_injected : detail::type_op {
+  template <class TArg, class U = aux::decay_t<aux::conditional_t<aux::is_same<T, _>::value, typename TArg::type, T>>>
+  struct apply : aux::conditional_t<aux::is_class<U>::value, typename type_traits::is_injectable<U>::type, aux::true_type> {};
+};
+static constexpr auto include_root = true;
+namespace operators {
+template <class X, class Y>
+inline auto operator||(const X&, const Y&) {
+  return detail::or_<X, Y>{};
+}
+template <class X, class Y>
+inline auto operator&&(const X&, const Y&) {
+  return detail::and_<X, Y>{};
+}
+template <class T>
+inline auto operator!(const T&) {
+  return detail::not_<T>{};
+}
+}
+template <bool, class T>
+struct constructible_impl {
+  template <class TArg, __BOOST_DI_REQUIRES(TArg::is_root::value || T::template apply<TArg>::value) = 0>
+  aux::true_type operator()(const TArg&) const {
+    return {};
+  }
+  template <class TArg, __BOOST_DI_REQUIRES(!TArg::is_root::value && !T::template apply<TArg>::value) = 0>
+  aux::false_type operator()(const TArg&) const {
+    return typename type<typename TArg::type>::template not_allowed_by<T>{};
+  }
+};
+template <class T>
+struct constructible_impl<true, T> {
+  template <class TArg, __BOOST_DI_REQUIRES(T::template apply<TArg>::value) = 0>
+  aux::true_type operator()(const TArg&) const {
+    return {};
+  }
+  template <class TArg, __BOOST_DI_REQUIRES(!T::template apply<TArg>::value) = 0>
+  aux::false_type operator()(const TArg&) const {
+    return typename type<typename TArg::type>::template not_allowed_by<T>{};
+  }
+};
+template <bool IncludeRoot = false, class T = aux::never<_>,
+          __BOOST_DI_REQUIRES(aux::is_base_of<detail::type_op, T>::value) = 0>
+inline auto constructible(const T& = {}) {
+  return constructible_impl<IncludeRoot, T>{};
+}
+template <bool IncludeRoot = false, class T = aux::never<_>,
+          __BOOST_DI_REQUIRES(!aux::is_base_of<detail::type_op, T>::value) = 0>
+inline auto constructible(const T& = {}) {
+  return constructible_impl<IncludeRoot, detail::or_<T>>{};
+}
+}
+#define __BOOST_DI_IF(cond, t, f) __BOOST_DI_IF_I(cond, t, f)
+#define __BOOST_DI_REPEAT(i, m, ...) __BOOST_DI_REPEAT_N(i, m, __VA_ARGS__)
+#define __BOOST_DI_CAT(a, ...) __BOOST_DI_PRIMITIVE_CAT(a, __VA_ARGS__)
+#define __BOOST_DI_EMPTY()
+#define __BOOST_DI_COMMA() ,
+#define __BOOST_DI_EAT(...)
+#define __BOOST_DI_EXPAND(...) __VA_ARGS__
+#define __BOOST_DI_SIZE(...) __BOOST_DI_CAT(__BOOST_DI_VARIADIC_SIZE_I(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ), )
+#define __BOOST_DI_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
+#define __BOOST_DI_ELEM(n, ...) __BOOST_DI_ELEM_I(n, __VA_ARGS__)
+#define __BOOST_DI_IS_EMPTY(...)                              \
+  __BOOST_DI_DETAIL_IS_EMPTY_IIF(__BOOST_DI_IBP(__VA_ARGS__)) \
+  (__BOOST_DI_DETAIL_IS_EMPTY_GEN_ZERO, __BOOST_DI_DETAIL_IS_EMPTY_PROCESS)(__VA_ARGS__)
+#define __BOOST_DI_DETAIL_IS_EMPTY_PRIMITIVE_CAT(a, b) a##b
+#define __BOOST_DI_DETAIL_IS_EMPTY_IIF(bit) __BOOST_DI_DETAIL_IS_EMPTY_PRIMITIVE_CAT(__BOOST_DI_DETAIL_IS_EMPTY_IIF_, bit)
+#define __BOOST_DI_DETAIL_IS_EMPTY_NON_FUNCTION_C(...) ()
+#define __BOOST_DI_DETAIL_IS_EMPTY_GEN_ZERO(...) 0
+#define __BOOST_DI_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, size, ...) size
+#define __BOOST_DI_IF_I(cond, t, f) __BOOST_DI_IIF(cond, t, f)
+#define __BOOST_DI_IIF_0(t, f) f
+#define __BOOST_DI_IIF_1(t, f) t
+#define __BOOST_DI_IIF_2(t, f) t
+#define __BOOST_DI_IIF_3(t, f) t
+#define __BOOST_DI_IIF_4(t, f) t
+#define __BOOST_DI_IIF_5(t, f) t
+#define __BOOST_DI_IIF_6(t, f) t
+#define __BOOST_DI_IIF_7(t, f) t
+#define __BOOST_DI_IIF_8(t, f) t
+#define __BOOST_DI_IIF_9(t, f) t
+#define __BOOST_DI_ELEM_I(n, ...) __BOOST_DI_CAT(__BOOST_DI_CAT(__BOOST_DI_ELEM, n)(__VA_ARGS__, ), )
+#define __BOOST_DI_ELEM0(p1, ...) p1
+#define __BOOST_DI_ELEM1(p1, p2, ...) p2
+#define __BOOST_DI_ELEM2(p1, p2, p3, ...) p3
+#define __BOOST_DI_ELEM3(p1, p2, p3, p4, ...) p4
+#define __BOOST_DI_ELEM4(p1, p2, p3, p4, p5, ...) p5
+#define __BOOST_DI_ELEM5(p1, p2, p3, p4, p5, p6, ...) p6
+#define __BOOST_DI_ELEM6(p1, p2, p3, p4, p5, p6, p7, ...) p7
+#define __BOOST_DI_ELEM7(p1, p2, p3, p4, p5, p6, p7, p8, ...) p8
+#define __BOOST_DI_ELEM8(p1, p2, p3, p4, p5, p6, p7, p8, p9, ...) p9
+#define __BOOST_DI_ELEM9(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, ...) p10
+#define __BOOST_DI_REPEAT_N(i, m, ...) __BOOST_DI_REPEAT_##i(m, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_1(m, ...) m(0, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_2(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_3(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_4(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_5(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_6(m, ...) \
+  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_7(m, ...) \
+  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) m(6, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_8(m, ...)                                                                           \
+  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) \
+      m(6, __VA_ARGS__) m(7, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_9(m, ...)                                                                           \
+  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) \
+      m(6, __VA_ARGS__) m(7, __VA_ARGS__) m(8, __VA_ARGS__)
+#define __BOOST_DI_REPEAT_10(m, ...)                                                                          \
+  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) \
+      m(6, __VA_ARGS__) m(7, __VA_ARGS__) m(8, __VA_ARGS__) m(9, __VA_ARGS__)
+#if defined(__MSVC__)
+#define __BOOST_DI_VD_IBP_CAT(a, b) __BOOST_DI_VD_IBP_CAT_I(a, b)
+#define __BOOST_DI_VD_IBP_CAT_I(a, b) __BOOST_DI_VD_IBP_CAT_II(a##b)
+#define __BOOST_DI_VD_IBP_CAT_II(res) res
+#define __BOOST_DI_IBP_SPLIT(i, ...) \
+  __BOOST_DI_VD_IBP_CAT(__BOOST_DI_IBP_PRIMITIVE_CAT(__BOOST_DI_IBP_SPLIT_, i)(__VA_ARGS__), __BOOST_DI_EMPTY())
+#define __BOOST_DI_IBP_IS_VARIADIC_C(...) 1 1
+#define __BOOST_DI_IBP_SPLIT_0(a, ...) a
+#define __BOOST_DI_IBP_SPLIT_1(a, ...) __VA_ARGS__
+#define __BOOST_DI_IBP_CAT(a, ...) __BOOST_DI_IBP_PRIMITIVE_CAT(a, __VA_ARGS__)
+#define __BOOST_DI_IBP_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
+#define __BOOST_DI_IBP_IS_VARIADIC_R_1 1,
+#define __BOOST_DI_IBP_IS_VARIADIC_R___BOOST_DI_IBP_IS_VARIADIC_C 0,
+#define __BOOST_DI_IBP(...) \
+  __BOOST_DI_IBP_SPLIT(0, __BOOST_DI_IBP_CAT(__BOOST_DI_IBP_IS_VARIADIC_R_, __BOOST_DI_IBP_IS_VARIADIC_C __VA_ARGS__))
+#define __BOOST_DI_IIF(bit, t, f) __BOOST_DI_IIF_OO((bit, t, f))
+#define __BOOST_DI_IIF_OO(par) __BOOST_DI_IIF_I##par
+#define __BOOST_DI_IIF_I(bit, t, f) __BOOST_DI_IIF_##bit(t, f)
+#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_0(t, b) b
+#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_1(t, b) t
+#define __BOOST_DI_DETAIL_IS_EMPTY_PROCESS(...) __BOOST_DI_IBP(__BOOST_DI_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__())
+#else
+#define __BOOST_DI_IBP_SPLIT(i, ...) __BOOST_DI_PRIMITIVE_CAT(__BOOST_DI_IBP_SPLIT_, i)(__VA_ARGS__)
+#define __BOOST_DI_IBP_SPLIT_0(a, ...) a
+#define __BOOST_DI_IBP_SPLIT_1(a, ...) __VA_ARGS__
+#define __BOOST_DI_IBP_IS_VARIADIC_C(...) 1
+#define __BOOST_DI_IBP_IS_VARIADIC_R_1 1,
+#define __BOOST_DI_IBP_IS_VARIADIC_R___BOOST_DI_IBP_IS_VARIADIC_C 0,
+#define __BOOST_DI_IBP(...) \
+  __BOOST_DI_IBP_SPLIT(0, __BOOST_DI_CAT(__BOOST_DI_IBP_IS_VARIADIC_R_, __BOOST_DI_IBP_IS_VARIADIC_C __VA_ARGS__))
+#define __BOOST_DI_IIF(bit, t, f) __BOOST_DI_IIF_I(bit, t, f)
+#define __BOOST_DI_IIF_I(bit, t, f) __BOOST_DI_IIF_II(__BOOST_DI_IIF_##bit(t, f))
+#define __BOOST_DI_IIF_II(id) id
+#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_0(t, ...) __VA_ARGS__
+#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_1(t, ...) t
+#define __BOOST_DI_DETAIL_IS_EMPTY_PROCESS(...) __BOOST_DI_IBP(__BOOST_DI_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__())
+#endif
+template <class, class>
+struct named;
+namespace detail {
+struct named_impl {
+  template <class T>
+  T operator=(const T&) const;
+};
+static constexpr __BOOST_DI_UNUSED named_impl named{};
+template <class T, class TName>
+struct combine_impl {
+  using type = ::boost::ext::di::v1_3_0::named<TName, T>;
+};
+template <class T>
+struct combine_impl<T, aux::none_type> {
+  using type = T;
+};
+template <class, class>
+struct combine;
+template <class... T1, class... T2>
+struct combine<aux::type_list<T1...>, aux::type_list<T2...>> {
+  using type = aux::type_list<typename combine_impl<T1, T2>::type...>;
+};
+template <class T1, class T2>
+using combine_t = typename combine<T1, T2>::type;
+}
+template <class... Ts>
+using inject = aux::type_list<Ts...>;
+#define __BOOST_DI_HAS_NAME(i, ...) __BOOST_DI_IF(__BOOST_DI_IBP(__BOOST_DI_ELEM(i, __VA_ARGS__, )), 1, )
+#define __BOOST_DI_HAS_NAMES(...) \
+  __BOOST_DI_IF(__BOOST_DI_IS_EMPTY(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_HAS_NAME, __VA_ARGS__)), 0, 1)
+#define __BOOST_DI_GEN_CTOR_IMPL(p, i) \
+  __BOOST_DI_IF(i, __BOOST_DI_COMMA, __BOOST_DI_EAT)() __BOOST_DI_IF(__BOOST_DI_IBP(p), __BOOST_DI_EAT p, p)
+#define __BOOST_DI_GEN_CTOR(i, ...) __BOOST_DI_GEN_CTOR_IMPL(__BOOST_DI_ELEM(i, __VA_ARGS__, ), i)
+#define __BOOST_DI_GEN_ARG_NAME(p) __BOOST_DI_GEN_ARG_NAME_IMPL p )
+#define __BOOST_DI_GEN_NONE_TYPE(p) ::boost::ext::di::v1_3_0::aux::none_type
+#define __BOOST_DI_GEN_ARG_NAME_IMPL(p) decltype(::boost::ext::di::v1_3_0::detail::p) __BOOST_DI_EAT(
+#define __BOOST_DI_GEN_NAME_IMPL(p, i)               \
+  __BOOST_DI_IF(i, __BOOST_DI_COMMA, __BOOST_DI_EAT) \
+  () __BOOST_DI_IF(__BOOST_DI_IBP(p), __BOOST_DI_GEN_ARG_NAME, __BOOST_DI_GEN_NONE_TYPE)(p)
+#define __BOOST_DI_GEN_NAME(i, ...) __BOOST_DI_GEN_NAME_IMPL(__BOOST_DI_ELEM(i, __VA_ARGS__, ), i)
+#define __BOOST_DI_INJECT_TRAITS_IMPL_0(...)                                                           \
+  static void ctor(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_CTOR, __VA_ARGS__)); \
+  using type __BOOST_DI_UNUSED = ::boost::ext::di::v1_3_0::aux::function_traits_t<decltype(ctor)>;
+#define __BOOST_DI_INJECT_TRAITS_IMPL_1(...)                                                                        \
+  static void ctor(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_CTOR, __VA_ARGS__));              \
+  static void name(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_NAME, __VA_ARGS__));              \
+  using type __BOOST_DI_UNUSED =                                                                                    \
+      ::boost::ext::di::v1_3_0::detail::combine_t<::boost::ext::di::v1_3_0::aux::function_traits_t<decltype(ctor)>, \
+                                                  ::boost::ext::di::v1_3_0::aux::function_traits_t<decltype(name)>>;
+#define __BOOST_DI_INJECT_TRAITS_EMPTY_IMPL(...) \
+  using boost_di_inject__ __BOOST_DI_UNUSED = ::boost::ext::di::v1_3_0::aux::type_list<>
+#define __BOOST_DI_INJECT_TRAITS_IMPL(...)                                                                             \
+  struct boost_di_inject__ {                                                                                           \
+    __BOOST_DI_CAT(__BOOST_DI_INJECT_TRAITS_IMPL_, __BOOST_DI_HAS_NAMES(__VA_ARGS__))                                  \
+    (__VA_ARGS__) static_assert(__BOOST_DI_SIZE(__VA_ARGS__) <= BOOST_DI_CFG_CTOR_LIMIT_SIZE,                          \
+                                "Number of constructor arguments is out of range - see BOOST_DI_CFG_CTOR_LIMIT_SIZE"); \
+  }
+#define BOOST_DI_INJECT_TRAITS(...)                                                                                   \
+  __BOOST_DI_IF(__BOOST_DI_IS_EMPTY(__VA_ARGS__), __BOOST_DI_INJECT_TRAITS_EMPTY_IMPL, __BOOST_DI_INJECT_TRAITS_IMPL) \
+  (__VA_ARGS__)
+#define BOOST_DI_INJECT(T, ...)        \
+  BOOST_DI_INJECT_TRAITS(__VA_ARGS__); \
+  T(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_CTOR, __VA_ARGS__))
+BOOST_DI_NAMESPACE_END
+#endif
+#if defined(__CLANG__)
+#pragma clang diagnostic pop
+#elif defined(__GCC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/gitattributes b/gitattributes
index 1c42e45..ba50d55 100644
--- a/gitattributes
+++ b/gitattributes
@@ -3,3 +3,5 @@
 *.[pP][dD][bB] filter=lfs diff=lfs merge=lfs -text
 *.[d][lL][lL] filter=lfs diff=lfs merge=lfs -text
 *.[lL][iI][bB] filter=lfs diff=lfs merge=lfs -text
+
+*.[pP][nN][gG] filter=lfs diff=lfs merge=lfs -text
diff --git a/vcpkg.json b/vcpkg.json
index b246429..63814f3 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
   "name": "cpp-gamedev-manifest",
   "version-string": "0.1.0",
   "dependencies": [
@@ -8,6 +8,9 @@
     },
     {
       "name": "sfml"
+    },
+    {
+      "name": "box2d"
     }
   ]
 }

From a189748eb8be5f99a74b68b764ed54bc7fc93e49 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Fri, 22 Sep 2023 19:59:15 +0300
Subject: [PATCH 02/13] move container and render_object to separate files,
 delete bullet if collide with other physics objects

---
 battle_tanks/client/battle_tanks.cpp          | 305 ++++++++++--------
 battle_tanks/client/headers/container.hpp     |  27 ++
 battle_tanks/client/headers/debug_draw.hpp    |  11 +-
 battle_tanks/client/headers/render_object.hpp |  34 ++
 battle_tanks/client/sources/container.cpp     |  46 +++
 battle_tanks/client/sources/debug_draw.cpp    |   2 +-
 battle_tanks/client/sources/render_object.cpp |  12 +
 7 files changed, 295 insertions(+), 142 deletions(-)
 create mode 100644 battle_tanks/client/headers/container.hpp
 create mode 100644 battle_tanks/client/headers/render_object.hpp
 create mode 100644 battle_tanks/client/sources/container.cpp
 create mode 100644 battle_tanks/client/sources/render_object.cpp

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 7da50bc..2a9d5cc 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -1,6 +1,10 @@
 #include <cmath>
 #include <numbers>
 #include <chrono>
+#include <functional>
+#include <ranges>
+#include <unordered_map>
+#include <unordered_set>
 
 #include <SFML/Graphics.hpp>
 #include <box2d/box2d.h>
@@ -8,6 +12,8 @@
 #include "boost/di.hpp"
 
 #include "debug_draw.hpp"
+#include "render_object.hpp"
+#include "container.hpp"
 
 typedef long long unsigned uuid;
 static uuid current_uuid{ 1 };
@@ -16,11 +22,16 @@ uuid generate_uuid()
     return current_uuid++;
 }
 
-float deg_to_rad(float rotation)
+float deg_to_rad(const float rotation)
 {
     return static_cast<float>(std::numbers::pi * static_cast<double>(rotation) / 180.0);
 }
 
+float rad_to_deg(const float rotation)
+{
+    return static_cast<float>(static_cast<double>(rotation) * 180.0f / std::numbers::pi);
+}
+
 class container;
 class render_object;
 
@@ -49,8 +60,8 @@ enum class game_object_type : unsigned
 
 struct game_object_b2d_link
 {
-	game_object_type type{ game_object_type::unknown };
-	uuid id{ 0 };
+    game_object_type type{ game_object_type::unknown };
+    uuid id{ 0 };
 };
 
 class game_object
@@ -68,12 +79,17 @@ class game_object
     virtual void free() = 0;
 
 public:
+    uuid get_id() const
+    {
+        return id_;
+    }
+
     const std::shared_ptr<render_object>& get_render_object() const
     {
         return render_object_;
     }
 
-    const b2Body* get_physics_body() const
+    b2Body* get_physics_body() const
     {
         return physics_body_;
     }
@@ -87,10 +103,9 @@ class game_object
 class game_scene
 {
 public:
-    void update(float delta_time) const
+    void update(const float delta_time) const
     {
-        //physics_world_.Step(delta_time, 8, 3);
-        for (const auto& game_object : game_objects_)
+        for (const auto& game_object : game_objects_ | std::views::values)
         {
             game_object->update(delta_time);
         }
@@ -98,93 +113,21 @@ class game_scene
 
     void add_game_object(const std::shared_ptr<game_object>& game_object)
     {
-        game_objects_.push_back(game_object);
+        game_objects_.insert({ game_object->get_id(), game_object });
     }
 
     void remove_game_object(const std::shared_ptr<game_object>& game_object)
     {
-        for (auto it = game_objects_.begin(); it != game_objects_.end(); ++it)
-        {
-            if (*it == game_object)
-            {
-                game_objects_.erase(it);
-                break;
-            }
-        }
+        game_objects_.erase(game_object->get_id());
     }
 
-private:
-    std::vector<std::shared_ptr<game_object>> game_objects_{};
-
-    //b2World physics_world_{ { 0.0f, 0.0f } };
-};
-
-class render_object : public sf::Transformable
-{
-    friend container;
-
-public:
-    virtual ~render_object() override = default;
-
-public:
-    void free()
+    std::shared_ptr<game_object> get_game_object(const uuid id) const
     {
-        if (parent_ != nullptr)
-        {
-            //TODO: fix
-            //parent_->remove_child(std::shared_ptr<render_object>(this));
-            //parent_ = nullptr;
-        }
+        return game_objects_.at(id);
     }
 
-protected:
-    virtual void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const = 0;
-
 private:
-    std::shared_ptr<container> parent_{ nullptr };
-};
-
-class container : public render_object
-{
-public:
-    virtual ~container() override = default;
-
-public:
-    void add_child(const std::shared_ptr<render_object>& child)
-    {
-        if (child->parent_ != nullptr)
-        {
-            child->parent_->remove_child(child);
-        }
-
-        children_.push_back(child);
-        //child->parent_ = std::shared_ptr<container>(this); //TODO: fix
-    }
-
-    void remove_child(const std::shared_ptr<render_object>& child)
-    {
-        for (auto it = children_.begin(); it != children_.end(); ++it)
-        {
-            if (*it == child)
-            {
-                children_.erase(it);
-                break;
-            }
-        }
-    }
-
-protected:
-    void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
-    {
-        const sf::Transform transform = parent_transform * getTransform();
-        for (const auto& ch : children_)
-        {
-            ch->draw(render_target, transform);
-        }
-    }
-
-protected:
-    std::vector<std::shared_ptr<render_object>> children_{};
+    std::unordered_map<uuid, std::shared_ptr<game_object>> game_objects_{};
 };
 
 class render_scene final : public container
@@ -291,16 +234,6 @@ class bullet : public game_object
             return;
         }
 
-        /*
-        const auto position = render_object_->getPosition();
-        const auto rotation = render_object_->getRotation();
-        const auto rad_rotation = static_cast<float>(std::numbers::pi * static_cast<double>(rotation) / 180.0);
-
-        const auto new_position_x = position.x + std::sin(rad_rotation) * velocity_ * delta_time;
-        const auto new_position_y = position.y + -std::cos(rad_rotation) * velocity_ * delta_time;
-
-        render_object_->setPosition(new_position_x, new_position_y);
-        */
         auto& ph_body_pos = physics_body_->GetPosition();
         const float ph_body_rot = physics_body_->GetAngle();
 
@@ -308,16 +241,15 @@ class bullet : public game_object
         render_object_->setRotation(std::fmod(
             static_cast<float>(static_cast<double>(ph_body_rot) * 180.0f / std::numbers::pi), 360.0f)
         );
-
-        //TODO: delete bullet if it out of game field (field_size_)
     }
 
     virtual void free() override
     {
         if (render_object_ != nullptr)
         {
-            render_object_->free();
+	        const auto render_object = render_object_;
             render_object_ = nullptr;
+            render_object->free();
         }
     }
 
@@ -331,17 +263,30 @@ class bullet : public game_object
 
 class physics_contact_listener final : public b2ContactListener
 {
+public:
+    physics_contact_listener()= default;
+
+    virtual ~physics_contact_listener() override
+    {
+        collision_handler_ = nullptr;
+    }
+
+public:
+
+    void add_collision_handler(const std::function<void(game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)>& collision_handler)
+    {
+        collision_handler_ = collision_handler;
+    }
+
     void BeginContact(b2Contact* contact) override
     {
         b2Fixture* fixture_a = contact->GetFixtureA();
         b2Fixture* fixture_b = contact->GetFixtureB();
 
-        // Check if fixtureA or fixtureB is your object, and perform actions accordingly.
-        // For example, you can check user data associated with the fixtures.
         b2Body* body_a = fixture_a->GetBody();
         b2Body* body_b = fixture_b->GetBody();
-        b2BodyUserData user_data_a = body_a->GetUserData();
-        b2BodyUserData user_data_b = body_b->GetUserData();
+        const b2BodyUserData user_data_a = body_a->GetUserData();
+        const b2BodyUserData user_data_b = body_b->GetUserData();
 
         const game_object_b2d_link* link_a{ nullptr };
         const game_object_b2d_link* link_b{ nullptr };
@@ -349,24 +294,116 @@ class physics_contact_listener final : public b2ContactListener
         if (user_data_a.pointer != 0)
         {
             link_a = reinterpret_cast<game_object_b2d_link*>(user_data_a.pointer);
-            if (link_a->type == game_object_type::bullet)
-            {
-                //std::cout << "Bullet collision detected!" << std::endl;
-            }
         }
 
         if (user_data_b.pointer != 0)
         {
             link_b = reinterpret_cast<game_object_b2d_link*>(user_data_b.pointer);
-            if (link_b->type == game_object_type::bullet)
-            {
-                //std::cout << "Bullet collision detected!" << std::endl;
-            }
         }
 
-        // Perform collision handling here.
-        //std::cout << "Collision detected!" << std::endl;
+        if (collision_handler_)
+        {
+            collision_handler_(
+                link_a != nullptr ? *link_a : game_object_b2d_link{ game_object_type::unknown, 0 },
+                link_b != nullptr ? *link_b : game_object_b2d_link{ game_object_type::unknown, 0 }
+            );
+        }
+    }
+
+private:
+    std::function<void(game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)> collision_handler_{};
+};
+
+class sfml_game
+{
+public:
+    sfml_game(sf::Vector2u field_size, const std::shared_ptr<sf::RenderWindow>& render_target, const float pixels_per_meters)
+        : window_{ render_target }, pixels_per_meters_{ pixels_per_meters }
+    {
+        game_world_ = std::make_unique<game_scene>();
+        render_scene_ = std::make_unique<render_scene>(render_target);
+        physics_world_ = std::make_unique<b2World>(b2Vec2{ 0.0f, 0.0f });
+        physics_world_->SetAllowSleeping(true);
+        //physics_world.SetContinuousPhysics(true);
+        contact_listener_ = new physics_contact_listener();
+        physics_world_->SetContactListener(contact_listener_);
+        debug_draw_ = new SFMLDebugDraw(render_target, pixels_per_meters_);
+        debug_draw_->AppendFlags(b2Draw::e_shapeBit);
+        physics_world_->SetDebugDraw(debug_draw_);
+
+        contact_listener_->add_collision_handler([this](game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)
+            {
+                if (game_object_a.type == game_object_type::bullet)
+                {
+                    objects_to_delete_.insert(game_object_a.id);
+                }
+                else if (game_object_b.type == game_object_type::bullet)
+                {
+                    objects_to_delete_.insert(game_object_b.id);
+                }
+            });
+    }
+
+    ~sfml_game()
+    {
+        delete contact_listener_;
+        delete debug_draw_;
+    }
+
+public:
+    const std::unique_ptr<game_scene>& get_game_scene() const
+    {
+        return game_world_;
+    }
+
+    const std::unique_ptr<render_scene>& get_render_scene() const
+    {
+        return render_scene_;
+    }
+
+    const std::unique_ptr<b2World>& get_physics_world() const
+    {
+        return physics_world_;
+    }
+
+    void update(const float delta_time)
+    {
+        window_->clear(sf::Color::Black);
+
+        delete_game_objects();
+
+        physics_world_->Step(delta_time, 8, 3);
+        game_world_->update(delta_time);
+        render_scene_->draw_scene();
+        physics_world_->DebugDraw();
+
+        window_->display();
+    }
+
+private:
+    void delete_game_objects()
+    {
+        for (const auto& game_object_id : objects_to_delete_)
+        {
+            auto game_object = game_world_->get_game_object(game_object_id);
+            physics_world_->DestroyBody(game_object->get_physics_body());
+            game_object->free();
+            game_world_->remove_game_object(game_object);
+        }
+        objects_to_delete_.clear();
     }
+
+private:
+    float pixels_per_meters_{};
+
+    std::shared_ptr<sf::RenderWindow> window_{ nullptr };
+    std::unique_ptr<game_scene> game_world_{ nullptr };
+    std::unique_ptr<render_scene> render_scene_{ nullptr };
+    std::unique_ptr<b2World> physics_world_{ nullptr };
+    SFMLDebugDraw* debug_draw_{ nullptr };
+    physics_contact_listener* contact_listener_{ nullptr };
+
+    std::unordered_set<uuid> objects_to_delete_{};
 };
 
 int main()
@@ -378,16 +415,8 @@ int main()
     //window->setFramerateLimit(20);
 
     sf::Clock clock;
-    game_scene game;
-    render_scene root_node{window};
-    b2World physics_world{ { 0.0f, 0.0f } };
-    physics_world.SetAllowSleeping(true);
-    //physics_world.SetContinuousPhysics(true);
-    auto* contact_listener = new physics_contact_listener();
-    physics_world.SetContactListener(contact_listener);
-    SFMLDebugDraw draw{ *window, pixels_per_meters };
-    draw.AppendFlags(b2Draw::e_shapeBit);
-    physics_world.SetDebugDraw(&draw);
+
+    std::unique_ptr<sfml_game> game = std::make_unique<sfml_game>(game_field_size, window, pixels_per_meters);
 
     // <TEXTURES>
     auto tank_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/tank.png");
@@ -406,7 +435,7 @@ int main()
     const auto tank_container = std::make_shared<container>();
     tank_container->setPosition(100.0, 100.0);
     tank_container->setOrigin(static_cast<float>(tank_texture_size.x) / 2.0f, static_cast<float>(tank_texture_size.y) / 2.0f);
-    root_node.add_child(tank_container);
+    game->get_render_scene()->add_child(tank_container);
 
     const auto tank_base_sprite = std::make_shared<sprite>(tank_texture_render_data);
     tank_container->add_child(tank_base_sprite);
@@ -419,7 +448,7 @@ int main()
     b2BodyDef tank_body_def;
     tank_body_def.type = b2_dynamicBody;
     tank_body_def.position.Set(100.0f / pixels_per_meters, 100.0f / pixels_per_meters);
-    auto tank_body = physics_world.CreateBody(&tank_body_def);
+    auto tank_body = game->get_physics_world()->CreateBody(&tank_body_def);
     b2PolygonShape tank_shape;
     tank_shape.SetAsBox(
         static_cast<float>(tank_texture_size.x) / pixels_per_meters / 2,
@@ -435,7 +464,7 @@ int main()
     };
     b2BodyDef edge_body_def;
     edge_body_def.type = b2_staticBody;
-    auto edges_body = physics_world.CreateBody(&edge_body_def);
+    auto edges_body = game->get_physics_world()->CreateBody(&edge_body_def);
 
     b2EdgeShape top_edge_shape;
     top_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(bottom_right_point.x, 0.0f));
@@ -521,6 +550,11 @@ int main()
                 {
                     tank_fire = false;
                 }
+
+                if (event.key.code == sf::Keyboard::Q)
+                {
+                    tank_body->SetTransform({ 100.0f / pixels_per_meters, 100.0f / pixels_per_meters }, tank_body->GetAngle());
+                }
             }
         }
 
@@ -539,7 +573,7 @@ int main()
                 b2BodyDef bullet_body_def;
                 bullet_body_def.type = b2_dynamicBody;
                 bullet_body_def.position.Set(bullet_pos.x, bullet_pos.y);
-                auto bullet_body = physics_world.CreateBody(&bullet_body_def);
+                auto bullet_body = game->get_physics_world()->CreateBody(&bullet_body_def);
                 b2PolygonShape bullet_shape;
                 bullet_shape.SetAsBox(
                     static_cast<float>(bullet_texture_render_data->get_size().x) / pixels_per_meters / 2,
@@ -563,8 +597,8 @@ int main()
                     static_cast<float>(bullet_texture_render_data->get_size().x) / 2.0f,
                     static_cast<float>(bullet_texture_render_data->get_size().y) / 2.0f
                 );
-                game.add_game_object(bt);
-                root_node.add_child(bt->get_render_object());
+                game->get_game_scene()->add_game_object(bt);
+                game->get_render_scene()->add_child(bt->get_render_object());
             }
         }
 
@@ -623,22 +657,15 @@ int main()
         float ph_body_rot = tank_body->GetAngle();
 
         tank_container->setPosition({ph_body_pos.x * pixels_per_meters, ph_body_pos.y * pixels_per_meters});
-        tank_container->setRotation(std::fmod(
-            static_cast<float>(static_cast<double>(ph_body_rot) * 180.0f / std::numbers::pi), 360.0f)
-        );
+        tank_container->setRotation(std::fmod(rad_to_deg(ph_body_rot), 360.0f));
         tank_tower_sprite->setRotation(tower_rotation);
 
-        window->clear(sf::Color::Black);
-
-        physics_world.Step(delta_time, 8, 3);
-        game.update(delta_time);
-        root_node.draw_scene();
-        physics_world.DebugDraw();
-
-        window->display();
+        game->update(delta_time);
     }
 
-    physics_world.DestroyBody(tank_body);
+    game->get_physics_world()->DestroyBody(edges_body);
+    game->get_physics_world()->DestroyBody(tank_body);
+
     tank_body = nullptr;
 
     return 0;
diff --git a/battle_tanks/client/headers/container.hpp b/battle_tanks/client/headers/container.hpp
new file mode 100644
index 0000000..c699215
--- /dev/null
+++ b/battle_tanks/client/headers/container.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include <SFML/Graphics/RenderTarget.hpp>
+#include "SFML/Graphics/Transform.hpp"
+
+#include "render_object.hpp"
+
+class container : public render_object
+{
+public:
+    virtual ~container() override = default;
+
+public:
+    void add_child(const std::shared_ptr<render_object>& child);
+
+    void remove_child(const std::shared_ptr<render_object>& child);
+    void remove_child(const render_object* const child);
+
+protected:
+    void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override;
+
+protected:
+    std::vector<std::shared_ptr<render_object>> children_{};
+};
\ No newline at end of file
diff --git a/battle_tanks/client/headers/debug_draw.hpp b/battle_tanks/client/headers/debug_draw.hpp
index 590448f..55db2db 100644
--- a/battle_tanks/client/headers/debug_draw.hpp
+++ b/battle_tanks/client/headers/debug_draw.hpp
@@ -1,16 +1,23 @@
 #pragma once
 
+#include <memory>
+
+#include <SFML/Graphics/RenderTarget.hpp>
+#include <SFML/System/Vector2.hpp>
+#include <SFML/Graphics/Color.hpp>
+#include <SFML/Config.hpp>
+
 #include <Box2D/Box2D.h>
 
 class SFMLDebugDraw : public b2Draw
 {
 private:
-	sf::RenderWindow* m_window;
+	std::shared_ptr<sf::RenderTarget> m_window;
 	//float m_pixels_per_meter;
 	static float pixels_per_meter;
 
 public:
-	SFMLDebugDraw(sf::RenderWindow& window, float pixels_per_meters);
+	SFMLDebugDraw(const std::shared_ptr<sf::RenderTarget>& window, float pixels_per_meters);
 
 	/// Convert Box2D's OpenGL style color definition[0-1] to SFML's color definition[0-255], with optional alpha byte[Default - opaque]
 	static sf::Color GLColorToSFML(const b2Color& color, sf::Uint8 alpha = 255)
diff --git a/battle_tanks/client/headers/render_object.hpp b/battle_tanks/client/headers/render_object.hpp
new file mode 100644
index 0000000..d1a6bdf
--- /dev/null
+++ b/battle_tanks/client/headers/render_object.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <memory>
+#include <SFML/Graphics/Transformable.hpp>
+#include <SFML/Graphics/Transform.hpp>
+#include <SFML/Graphics/RenderTarget.hpp>
+
+class container;
+
+class render_object : public sf::Transformable
+{
+    friend container;
+public:
+    virtual ~render_object() override = default;
+
+public:
+    virtual void free();
+
+    //void set_parent(const std::shared_ptr<container>& parent)
+    //{
+    //    parent_ = parent;
+    //}
+
+    //std::shared_ptr<container> get_parent() const
+    //{
+    //    return parent_;
+    //}
+
+protected:
+    virtual void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const = 0;
+
+private:
+    container* parent_{ nullptr };
+};
diff --git a/battle_tanks/client/sources/container.cpp b/battle_tanks/client/sources/container.cpp
new file mode 100644
index 0000000..b0d2c0d
--- /dev/null
+++ b/battle_tanks/client/sources/container.cpp
@@ -0,0 +1,46 @@
+#include "container.hpp"
+#include "render_object.hpp"
+
+void container::add_child(const std::shared_ptr<render_object>& child)
+{
+    if (child->parent_ != nullptr)
+    {
+        child->parent_->remove_child(child);
+    }
+
+    children_.push_back(child);
+    child->parent_ = this;
+}
+
+void container::remove_child(const std::shared_ptr<render_object>& child)
+{
+    for (auto it = children_.begin(); it != children_.end(); ++it)
+    {
+        if (*it == child)
+        {
+            children_.erase(it);
+            break;
+        }
+    }
+}
+
+void container::remove_child(const render_object* const child)
+{
+    for (auto it = children_.begin(); it != children_.end(); ++it)
+    {
+        if (it->get() == child)
+        {
+            children_.erase(it);
+            break;
+        }
+    }
+}
+
+void container::draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const
+{
+    const sf::Transform transform = parent_transform * getTransform();
+    for (const auto& ch : children_)
+    {
+        ch->draw(render_target, transform);
+    }
+}
diff --git a/battle_tanks/client/sources/debug_draw.cpp b/battle_tanks/client/sources/debug_draw.cpp
index 5c7f13a..490771a 100644
--- a/battle_tanks/client/sources/debug_draw.cpp
+++ b/battle_tanks/client/sources/debug_draw.cpp
@@ -4,7 +4,7 @@
 
 float SFMLDebugDraw::pixels_per_meter = 30.f;
 
-SFMLDebugDraw::SFMLDebugDraw(sf::RenderWindow& window, float pixels_per_meters) : m_window(&window)
+SFMLDebugDraw::SFMLDebugDraw(const std::shared_ptr<sf::RenderTarget>& window, float pixels_per_meters) : m_window(window)
 {
 	pixels_per_meter = pixels_per_meters;
 }
diff --git a/battle_tanks/client/sources/render_object.cpp b/battle_tanks/client/sources/render_object.cpp
new file mode 100644
index 0000000..3988c8a
--- /dev/null
+++ b/battle_tanks/client/sources/render_object.cpp
@@ -0,0 +1,12 @@
+#include "render_object.hpp"
+
+#include "container.hpp"
+
+void render_object::free()
+{
+    if (parent_ != nullptr)
+    {
+        parent_->remove_child(this);
+        parent_ = nullptr;
+    }
+}

From 66fb928e5162cf531cdddc8d1d5359b1652c9cdb Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Fri, 22 Sep 2023 20:10:36 +0300
Subject: [PATCH 03/13] move *.cpp and *.hpp to packages

---
 battle_tanks/client/battle_tanks.cpp                        | 6 +++---
 battle_tanks/client/headers/{ => dev}/debug_draw.hpp        | 0
 battle_tanks/client/headers/{ => renderer}/container.hpp    | 0
 .../client/headers/{ => renderer}/render_object.hpp         | 0
 battle_tanks/client/sources/{ => dev}/debug_draw.cpp        | 2 +-
 battle_tanks/client/sources/{ => renderer}/container.cpp    | 4 ++--
 .../client/sources/{ => renderer}/render_object.cpp         | 4 ++--
 7 files changed, 8 insertions(+), 8 deletions(-)
 rename battle_tanks/client/headers/{ => dev}/debug_draw.hpp (100%)
 rename battle_tanks/client/headers/{ => renderer}/container.hpp (100%)
 rename battle_tanks/client/headers/{ => renderer}/render_object.hpp (100%)
 rename battle_tanks/client/sources/{ => dev}/debug_draw.cpp (99%)
 rename battle_tanks/client/sources/{ => renderer}/container.cpp (93%)
 rename battle_tanks/client/sources/{ => renderer}/render_object.cpp (65%)

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 2a9d5cc..469b80e 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -11,9 +11,9 @@
 
 #include "boost/di.hpp"
 
-#include "debug_draw.hpp"
-#include "render_object.hpp"
-#include "container.hpp"
+#include "dev/debug_draw.hpp"
+#include "renderer/render_object.hpp"
+#include "renderer/container.hpp"
 
 typedef long long unsigned uuid;
 static uuid current_uuid{ 1 };
diff --git a/battle_tanks/client/headers/debug_draw.hpp b/battle_tanks/client/headers/dev/debug_draw.hpp
similarity index 100%
rename from battle_tanks/client/headers/debug_draw.hpp
rename to battle_tanks/client/headers/dev/debug_draw.hpp
diff --git a/battle_tanks/client/headers/container.hpp b/battle_tanks/client/headers/renderer/container.hpp
similarity index 100%
rename from battle_tanks/client/headers/container.hpp
rename to battle_tanks/client/headers/renderer/container.hpp
diff --git a/battle_tanks/client/headers/render_object.hpp b/battle_tanks/client/headers/renderer/render_object.hpp
similarity index 100%
rename from battle_tanks/client/headers/render_object.hpp
rename to battle_tanks/client/headers/renderer/render_object.hpp
diff --git a/battle_tanks/client/sources/debug_draw.cpp b/battle_tanks/client/sources/dev/debug_draw.cpp
similarity index 99%
rename from battle_tanks/client/sources/debug_draw.cpp
rename to battle_tanks/client/sources/dev/debug_draw.cpp
index 490771a..1209ad6 100644
--- a/battle_tanks/client/sources/debug_draw.cpp
+++ b/battle_tanks/client/sources/dev/debug_draw.cpp
@@ -1,6 +1,6 @@
 #include "SFML/Graphics.hpp"
 
-#include "debug_draw.hpp"
+#include "dev/debug_draw.hpp"
 
 float SFMLDebugDraw::pixels_per_meter = 30.f;
 
diff --git a/battle_tanks/client/sources/container.cpp b/battle_tanks/client/sources/renderer/container.cpp
similarity index 93%
rename from battle_tanks/client/sources/container.cpp
rename to battle_tanks/client/sources/renderer/container.cpp
index b0d2c0d..df9b6f0 100644
--- a/battle_tanks/client/sources/container.cpp
+++ b/battle_tanks/client/sources/renderer/container.cpp
@@ -1,5 +1,5 @@
-#include "container.hpp"
-#include "render_object.hpp"
+#include "renderer/container.hpp"
+#include "renderer/render_object.hpp"
 
 void container::add_child(const std::shared_ptr<render_object>& child)
 {
diff --git a/battle_tanks/client/sources/render_object.cpp b/battle_tanks/client/sources/renderer/render_object.cpp
similarity index 65%
rename from battle_tanks/client/sources/render_object.cpp
rename to battle_tanks/client/sources/renderer/render_object.cpp
index 3988c8a..d573c35 100644
--- a/battle_tanks/client/sources/render_object.cpp
+++ b/battle_tanks/client/sources/renderer/render_object.cpp
@@ -1,6 +1,6 @@
-#include "render_object.hpp"
+#include "renderer/render_object.hpp"
+#include "renderer/container.hpp"
 
-#include "container.hpp"
 
 void render_object::free()
 {

From cc36b2c06a225b9be6a69997c475f69d779ee1d2 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Fri, 22 Sep 2023 21:57:19 +0300
Subject: [PATCH 04/13] made namespace bt, moved classes to bt::, move all
 classes from main file to their own

---
 battle_tanks/client/battle_tanks.cpp          | 418 +-----------------
 .../client/headers/game/entity/bullet.hpp     |  37 ++
 .../headers/game/entity/game_entities.hpp     |   6 +
 .../headers/game/entity/game_object.hpp       |  48 ++
 .../headers/game/entity/game_object_type.hpp  |  14 +
 .../client/headers/game/entity/game_scene.hpp |  37 ++
 .../client/headers/game/sfml_game.hpp         | 105 +++++
 .../headers/physics/collision_listener.hpp    |  61 +++
 .../headers/physics/game_object_b2d_link.hpp  |  12 +
 .../client/headers/renderer/container.hpp     |  27 +-
 .../client/headers/renderer/render_object.hpp |  55 +--
 .../client/headers/renderer/render_scene.hpp  |  29 ++
 .../client/headers/renderer/renderer.hpp      |   8 +
 .../client/headers/renderer/sprite.hpp        |  41 ++
 .../client/headers/renderer/textures.hpp      |  36 ++
 battle_tanks/client/headers/utils/math.hpp    |  25 ++
 battle_tanks/client/headers/utils/uuid.hpp    |   9 +
 .../client/sources/game/entity/bullet.cpp     |  41 ++
 .../client/sources/renderer/container.cpp     |   8 +-
 .../client/sources/renderer/render_object.cpp |   2 +-
 battle_tanks/client/sources/util/uuid.cpp     |  12 +
 21 files changed, 590 insertions(+), 441 deletions(-)
 create mode 100644 battle_tanks/client/headers/game/entity/bullet.hpp
 create mode 100644 battle_tanks/client/headers/game/entity/game_entities.hpp
 create mode 100644 battle_tanks/client/headers/game/entity/game_object.hpp
 create mode 100644 battle_tanks/client/headers/game/entity/game_object_type.hpp
 create mode 100644 battle_tanks/client/headers/game/entity/game_scene.hpp
 create mode 100644 battle_tanks/client/headers/game/sfml_game.hpp
 create mode 100644 battle_tanks/client/headers/physics/collision_listener.hpp
 create mode 100644 battle_tanks/client/headers/physics/game_object_b2d_link.hpp
 create mode 100644 battle_tanks/client/headers/renderer/render_scene.hpp
 create mode 100644 battle_tanks/client/headers/renderer/renderer.hpp
 create mode 100644 battle_tanks/client/headers/renderer/sprite.hpp
 create mode 100644 battle_tanks/client/headers/renderer/textures.hpp
 create mode 100644 battle_tanks/client/headers/utils/math.hpp
 create mode 100644 battle_tanks/client/headers/utils/uuid.hpp
 create mode 100644 battle_tanks/client/sources/game/entity/bullet.cpp
 create mode 100644 battle_tanks/client/sources/util/uuid.cpp

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 469b80e..ba502db 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -2,38 +2,17 @@
 #include <numbers>
 #include <chrono>
 #include <functional>
-#include <ranges>
-#include <unordered_map>
-#include <unordered_set>
 
-#include <SFML/Graphics.hpp>
+#include "SFML/System/Clock.hpp"
+#include "SFML/Graphics.hpp"
 #include <box2d/box2d.h>
 
-#include "boost/di.hpp"
-
-#include "dev/debug_draw.hpp"
-#include "renderer/render_object.hpp"
-#include "renderer/container.hpp"
-
-typedef long long unsigned uuid;
-static uuid current_uuid{ 1 };
-uuid generate_uuid()
-{
-    return current_uuid++;
-}
-
-float deg_to_rad(const float rotation)
-{
-    return static_cast<float>(std::numbers::pi * static_cast<double>(rotation) / 180.0);
-}
-
-float rad_to_deg(const float rotation)
-{
-    return static_cast<float>(static_cast<double>(rotation) * 180.0f / std::numbers::pi);
-}
-
-class container;
-class render_object;
+#include "utils/uuid.hpp"
+#include "utils/math.hpp"
+#include "renderer/renderer.hpp"
+#include "game/entity/game_entities.hpp"
+#include "game/sfml_game.hpp"
+#include "physics/collision_listener.hpp"
 
 enum class move_action
 {
@@ -49,363 +28,6 @@ enum rotate_action
     right,
 };
 
-enum class game_object_type : unsigned
-{
-    unknown = 0,
-    tank,
-    bullet,
-    wall,
-    brick
-};
-
-struct game_object_b2d_link
-{
-    game_object_type type{ game_object_type::unknown };
-    uuid id{ 0 };
-};
-
-class game_object
-{
-public:
-    explicit game_object(uuid id) : id_{ id }
-    {
-    }
-
-    virtual ~game_object() = default;
-
-public:
-    virtual void initialize() = 0;
-    virtual void update(float delta_time) = 0;
-    virtual void free() = 0;
-
-public:
-    uuid get_id() const
-    {
-        return id_;
-    }
-
-    const std::shared_ptr<render_object>& get_render_object() const
-    {
-        return render_object_;
-    }
-
-    b2Body* get_physics_body() const
-    {
-        return physics_body_;
-    }
-
-protected:
-    std::shared_ptr<render_object> render_object_{ nullptr };
-    b2Body* physics_body_{ nullptr };
-    uuid id_;
-};
-
-class game_scene
-{
-public:
-    void update(const float delta_time) const
-    {
-        for (const auto& game_object : game_objects_ | std::views::values)
-        {
-            game_object->update(delta_time);
-        }
-    }
-
-    void add_game_object(const std::shared_ptr<game_object>& game_object)
-    {
-        game_objects_.insert({ game_object->get_id(), game_object });
-    }
-
-    void remove_game_object(const std::shared_ptr<game_object>& game_object)
-    {
-        game_objects_.erase(game_object->get_id());
-    }
-
-    std::shared_ptr<game_object> get_game_object(const uuid id) const
-    {
-        return game_objects_.at(id);
-    }
-
-private:
-    std::unordered_map<uuid, std::shared_ptr<game_object>> game_objects_{};
-};
-
-class render_scene final : public container
-{
-public:
-    explicit render_scene(const std::shared_ptr<sf::RenderTarget>& render_target) : render_target_{ render_target }
-    {
-    }
-
-    virtual ~render_scene() override = default;
-
-public:
-    void draw_scene() const
-    {
-        container::draw(render_target_, getTransform());
-    }
-
-private:
-    std::shared_ptr<sf::RenderTarget> render_target_{ nullptr };
-};
-
-class texture_render_data
-{
-public:
-    explicit texture_render_data(const std::string& path)
-    {
-        texture_ = std::make_shared<sf::Texture>();
-        texture_->loadFromFile(path);
-        texture_->setSmooth(true);
-        texture_size_ = texture_->getSize();
-    }
-
-public:
-    std::shared_ptr<sf::Texture> get_texture() const
-    {
-        return texture_;
-    }
-
-    sf::Vector2u get_size() const
-    {
-        return texture_size_;
-    }
-
-private:
-    std::shared_ptr<sf::Texture> texture_{ nullptr };
-    sf::Vector2u texture_size_{};
-};
-
-
-class sprite : public render_object
-{
-public:
-    explicit sprite(const std::string& path)
-    {
-        texture_render_data_ = std::make_shared<texture_render_data>(path);
-        sprite_.setTexture(*texture_render_data_->get_texture());
-    }
-
-    explicit sprite(const std::shared_ptr<texture_render_data>& texture_render_data)
-    {
-        texture_render_data_ = texture_render_data;
-        sprite_.setTexture(*texture_render_data_->get_texture());
-    }
-
-    virtual ~sprite() override = default;
-
-protected:
-    void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
-    {
-        if (texture_render_data_ == nullptr)
-        {
-            return;
-        }
-        render_target->draw(sprite_, parent_transform * getTransform());
-    }
-
-private:
-    sf::Sprite sprite_{};
-    std::shared_ptr<texture_render_data> texture_render_data_{ nullptr };
-};
-
-//TODO:: create object poll for such objects
-class bullet : public game_object
-{
-public:
-    bullet(const uuid id, float velocity, const std::shared_ptr<texture_render_data>& render_data, b2Body* body) :
-        game_object(id), velocity_{ velocity }, render_data_{ render_data }
-    {
-        physics_body_ = body ;
-    }
-
-    virtual ~bullet() override = default;
-
-public:
-    virtual void initialize() override
-    {
-        render_object_ = std::make_shared<sprite>(render_data_);
-    }
-
-    virtual void update(float delta_time) override
-    {
-        if (render_object_ == nullptr || velocity_ == 0.0f)
-        {
-            return;
-        }
-
-        auto& ph_body_pos = physics_body_->GetPosition();
-        const float ph_body_rot = physics_body_->GetAngle();
-
-        render_object_->setPosition({ ph_body_pos.x * 10.0f, ph_body_pos.y * 10.0f });
-        render_object_->setRotation(std::fmod(
-            static_cast<float>(static_cast<double>(ph_body_rot) * 180.0f / std::numbers::pi), 360.0f)
-        );
-    }
-
-    virtual void free() override
-    {
-        if (render_object_ != nullptr)
-        {
-	        const auto render_object = render_object_;
-            render_object_ = nullptr;
-            render_object->free();
-        }
-    }
-
-private:
-    float velocity_{ 0.0f };
-    sf::Vector2f position_{};
-    sf::Vector2u field_size_{};
-
-    std::shared_ptr<texture_render_data> render_data_{ nullptr };
-};
-
-class physics_contact_listener final : public b2ContactListener
-{
-public:
-    physics_contact_listener()= default;
-
-    virtual ~physics_contact_listener() override
-    {
-        collision_handler_ = nullptr;
-    }
-
-public:
-
-    void add_collision_handler(const std::function<void(game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)>& collision_handler)
-    {
-        collision_handler_ = collision_handler;
-    }
-
-    void BeginContact(b2Contact* contact) override
-    {
-        b2Fixture* fixture_a = contact->GetFixtureA();
-        b2Fixture* fixture_b = contact->GetFixtureB();
-
-        b2Body* body_a = fixture_a->GetBody();
-        b2Body* body_b = fixture_b->GetBody();
-        const b2BodyUserData user_data_a = body_a->GetUserData();
-        const b2BodyUserData user_data_b = body_b->GetUserData();
-
-        const game_object_b2d_link* link_a{ nullptr };
-        const game_object_b2d_link* link_b{ nullptr };
-
-        if (user_data_a.pointer != 0)
-        {
-            link_a = reinterpret_cast<game_object_b2d_link*>(user_data_a.pointer);
-        }
-
-        if (user_data_b.pointer != 0)
-        {
-            link_b = reinterpret_cast<game_object_b2d_link*>(user_data_b.pointer);
-        }
-
-        if (collision_handler_)
-        {
-            collision_handler_(
-                link_a != nullptr ? *link_a : game_object_b2d_link{ game_object_type::unknown, 0 },
-                link_b != nullptr ? *link_b : game_object_b2d_link{ game_object_type::unknown, 0 }
-            );
-        }
-    }
-
-private:
-    std::function<void(game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)> collision_handler_{};
-};
-
-class sfml_game
-{
-public:
-    sfml_game(sf::Vector2u field_size, const std::shared_ptr<sf::RenderWindow>& render_target, const float pixels_per_meters)
-        : window_{ render_target }, pixels_per_meters_{ pixels_per_meters }
-    {
-        game_world_ = std::make_unique<game_scene>();
-        render_scene_ = std::make_unique<render_scene>(render_target);
-        physics_world_ = std::make_unique<b2World>(b2Vec2{ 0.0f, 0.0f });
-        physics_world_->SetAllowSleeping(true);
-        //physics_world.SetContinuousPhysics(true);
-        contact_listener_ = new physics_contact_listener();
-        physics_world_->SetContactListener(contact_listener_);
-        debug_draw_ = new SFMLDebugDraw(render_target, pixels_per_meters_);
-        debug_draw_->AppendFlags(b2Draw::e_shapeBit);
-        physics_world_->SetDebugDraw(debug_draw_);
-
-        contact_listener_->add_collision_handler([this](game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)
-            {
-                if (game_object_a.type == game_object_type::bullet)
-                {
-                    objects_to_delete_.insert(game_object_a.id);
-                }
-                else if (game_object_b.type == game_object_type::bullet)
-                {
-                    objects_to_delete_.insert(game_object_b.id);
-                }
-            });
-    }
-
-    ~sfml_game()
-    {
-        delete contact_listener_;
-        delete debug_draw_;
-    }
-
-public:
-    const std::unique_ptr<game_scene>& get_game_scene() const
-    {
-        return game_world_;
-    }
-
-    const std::unique_ptr<render_scene>& get_render_scene() const
-    {
-        return render_scene_;
-    }
-
-    const std::unique_ptr<b2World>& get_physics_world() const
-    {
-        return physics_world_;
-    }
-
-    void update(const float delta_time)
-    {
-        window_->clear(sf::Color::Black);
-
-        delete_game_objects();
-
-        physics_world_->Step(delta_time, 8, 3);
-        game_world_->update(delta_time);
-        render_scene_->draw_scene();
-        physics_world_->DebugDraw();
-
-        window_->display();
-    }
-
-private:
-    void delete_game_objects()
-    {
-        for (const auto& game_object_id : objects_to_delete_)
-        {
-            auto game_object = game_world_->get_game_object(game_object_id);
-            physics_world_->DestroyBody(game_object->get_physics_body());
-            game_object->free();
-            game_world_->remove_game_object(game_object);
-        }
-        objects_to_delete_.clear();
-    }
-
-private:
-    float pixels_per_meters_{};
-
-    std::shared_ptr<sf::RenderWindow> window_{ nullptr };
-    std::unique_ptr<game_scene> game_world_{ nullptr };
-    std::unique_ptr<render_scene> render_scene_{ nullptr };
-    std::unique_ptr<b2World> physics_world_{ nullptr };
-    SFMLDebugDraw* debug_draw_{ nullptr };
-    physics_contact_listener* contact_listener_{ nullptr };
-
-    std::unordered_set<uuid> objects_to_delete_{};
-};
-
 int main()
 {
     constexpr float pixels_per_meters{ 10.0f }; // 1 meter = 10 pixels
@@ -416,12 +38,12 @@ int main()
 
     sf::Clock clock;
 
-    std::unique_ptr<sfml_game> game = std::make_unique<sfml_game>(game_field_size, window, pixels_per_meters);
+    std::unique_ptr<bt::sfml_game> game = std::make_unique<bt::sfml_game>(game_field_size, window, pixels_per_meters);
 
     // <TEXTURES>
-    auto tank_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/tank.png");
-    auto tower_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/tower.png");
-    auto bullet_texture_render_data = std::make_shared<texture_render_data>("game_data/atlases/bullet_1.png");
+    auto tank_texture_render_data = std::make_shared<bt::texture_render_data>("game_data/atlases/tank.png");
+    auto tower_texture_render_data = std::make_shared<bt::texture_render_data>("game_data/atlases/tower.png");
+    auto bullet_texture_render_data = std::make_shared<bt::texture_render_data>("game_data/atlases/bullet_1.png");
     // </TEXTURES>
 
     // <TANK>
@@ -432,15 +54,15 @@ int main()
 
     sf::Vector2u tank_texture_size = tank_texture_render_data->get_size();
 
-    const auto tank_container = std::make_shared<container>();
+    const auto tank_container = std::make_shared<bt::container>();
     tank_container->setPosition(100.0, 100.0);
     tank_container->setOrigin(static_cast<float>(tank_texture_size.x) / 2.0f, static_cast<float>(tank_texture_size.y) / 2.0f);
     game->get_render_scene()->add_child(tank_container);
 
-    const auto tank_base_sprite = std::make_shared<sprite>(tank_texture_render_data);
+    const auto tank_base_sprite = std::make_shared<bt::sprite>(tank_texture_render_data);
     tank_container->add_child(tank_base_sprite);
 
-    const auto tank_tower_sprite = std::make_shared<sprite>(tower_texture_render_data);
+    const auto tank_tower_sprite = std::make_shared<bt::sprite>(tower_texture_render_data);
     tank_tower_sprite->setPosition(16.5f, 27.0f);
     tank_tower_sprite->setOrigin(10.0f, 67.0f);
     tank_container->add_child(tank_tower_sprite);
@@ -565,7 +187,7 @@ int main()
             if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time).count() >= 1000)
             {
                 bullet_creation_time = bullet_current_time;
-                const float bullet_rotation_rad = deg_to_rad(tank_tower_sprite->getRotation() + tank_container->getRotation());
+                const float bullet_rotation_rad = bt::deg_to_rad(tank_tower_sprite->getRotation() + tank_container->getRotation());
                 const b2Vec2 bullet_pos{
                 (tank_container->getPosition().x + 80 * std::sin(bullet_rotation_rad)) / pixels_per_meters,
                 (tank_container->getPosition().y - 80 * std::cos(bullet_rotation_rad)) / pixels_per_meters
@@ -580,8 +202,8 @@ int main()
                     static_cast<float>(bullet_texture_render_data->get_size().y) / pixels_per_meters / 2
                 );
                 bullet_body->CreateFixture(&bullet_shape, 1.0f);
-                uuid bullet_id = generate_uuid();
-                auto* bullet_link = new game_object_b2d_link{ game_object_type::bullet, bullet_id };
+                bt::uuid bullet_id = bt::generate_uuid();
+                auto* bullet_link = new bt::game_object_b2d_link{ bt::game_object_type::bullet, bullet_id };
                 bullet_body->GetUserData().pointer = reinterpret_cast<uintptr_t>(bullet_link);
 
                 auto force = b2Vec2{
@@ -591,7 +213,7 @@ int main()
                 bullet_body->SetTransform(bullet_pos, bullet_rotation_rad);
                 bullet_body->SetLinearVelocity(force);
 
-                const auto bt = std::make_shared<bullet>(bullet_id, 500.0f, bullet_texture_render_data, bullet_body);
+                const auto bt = std::make_shared<bt::bullet>(bullet_id, 500.0f, bullet_texture_render_data, bullet_body);
                 bt->initialize();
                 bt->get_render_object()->setOrigin(
                     static_cast<float>(bullet_texture_render_data->get_size().x) / 2.0f,
@@ -657,7 +279,7 @@ int main()
         float ph_body_rot = tank_body->GetAngle();
 
         tank_container->setPosition({ph_body_pos.x * pixels_per_meters, ph_body_pos.y * pixels_per_meters});
-        tank_container->setRotation(std::fmod(rad_to_deg(ph_body_rot), 360.0f));
+        tank_container->setRotation(std::fmod(bt::rad_to_deg(ph_body_rot), 360.0f));
         tank_tower_sprite->setRotation(tower_rotation);
 
         game->update(delta_time);
diff --git a/battle_tanks/client/headers/game/entity/bullet.hpp b/battle_tanks/client/headers/game/entity/bullet.hpp
new file mode 100644
index 0000000..03191f5
--- /dev/null
+++ b/battle_tanks/client/headers/game/entity/bullet.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+
+#include <SFML/System/Vector2.hpp>
+#include <box2d/b2_body.h>
+
+#include "game/entity/game_object.hpp"
+#include "renderer/textures.hpp"
+#include "utils/uuid.hpp"
+
+
+namespace bt
+{
+    //TODO:: create object poll for such objects
+    class bullet : public bt::game_object
+    {
+    public:
+        bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_render_data>& render_data, b2Body* body);
+
+        virtual ~bullet() override = default;
+
+    public:
+        virtual void initialize() override;
+
+        virtual void update(float delta_time) override;
+
+        virtual void free() override;
+
+    private:
+        float velocity_{ 0.0f };
+        sf::Vector2f position_{};
+        sf::Vector2u field_size_{};
+
+        std::shared_ptr<bt::texture_render_data> render_data_{ nullptr };
+    };
+}
diff --git a/battle_tanks/client/headers/game/entity/game_entities.hpp b/battle_tanks/client/headers/game/entity/game_entities.hpp
new file mode 100644
index 0000000..e3d4f67
--- /dev/null
+++ b/battle_tanks/client/headers/game/entity/game_entities.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "game/entity/game_object_type.hpp"
+#include "game/entity/game_object.hpp"
+#include "game/entity/bullet.hpp"
+#include "game/entity/game_scene.hpp"
\ No newline at end of file
diff --git a/battle_tanks/client/headers/game/entity/game_object.hpp b/battle_tanks/client/headers/game/entity/game_object.hpp
new file mode 100644
index 0000000..4382a30
--- /dev/null
+++ b/battle_tanks/client/headers/game/entity/game_object.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+
+#include <Box2D/b2_body.h>
+
+#include "utils/uuid.hpp"
+#include "renderer/render_object.hpp"
+
+namespace bt
+{
+    class game_object
+    {
+    public:
+        explicit game_object(const bt::uuid id) : id_{ id }
+        {
+        }
+
+        virtual ~game_object() = default;
+
+    public:
+        virtual void initialize() = 0;
+        virtual void update(float delta_time) = 0;
+        virtual void free() = 0;
+
+    public:
+        bt::uuid get_id() const
+        {
+            return id_;
+        }
+
+        const std::shared_ptr<bt::render_object>& get_render_object() const
+        {
+            return render_object_;
+        }
+
+        b2Body* get_physics_body() const
+        {
+            return physics_body_;
+        }
+
+    protected:
+        std::shared_ptr<bt::render_object> render_object_{ nullptr };
+        b2Body* physics_body_{ nullptr };
+        bt::uuid id_;
+    };
+
+}
diff --git a/battle_tanks/client/headers/game/entity/game_object_type.hpp b/battle_tanks/client/headers/game/entity/game_object_type.hpp
new file mode 100644
index 0000000..e2b96b1
--- /dev/null
+++ b/battle_tanks/client/headers/game/entity/game_object_type.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace bt
+{
+    enum class game_object_type : unsigned
+    {
+        unknown = 0,
+        tank,
+        bullet,
+        wall,
+        brick
+    };
+
+}
\ No newline at end of file
diff --git a/battle_tanks/client/headers/game/entity/game_scene.hpp b/battle_tanks/client/headers/game/entity/game_scene.hpp
new file mode 100644
index 0000000..21c8aed
--- /dev/null
+++ b/battle_tanks/client/headers/game/entity/game_scene.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <ranges>
+
+namespace bt
+{
+    class game_scene
+    {
+    public:
+        void update(const float delta_time) const
+        {
+            for (const auto& game_object : game_objects_ | std::views::values)
+            {
+                game_object->update(delta_time);
+            }
+        }
+
+        void add_game_object(const std::shared_ptr<bt::game_object>& game_object)
+        {
+            game_objects_.insert({ game_object->get_id(), game_object });
+        }
+
+        void remove_game_object(const std::shared_ptr<bt::game_object>& game_object)
+        {
+            game_objects_.erase(game_object->get_id());
+        }
+
+        std::shared_ptr<bt::game_object> get_game_object(const bt::uuid id) const
+        {
+            return game_objects_.at(id);
+        }
+
+    private:
+        std::unordered_map<bt::uuid, std::shared_ptr<bt::game_object>> game_objects_{};
+    };
+}
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
new file mode 100644
index 0000000..27fb4b9
--- /dev/null
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -0,0 +1,105 @@
+#pragma once
+
+#include <SFML/Graphics/RenderWindow.hpp>
+
+#include "unordered_set"
+#include "dev/debug_draw.hpp"
+
+#include "physics/collision_listener.hpp"
+
+
+namespace bt
+{
+    class sfml_game
+    {
+    public:
+        sfml_game(sf::Vector2u field_size, const std::shared_ptr<sf::RenderWindow>& render_target, const float pixels_per_meters)
+            : window_{ render_target }, pixels_per_meters_{ pixels_per_meters }
+        {
+            game_world_ = std::make_unique<bt::game_scene>();
+            render_scene_ = std::make_unique<bt::render_scene>(render_target);
+            physics_world_ = std::make_unique<b2World>(b2Vec2{ 0.0f, 0.0f });
+            physics_world_->SetAllowSleeping(true);
+            //physics_world.SetContinuousPhysics(true);
+            contact_listener_ = new bt::collision_listener();
+            physics_world_->SetContactListener(contact_listener_);
+            debug_draw_ = new SFMLDebugDraw(render_target, pixels_per_meters_);
+            debug_draw_->AppendFlags(b2Draw::e_shapeBit);
+            physics_world_->SetDebugDraw(debug_draw_);
+
+            contact_listener_->add_collision_handler([this](bt::game_object_b2d_link game_object_a, bt::game_object_b2d_link game_object_b)
+                {
+                    if (game_object_a.type == bt::game_object_type::bullet)
+                    {
+                        objects_to_delete_.insert(game_object_a.id);
+                    }
+                    else if (game_object_b.type == bt::game_object_type::bullet)
+                    {
+                        objects_to_delete_.insert(game_object_b.id);
+                    }
+                });
+        }
+
+        ~sfml_game()
+        {
+            delete contact_listener_;
+            delete debug_draw_;
+        }
+
+    public:
+        const std::unique_ptr<bt::game_scene>& get_game_scene() const
+        {
+            return game_world_;
+        }
+
+        const std::unique_ptr<bt::render_scene>& get_render_scene() const
+        {
+            return render_scene_;
+        }
+
+        const std::unique_ptr<b2World>& get_physics_world() const
+        {
+            return physics_world_;
+        }
+
+        void update(const float delta_time)
+        {
+            window_->clear(sf::Color::Black);
+
+            delete_game_objects();
+
+            physics_world_->Step(delta_time, 8, 3);
+            game_world_->update(delta_time);
+            render_scene_->draw_scene();
+            physics_world_->DebugDraw();
+
+            window_->display();
+        }
+
+    private:
+        void delete_game_objects()
+        {
+            for (const auto& game_object_id : objects_to_delete_)
+            {
+                auto game_object = game_world_->get_game_object(game_object_id);
+                physics_world_->DestroyBody(game_object->get_physics_body());
+                game_object->free();
+                game_world_->remove_game_object(game_object);
+            }
+            objects_to_delete_.clear();
+        }
+
+    private:
+        float pixels_per_meters_{};
+
+        std::shared_ptr<sf::RenderWindow> window_{ nullptr };
+        std::unique_ptr<bt::game_scene> game_world_{ nullptr };
+        std::unique_ptr<bt::render_scene> render_scene_{ nullptr };
+        std::unique_ptr<b2World> physics_world_{ nullptr };
+        SFMLDebugDraw* debug_draw_{ nullptr };
+        bt::collision_listener* contact_listener_{ nullptr };
+
+        std::unordered_set<bt::uuid> objects_to_delete_{};
+    };
+
+}
diff --git a/battle_tanks/client/headers/physics/collision_listener.hpp b/battle_tanks/client/headers/physics/collision_listener.hpp
new file mode 100644
index 0000000..e0e61b9
--- /dev/null
+++ b/battle_tanks/client/headers/physics/collision_listener.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <functional>
+
+#include "physics/game_object_b2d_link.hpp"
+
+namespace bt
+{
+    class collision_listener final : public b2ContactListener
+    {
+    public:
+        collision_listener() = default;
+
+        virtual ~collision_listener() override
+        {
+            collision_handler_ = nullptr;
+        }
+
+    public:
+
+        void add_collision_handler(const std::function<void(game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)>& collision_handler)
+        {
+            collision_handler_ = collision_handler;
+        }
+
+        void BeginContact(b2Contact* contact) override
+        {
+            b2Fixture* fixture_a = contact->GetFixtureA();
+            b2Fixture* fixture_b = contact->GetFixtureB();
+
+            b2Body* body_a = fixture_a->GetBody();
+            b2Body* body_b = fixture_b->GetBody();
+            const b2BodyUserData user_data_a = body_a->GetUserData();
+            const b2BodyUserData user_data_b = body_b->GetUserData();
+
+            const game_object_b2d_link* link_a{ nullptr };
+            const game_object_b2d_link* link_b{ nullptr };
+
+            if (user_data_a.pointer != 0)
+            {
+                link_a = reinterpret_cast<game_object_b2d_link*>(user_data_a.pointer);
+            }
+
+            if (user_data_b.pointer != 0)
+            {
+                link_b = reinterpret_cast<game_object_b2d_link*>(user_data_b.pointer);
+            }
+
+            if (collision_handler_)
+            {
+                collision_handler_(
+                    link_a != nullptr ? *link_a : game_object_b2d_link{ game_object_type::unknown, 0 },
+                    link_b != nullptr ? *link_b : game_object_b2d_link{ game_object_type::unknown, 0 }
+                );
+            }
+        }
+
+    private:
+        std::function<void(game_object_b2d_link game_object_a, game_object_b2d_link game_object_b)> collision_handler_{};
+    };
+}
\ No newline at end of file
diff --git a/battle_tanks/client/headers/physics/game_object_b2d_link.hpp b/battle_tanks/client/headers/physics/game_object_b2d_link.hpp
new file mode 100644
index 0000000..fb37d85
--- /dev/null
+++ b/battle_tanks/client/headers/physics/game_object_b2d_link.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "game/entity/game_object_type.hpp"
+
+namespace bt
+{
+    struct game_object_b2d_link
+    {
+        game_object_type type{ game_object_type::unknown };
+        bt::uuid id{ 0 };
+    };
+}
diff --git a/battle_tanks/client/headers/renderer/container.hpp b/battle_tanks/client/headers/renderer/container.hpp
index c699215..61c5164 100644
--- a/battle_tanks/client/headers/renderer/container.hpp
+++ b/battle_tanks/client/headers/renderer/container.hpp
@@ -8,20 +8,23 @@
 
 #include "render_object.hpp"
 
-class container : public render_object
+namespace bt
 {
-public:
-    virtual ~container() override = default;
+    class container : public render_object
+    {
+    public:
+        virtual ~container() override = default;
 
-public:
-    void add_child(const std::shared_ptr<render_object>& child);
+    public:
+        void add_child(const std::shared_ptr<render_object>& child);
 
-    void remove_child(const std::shared_ptr<render_object>& child);
-    void remove_child(const render_object* const child);
+        void remove_child(const std::shared_ptr<render_object>& child);
+        void remove_child(const render_object* const child);
 
-protected:
-    void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override;
+    protected:
+        void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override;
 
-protected:
-    std::vector<std::shared_ptr<render_object>> children_{};
-};
\ No newline at end of file
+    protected:
+        std::vector<std::shared_ptr<render_object>> children_{};
+    };
+}
diff --git a/battle_tanks/client/headers/renderer/render_object.hpp b/battle_tanks/client/headers/renderer/render_object.hpp
index d1a6bdf..190a1bf 100644
--- a/battle_tanks/client/headers/renderer/render_object.hpp
+++ b/battle_tanks/client/headers/renderer/render_object.hpp
@@ -5,30 +5,33 @@
 #include <SFML/Graphics/Transform.hpp>
 #include <SFML/Graphics/RenderTarget.hpp>
 
-class container;
-
-class render_object : public sf::Transformable
+namespace bt
 {
-    friend container;
-public:
-    virtual ~render_object() override = default;
-
-public:
-    virtual void free();
-
-    //void set_parent(const std::shared_ptr<container>& parent)
-    //{
-    //    parent_ = parent;
-    //}
-
-    //std::shared_ptr<container> get_parent() const
-    //{
-    //    return parent_;
-    //}
-
-protected:
-    virtual void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const = 0;
-
-private:
-    container* parent_{ nullptr };
-};
+    class container;
+
+    class render_object : public sf::Transformable
+    {
+        friend bt::container;
+    public:
+        virtual ~render_object() override = default;
+
+    public:
+        virtual void free();
+
+        //void set_parent(const std::shared_ptr<container>& parent)
+        //{
+        //    parent_ = parent;
+        //}
+
+        //std::shared_ptr<container> get_parent() const
+        //{
+        //    return parent_;
+        //}
+
+    protected:
+        virtual void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const = 0;
+
+    private:
+        bt::container* parent_{ nullptr };
+    };
+}
diff --git a/battle_tanks/client/headers/renderer/render_scene.hpp b/battle_tanks/client/headers/renderer/render_scene.hpp
new file mode 100644
index 0000000..9110a49
--- /dev/null
+++ b/battle_tanks/client/headers/renderer/render_scene.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+
+#include <SFML/Graphics/RenderTarget.hpp>
+
+#include "renderer/container.hpp"
+
+namespace bt
+{
+    class render_scene final : public bt::container
+    {
+    public:
+        explicit render_scene(const std::shared_ptr<sf::RenderTarget>& render_target) : render_target_{ render_target }
+        {
+        }
+
+        virtual ~render_scene() override = default;
+
+    public:
+        void draw_scene() const
+        {
+            bt::container::draw(render_target_, getTransform());
+        }
+
+    private:
+        std::shared_ptr<sf::RenderTarget> render_target_{ nullptr };
+    };
+}
\ No newline at end of file
diff --git a/battle_tanks/client/headers/renderer/renderer.hpp b/battle_tanks/client/headers/renderer/renderer.hpp
new file mode 100644
index 0000000..ee3e489
--- /dev/null
+++ b/battle_tanks/client/headers/renderer/renderer.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "renderer/textures.hpp"
+
+#include "renderer/render_object.hpp"
+#include "renderer/container.hpp"
+#include "renderer/sprite.hpp"
+#include "renderer/render_scene.hpp"
diff --git a/battle_tanks/client/headers/renderer/sprite.hpp b/battle_tanks/client/headers/renderer/sprite.hpp
new file mode 100644
index 0000000..b968e6c
--- /dev/null
+++ b/battle_tanks/client/headers/renderer/sprite.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <SFML/Graphics/Sprite.hpp>
+
+#include "renderer/textures.hpp"
+#include "renderer/render_object.hpp"
+
+namespace bt
+{
+    class sprite : public bt::render_object
+    {
+    public:
+        explicit sprite(const std::string& path)
+        {
+            texture_render_data_ = std::make_shared<texture_render_data>(path);
+            sprite_.setTexture(*texture_render_data_->get_texture());
+        }
+
+        explicit sprite(const std::shared_ptr<texture_render_data>& texture_render_data)
+        {
+            texture_render_data_ = texture_render_data;
+            sprite_.setTexture(*texture_render_data_->get_texture());
+        }
+
+        virtual ~sprite() override = default;
+
+    protected:
+        void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
+        {
+            if (texture_render_data_ == nullptr)
+            {
+                return;
+            }
+            render_target->draw(sprite_, parent_transform * getTransform());
+        }
+
+    private:
+        sf::Sprite sprite_{};
+        std::shared_ptr<texture_render_data> texture_render_data_{ nullptr };
+    };
+}
diff --git a/battle_tanks/client/headers/renderer/textures.hpp b/battle_tanks/client/headers/renderer/textures.hpp
new file mode 100644
index 0000000..9d83b71
--- /dev/null
+++ b/battle_tanks/client/headers/renderer/textures.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include <SFML/Graphics/Texture.hpp>
+
+namespace bt
+{
+    class texture_render_data
+    {
+    public:
+        explicit texture_render_data(const std::string& path)
+        {
+            texture_ = std::make_shared<sf::Texture>();
+            texture_->loadFromFile(path);
+            texture_->setSmooth(true);
+            texture_size_ = texture_->getSize();
+        }
+
+    public:
+        std::shared_ptr<sf::Texture> get_texture() const
+        {
+            return texture_;
+        }
+
+        sf::Vector2u get_size() const
+        {
+            return texture_size_;
+        }
+
+    private:
+        std::shared_ptr<sf::Texture> texture_{ nullptr };
+        sf::Vector2u texture_size_{};
+    };
+}
diff --git a/battle_tanks/client/headers/utils/math.hpp b/battle_tanks/client/headers/utils/math.hpp
new file mode 100644
index 0000000..c4a799f
--- /dev/null
+++ b/battle_tanks/client/headers/utils/math.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <numbers>
+#include <cmath>
+
+namespace bt
+{
+    constexpr float deg_to_rad_multiplier = static_cast<float>(std::numbers::pi / 180.0);
+    constexpr float rad_to_deg_multiplier = static_cast<float>(180.0 / std::numbers::pi);
+
+    inline float deg_to_rad(const float rotation)
+    {
+        return deg_to_rad_multiplier * rotation;
+    }
+
+    inline float rad_to_deg(const float rotation)
+    {
+        return rad_to_deg_multiplier * rotation;
+    }
+
+    inline float rad_to_deg_360(const float rotation)
+    {
+        return std::fmod(rad_to_deg(rotation), 360);
+    }
+}
\ No newline at end of file
diff --git a/battle_tanks/client/headers/utils/uuid.hpp b/battle_tanks/client/headers/utils/uuid.hpp
new file mode 100644
index 0000000..6529300
--- /dev/null
+++ b/battle_tanks/client/headers/utils/uuid.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+namespace bt
+{
+    typedef long long unsigned uuid;
+
+    uuid generate_uuid();
+
+}
diff --git a/battle_tanks/client/sources/game/entity/bullet.cpp b/battle_tanks/client/sources/game/entity/bullet.cpp
new file mode 100644
index 0000000..a2ddc0d
--- /dev/null
+++ b/battle_tanks/client/sources/game/entity/bullet.cpp
@@ -0,0 +1,41 @@
+#include <box2d/b2_math.h>
+
+#include "game/entity/bullet.hpp"
+#include "renderer/sprite.hpp"
+
+#include "utils/math.hpp"
+
+bt::bullet::bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_render_data>& render_data, b2Body* body) :
+    bt::game_object(id), velocity_{ velocity }, render_data_{ render_data }
+{
+    physics_body_ = body;
+}
+
+void bt::bullet::initialize()
+{
+    render_object_ = std::make_shared<bt::sprite>(render_data_);
+}
+
+void bt::bullet::update(float delta_time)
+{
+    if (render_object_ == nullptr || velocity_ == 0.0f)
+    {
+        return;
+    }
+
+    auto& ph_body_pos = physics_body_->GetPosition();
+    const float ph_body_rot = physics_body_->GetAngle();
+
+    render_object_->setPosition({ ph_body_pos.x * 10.0f, ph_body_pos.y * 10.0f });
+    render_object_->setRotation(rad_to_deg_360(ph_body_rot));
+}
+
+void bt::bullet::free()
+{
+    if (render_object_ != nullptr)
+    {
+        const auto render_object = render_object_;
+        render_object_ = nullptr;
+        render_object->free();
+    }
+}
diff --git a/battle_tanks/client/sources/renderer/container.cpp b/battle_tanks/client/sources/renderer/container.cpp
index df9b6f0..4494bb2 100644
--- a/battle_tanks/client/sources/renderer/container.cpp
+++ b/battle_tanks/client/sources/renderer/container.cpp
@@ -1,7 +1,7 @@
 #include "renderer/container.hpp"
 #include "renderer/render_object.hpp"
 
-void container::add_child(const std::shared_ptr<render_object>& child)
+void bt::container::add_child(const std::shared_ptr<render_object>& child)
 {
     if (child->parent_ != nullptr)
     {
@@ -12,7 +12,7 @@ void container::add_child(const std::shared_ptr<render_object>& child)
     child->parent_ = this;
 }
 
-void container::remove_child(const std::shared_ptr<render_object>& child)
+void bt::container::remove_child(const std::shared_ptr<render_object>& child)
 {
     for (auto it = children_.begin(); it != children_.end(); ++it)
     {
@@ -24,7 +24,7 @@ void container::remove_child(const std::shared_ptr<render_object>& child)
     }
 }
 
-void container::remove_child(const render_object* const child)
+void bt::container::remove_child(const render_object* const child)
 {
     for (auto it = children_.begin(); it != children_.end(); ++it)
     {
@@ -36,7 +36,7 @@ void container::remove_child(const render_object* const child)
     }
 }
 
-void container::draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const
+void bt::container::draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const
 {
     const sf::Transform transform = parent_transform * getTransform();
     for (const auto& ch : children_)
diff --git a/battle_tanks/client/sources/renderer/render_object.cpp b/battle_tanks/client/sources/renderer/render_object.cpp
index d573c35..fab3457 100644
--- a/battle_tanks/client/sources/renderer/render_object.cpp
+++ b/battle_tanks/client/sources/renderer/render_object.cpp
@@ -2,7 +2,7 @@
 #include "renderer/container.hpp"
 
 
-void render_object::free()
+void bt::render_object::free()
 {
     if (parent_ != nullptr)
     {
diff --git a/battle_tanks/client/sources/util/uuid.cpp b/battle_tanks/client/sources/util/uuid.cpp
new file mode 100644
index 0000000..6613624
--- /dev/null
+++ b/battle_tanks/client/sources/util/uuid.cpp
@@ -0,0 +1,12 @@
+#include "utils/uuid.hpp"
+
+namespace
+{
+    bt::uuid current_uuid{ 1 };
+}
+
+
+bt::uuid bt::generate_uuid()
+{
+    return current_uuid++;
+}

From 7ba07d91cd5377460f395d20f6836b7b036b5057 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Sat, 30 Sep 2023 14:36:36 +0300
Subject: [PATCH 05/13] add server, common logic lib. tank and turret
 transformation moved to server. session waits 2 connection to start after 3
 sec.

---
 CMakeLists.txt                                |    2 +
 battle_tanks/client/CMakeLists.txt            |   14 +-
 battle_tanks/client/battle_tanks.cpp          |  409 +-
 .../client/game_data/atlases/rock_1.png       |  Bin 0 -> 3030 bytes
 .../headers/game/entity/game_entities.hpp     |    6 -
 .../game/{entity => game_objects}/bullet.hpp  |    7 +-
 .../{entity => game_objects}/game_object.hpp  |   18 +-
 .../game/game_objects/game_objects.hpp        |    6 +
 .../{entity => game_objects}/game_scene.hpp   |    2 +-
 .../game/game_objects/player_game_object.hpp  |   94 +
 .../client/headers/game/sfml_game.hpp         |   43 +-
 .../client/headers/renderer/sprite.hpp        |    6 +-
 .../client/headers/renderer/textures.hpp      |  158 +-
 .../client/network/client_connection.hpp      |   25 +
 .../client/network/connection_service.hpp     |   39 +
 .../client/sources/game/entity/bullet.cpp     |   41 -
 .../sources/game/game_objects/bullet.cpp      |   42 +
 battle_tanks/common_logic/CMakeLists.txt      |   27 +
 .../headers/data_structures/ts_deque.hpp      |  104 +
 .../game/entity/game_entity_constants.hpp     |   17 +
 .../game/entity/game_object_entity.hpp        |   64 +
 .../headers/game/entity/game_object_type.hpp  |    0
 .../game/entity/phy_game_object_entity.hpp    |   45 +
 .../game/entity/player_game_object_entity.hpp |  123 +
 .../game_object_frame_restorer.hpp            |   14 +
 .../game_object_frame_restorer_packet.hpp     |   32 +
 .../headers/game/player_action_controller.hpp |  118 +
 .../common_logic/headers/network/commands.hpp |  282 ++
 .../headers/network/connection_base.hpp       |  107 +
 .../headers/network/player_actions.hpp        |   23 +
 .../headers/physics/collision_listener.hpp    |    2 +
 .../headers/physics/game_object_b2d_link.hpp  |    1 +
 .../headers/physics/physics_body_factory.hpp  |   36 +
 .../headers/utils/math.hpp                    |    0
 .../headers/utils/uuid.hpp                    |    3 +-
 .../sources/util/uuid.cpp                     |    0
 battle_tanks/server/CMakeLists.txt            |   25 +
 battle_tanks/server/battle_tanks_server.cpp   |   13 +
 battle_tanks/server/headers/game_server.hpp   |  195 +
 battle_tanks/server/headers/game_session.hpp  |  268 ++
 .../server/headers/network/network_server.hpp |  219 ++
 .../headers/network/server_connection.hpp     |   28 +
 external/headers/boost/di.hpp                 | 3355 -----------------
 43 files changed, 2423 insertions(+), 3590 deletions(-)
 create mode 100644 battle_tanks/client/game_data/atlases/rock_1.png
 delete mode 100644 battle_tanks/client/headers/game/entity/game_entities.hpp
 rename battle_tanks/client/headers/game/{entity => game_objects}/bullet.hpp (74%)
 rename battle_tanks/client/headers/game/{entity => game_objects}/game_object.hpp (60%)
 create mode 100644 battle_tanks/client/headers/game/game_objects/game_objects.hpp
 rename battle_tanks/client/headers/game/{entity => game_objects}/game_scene.hpp (92%)
 create mode 100644 battle_tanks/client/headers/game/game_objects/player_game_object.hpp
 create mode 100644 battle_tanks/client/network/client_connection.hpp
 create mode 100644 battle_tanks/client/network/connection_service.hpp
 delete mode 100644 battle_tanks/client/sources/game/entity/bullet.cpp
 create mode 100644 battle_tanks/client/sources/game/game_objects/bullet.cpp
 create mode 100644 battle_tanks/common_logic/CMakeLists.txt
 create mode 100644 battle_tanks/common_logic/headers/data_structures/ts_deque.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
 rename battle_tanks/{client => common_logic}/headers/game/entity/game_object_type.hpp (100%)
 create mode 100644 battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer_packet.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/player_action_controller.hpp
 create mode 100644 battle_tanks/common_logic/headers/network/commands.hpp
 create mode 100644 battle_tanks/common_logic/headers/network/connection_base.hpp
 create mode 100644 battle_tanks/common_logic/headers/network/player_actions.hpp
 rename battle_tanks/{client => common_logic}/headers/physics/collision_listener.hpp (98%)
 rename battle_tanks/{client => common_logic}/headers/physics/game_object_b2d_link.hpp (88%)
 create mode 100644 battle_tanks/common_logic/headers/physics/physics_body_factory.hpp
 rename battle_tanks/{client => common_logic}/headers/utils/math.hpp (100%)
 rename battle_tanks/{client => common_logic}/headers/utils/uuid.hpp (53%)
 rename battle_tanks/{client => common_logic}/sources/util/uuid.cpp (100%)
 create mode 100644 battle_tanks/server/CMakeLists.txt
 create mode 100644 battle_tanks/server/battle_tanks_server.cpp
 create mode 100644 battle_tanks/server/headers/game_server.hpp
 create mode 100644 battle_tanks/server/headers/game_session.hpp
 create mode 100644 battle_tanks/server/headers/network/network_server.hpp
 create mode 100644 battle_tanks/server/headers/network/server_connection.hpp
 delete mode 100644 external/headers/boost/di.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e8e749d..9ddcbec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,4 +39,6 @@ add_subdirectory ("lesson_23")
 add_subdirectory ("lesson_26")
 add_subdirectory ("lesson_27")
 
+add_subdirectory ("battle_tanks/common_logic")
 add_subdirectory ("battle_tanks/client")
+add_subdirectory ("battle_tanks/server")
diff --git a/battle_tanks/client/CMakeLists.txt b/battle_tanks/client/CMakeLists.txt
index 7f7f248..80fcd3a 100644
--- a/battle_tanks/client/CMakeLists.txt
+++ b/battle_tanks/client/CMakeLists.txt
@@ -15,13 +15,15 @@ if (CMAKE_VERSION VERSION_GREATER 3.12)
   set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
 endif()
 
+target_include_directories(${PROJECT_NAME}
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/../external/headers
+        ${CMAKE_CURRENT_SOURCE_DIR}/../common_logic/headers
+)
+
 target_link_libraries(${PROJECT_NAME}
     PRIVATE
-        sfml-system
-        sfml-network
+        bt-common
         sfml-graphics
         sfml-window
-        box2d::box2d
-)
-
-target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../external/headers)
\ No newline at end of file
+)
\ No newline at end of file
diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index ba502db..d33f683 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -1,3 +1,4 @@
+#include <iostream>
 #include <cmath>
 #include <numbers>
 #include <chrono>
@@ -5,31 +6,76 @@
 
 #include "SFML/System/Clock.hpp"
 #include "SFML/Graphics.hpp"
+#include <SFML/Network.hpp>
 #include <box2d/box2d.h>
 
 #include "utils/uuid.hpp"
 #include "utils/math.hpp"
 #include "renderer/renderer.hpp"
-#include "game/entity/game_entities.hpp"
+#include "game/game_objects/player_game_object.hpp"
 #include "game/sfml_game.hpp"
+#include "game/game_objects/bullet.hpp"
 #include "physics/collision_listener.hpp"
+#include "network/client_connection.hpp"
+#include "network/connection_service.hpp"
+#include "network/player_actions.hpp"
+#include <game/game_objects/game_object_frame_restorer_packet.hpp>
 
-enum class move_action
+enum class player_game_state : unsigned int
 {
-    stop = 0,
-    forward,
-    backward,
+    unknown = 0,
+    disconnected,
+    connecting,
+    main_lobby,
+    session_lobby,
+    game_session,
 };
 
-enum rotate_action
+void create_test_rock(const std::unique_ptr<bt::sfml_game>& game, sf::Vector2f position, const std::shared_ptr<bt::texture_holder>& texture_data)
 {
-    stop = 0,
-    left,
-    right,
-};
+    const auto rock_sprite = std::make_shared<bt::sprite>(texture_data);
+    rock_sprite->setPosition(position);
+    rock_sprite->setOrigin(static_cast<float>(texture_data->get_size().x) / 2.0f, static_cast<float>(texture_data->get_size().y) / 2.0f);
+    game->get_render_scene()->add_child(rock_sprite);
+
+    b2BodyDef rock_body_def;
+    rock_body_def.type = b2_staticBody;
+    rock_body_def.position.Set(position.x / game->get_pixels_per_meters(), position.y / game->get_pixels_per_meters());
+    const auto rock_body = game->get_physics_body_factory().create_body(rock_body_def);
+    b2PolygonShape rock_shape;
+    rock_shape.SetAsBox(
+        static_cast<float>(texture_data->get_size().x) / game->get_pixels_per_meters() / 2,
+        static_cast<float>(texture_data->get_size().y) / game->get_pixels_per_meters() / 2
+    );
+    auto* fixture = rock_body->CreateFixture(&rock_shape, 1.0f);
+    b2Filter filter;
+    filter.categoryBits = 0x0002;
+    filter.maskBits = 0x8006;
+
+    fixture->SetFilterData(filter);
+
+    //bt::uuid rock_id = bt::generate_uuid();
+    //auto* rock_link = new bt::game_object_b2d_link{ bt::game_object_type::rock, rock_id };
+    //rock_body->GetUserData().pointer = reinterpret_cast<uintptr_t>(rock_link);
+
+    //const auto rock = std::make_shared<bt::rock>(rock_id, texture_data, rock_body);
+    //rock->initialize();
+    //game->get_game_scene()->add_game_object(rock);
+    //game->get_render_scene()->add_child(rock->get_render_object());
+}
 
 int main()
 {
+    auto player_state = player_game_state::disconnected;
+
+    auto commands_in = std::make_shared<ts_deque<connection_command_in>>();
+    auto connection_service = std::make_unique<bt::connection_service>(commands_in);
+    connection_service->get_connection().connect({ "localhost" }, 52000);
+
+    player_state = player_game_state::connecting;
+    std::cout << "connecting..." << std::endl;
+
+
     constexpr float pixels_per_meters{ 10.0f }; // 1 meter = 10 pixels
     const sf::Vector2u game_field_size{ 800, 600 };
 
@@ -41,43 +87,22 @@ int main()
     std::unique_ptr<bt::sfml_game> game = std::make_unique<bt::sfml_game>(game_field_size, window, pixels_per_meters);
 
     // <TEXTURES>
-    auto tank_texture_render_data = std::make_shared<bt::texture_render_data>("game_data/atlases/tank.png");
-    auto tower_texture_render_data = std::make_shared<bt::texture_render_data>("game_data/atlases/tower.png");
-    auto bullet_texture_render_data = std::make_shared<bt::texture_render_data>("game_data/atlases/bullet_1.png");
+    auto tank_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/tank.png");
+    auto tower_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/tower.png");
+    auto bullet_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/bullet_1.png");
     // </TEXTURES>
 
-    // <TANK>
-    move_action tank_move_action{};
-    rotate_action tank_rotate_action{};
-    rotate_action tower_rotate_action{};
-    bool tank_fire{ false };
 
-    sf::Vector2u tank_texture_size = tank_texture_render_data->get_size();
-
-    const auto tank_container = std::make_shared<bt::container>();
-    tank_container->setPosition(100.0, 100.0);
-    tank_container->setOrigin(static_cast<float>(tank_texture_size.x) / 2.0f, static_cast<float>(tank_texture_size.y) / 2.0f);
-    game->get_render_scene()->add_child(tank_container);
-
-    const auto tank_base_sprite = std::make_shared<bt::sprite>(tank_texture_render_data);
-    tank_container->add_child(tank_base_sprite);
-
-    const auto tank_tower_sprite = std::make_shared<bt::sprite>(tower_texture_render_data);
-    tank_tower_sprite->setPosition(16.5f, 27.0f);
-    tank_tower_sprite->setOrigin(10.0f, 67.0f);
-    tank_container->add_child(tank_tower_sprite);
-
-    b2BodyDef tank_body_def;
-    tank_body_def.type = b2_dynamicBody;
-    tank_body_def.position.Set(100.0f / pixels_per_meters, 100.0f / pixels_per_meters);
-    auto tank_body = game->get_physics_world()->CreateBody(&tank_body_def);
-    b2PolygonShape tank_shape;
-    tank_shape.SetAsBox(
-        static_cast<float>(tank_texture_size.x) / pixels_per_meters / 2,
-        static_cast<float>(tank_texture_size.y) / pixels_per_meters / 2
-    );
-    tank_body->CreateFixture(&tank_shape, 1.0f);
-    // </TANK>
+    auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
+    create_test_rock(game, {200.f, 200.f}, rock_texture_render_data);
+
+    bt::texture_warehouse texture_warehouse{};
+
+    bool tank_fire{ false };
+    //TODO:: start move object immediately after key pressed. don't wait server to move 
+    player_action tank_move_action{};
+    player_action tank_rotate_action{};
+    player_action tower_rotate_action{};
 
     // <EDGES>
     b2Vec2 bottom_right_point = b2Vec2{
@@ -86,23 +111,31 @@ int main()
     };
     b2BodyDef edge_body_def;
     edge_body_def.type = b2_staticBody;
-    auto edges_body = game->get_physics_world()->CreateBody(&edge_body_def);
+    auto* edges_body = game->get_physics_body_factory().create_body(edge_body_def);
+
+    b2Filter edge_filter;
+    edge_filter.categoryBits = 0x8000;
+    edge_filter.maskBits = 0x0007;
 
     b2EdgeShape top_edge_shape;
     top_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(bottom_right_point.x, 0.0f));
-    edges_body->CreateFixture(&top_edge_shape, 1.0f);
+    auto* edge_fixture = edges_body->CreateFixture(&top_edge_shape, 1.0f);
+    edge_fixture->SetFilterData(edge_filter);
 
     b2EdgeShape bottom_edge_shape;
     bottom_edge_shape.SetTwoSided(b2Vec2(0.0f, bottom_right_point.y), bottom_right_point);
-    edges_body->CreateFixture(&bottom_edge_shape, 1.0f);
+    edge_fixture = edges_body->CreateFixture(&bottom_edge_shape, 1.0f);
+    edge_fixture->SetFilterData(edge_filter);
 
     b2EdgeShape left_edge_shape;
     left_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(0.0f, bottom_right_point.y));
-    edges_body->CreateFixture(&left_edge_shape, 1.0f);
+    edge_fixture = edges_body->CreateFixture(&left_edge_shape, 1.0f);
+    edge_fixture->SetFilterData(edge_filter);
 
     b2EdgeShape right_edge_shape;
     right_edge_shape.SetTwoSided(b2Vec2(bottom_right_point.x, 0.0f), bottom_right_point);
-    edges_body->CreateFixture(&right_edge_shape, 1.0f);
+    edge_fixture = edges_body->CreateFixture(&right_edge_shape, 1.0f);
+    edge_fixture->SetFilterData(edge_filter);
     // </EDGES>
 
     auto bullet_creation_time = std::chrono::high_resolution_clock::now();
@@ -110,72 +143,208 @@ int main()
     {
         float delta_time = clock.restart().asSeconds();
 
-        sf::Event event;
-        while (window->pollEvent(event))
+        sf::Uint32 current_session{};
+
+        //<poll server commands>
+        connection_service->get_connection().update();
+        if (!commands_in->empty())
         {
-            if (event.type == sf::Event::Closed ||
-                (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Key::Escape))
+            auto [connection_id, session_id, packet_ref] = commands_in->pop_front();
+            sf::Uint32 command_id;
+            *packet_ref >> command_id;
+
+            auto server_command_id = static_cast<command_id_server>(command_id);
+
+            switch (server_command_id)
             {
-                window->close();
+            case command_id_server::connected_to_game:
+            {
+                if (player_state == player_game_state::connecting)
+                {
+                    player_state = player_game_state::main_lobby;
+                    std::cout << "connected" << std::endl;
+                }
+                break;
             }
-
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W))
+            case command_id_server::session_created:
             {
-                tank_move_action = move_action::forward;
+                if (player_state == player_game_state::main_lobby)
+                {
+                    player_state = player_game_state::session_lobby;
+                    *packet_ref >> current_session;
+                    std::cout << "session created, id: " << current_session << std::endl;
+
+                    //TODO:: parse session_id and connection_id in connection layer
+                    connection_service->get_connection().set_session_id(current_session);
+                    std::cout << "joining to session... id: " << current_session << std::endl;
+                    connection_service->send(join_session_command{ current_session });
+                }
+                break;
             }
-            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::S))
+            case command_id_server::player_joined_to_session:
             {
-                tank_move_action = move_action::backward;
+                if (player_state == player_game_state::session_lobby)
+                {
+                    std::cout << "joined to session, id: " << session_id << std::endl;
+                    //TODO:: add player to game session and display in session lobby connected players
+                }
+                break;
             }
-
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A))
+            case command_id_server::session_started:
             {
-                tank_rotate_action = left;
+                if (player_state == player_game_state::session_lobby)
+                {
+                    player_state = player_game_state::game_session;
+                    std::cout << "game session started, id: " << session_id << std::endl;
+                    *packet_ref >> session_id;
+                    //TODO:: start game world rendering and physics simulation
+                    sf::Uint32 game_objects_count;
+                    *packet_ref >> game_objects_count;
+                    for (sf::Uint32 i = 0; i < game_objects_count; ++i)
+                    {
+                        bt::uuid game_object_id;
+                        *packet_ref >> game_object_id;
+                        bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
+                        auto player = std::make_shared<bt::player_game_object>(game_object_id, texture_warehouse.load_pack(bt::textures_pack_id::tank), game->get_physics_body_factory());
+                        player->initialize();
+                        player->restore_from_frame(restorer_packet);
+                        game->add_game_object(player);
+                    }
+                }
+                break;
             }
-            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D))
+            case command_id_server::update_game_frame:
             {
-                tank_rotate_action = right;
+                if (player_state == player_game_state::game_session)
+                {
+                    sf::Uint32 game_objects_count;
+                    *packet_ref >> game_objects_count;
+                    for (sf::Uint32 i = 0; i < game_objects_count; ++i)
+                    {
+                        bt::uuid game_object_id;
+                        *packet_ref >> game_object_id;
+                        //sf::Uint32 game_object_type;
+                        //*packet_ref >> game_object_type;
+
+                        bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
+                        game->get_game_scene()->get_game_object(game_object_id)->restore_from_frame(restorer_packet);
+
+                        //if (game_object_type == static_cast<sf::Uint32>(bt::game_object_type::tank))
+                        //{
+                        //    bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
+                        //    player->restore_from_frame(restorer_packet);
+                        //}
+                        //else if (game_object_type == static_cast<sf::Uint32>(bt::game_object_type::bullet))
+                        //{
+                        //    sf::Uint32 bullet_id;
+                        //    *packet_ref >> bullet_id;
+                        //    sf::Vector2f bullet_position;
+                        //    *packet_ref >> bullet_position.x >> bullet_position.y;
+                        //    float bullet_rotation;
+                        //    *packet_ref >> bullet_rotation;
+                        //    std::cout << "bullet: " << bullet_id << " position: " << bullet_position.x << ", " << bullet_position.y
+                        //        << " rotation: " << bullet_rotation << std::endl;
+                        //}
+                    }
+                }
             }
 
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left))
-            {
-                tower_rotate_action = left;
             }
-            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right))
+        }
+        sf::Event event;
+        while (window->pollEvent(event))
+        {
+            if (event.type == sf::Event::Closed ||
+                (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Key::Escape))
             {
-                tower_rotate_action = right;
+                window->close();
             }
 
-            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Space))
+            if (player_state == player_game_state::main_lobby)
             {
-                tank_fire = true;
+                //TODO:: don't allow to repeat it until server response
+                if (event.type == sf::Event::KeyReleased)
+                {
+                    if (event.key.code == sf::Keyboard::C)
+                    {
+                        std::cout << "creating session... " << std::endl;
+                        connection_service->send(client_command{ command_id_client::create_session });
+                    }
+                    else if (event.key.code == sf::Keyboard::J)
+                    {
+                        std::cout << "joining to session... id: " << 2 << std::endl;
+                        player_state = player_game_state::session_lobby;
+                        connection_service->send(join_session_command{ 2 });
+                    }
+                }
             }
 
-            if (event.type == sf::Event::KeyReleased)
+            if (player_state == player_game_state::game_session)
             {
-                if (event.key.code == sf::Keyboard::W || event.key.code == sf::Keyboard::S)
+                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W))
                 {
-                    tank_move_action = move_action::stop;
+                    tank_move_action = player_action::move_forward;
+                    connection_service->send(player_action_command{ player_action::move_forward });
+                }
+                else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::S))
+                {
+                    tank_move_action = player_action::move_backward;
+                    connection_service->send(player_action_command{ player_action::move_backward });
                 }
 
-                if (event.key.code == sf::Keyboard::A || event.key.code == sf::Keyboard::D)
+                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A))
+                {
+                    tank_rotate_action = player_action::turn_left;
+                    connection_service->send(player_action_command{ player_action::turn_left });
+                }
+                else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D))
                 {
-                    tank_rotate_action = stop;
+                    tank_rotate_action = player_action::turn_right;
+                    connection_service->send(player_action_command{ player_action::turn_right });
                 }
 
-                if (event.key.code == sf::Keyboard::Left || event.key.code == sf::Keyboard::Right)
+                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left))
+                {
+                    tower_rotate_action = player_action::turn_turret_left;
+                    connection_service->send(player_action_command{ player_action::turn_turret_left });
+                }
+                else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right))
                 {
-                    tower_rotate_action = stop;
+                    tower_rotate_action = player_action::turn_turret_right;
+                    connection_service->send(player_action_command{ player_action::turn_turret_right });
                 }
 
-                if (event.key.code == sf::Keyboard::Space)
+                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Space))
                 {
-                    tank_fire = false;
+                    tank_fire = true;
+                    connection_service->send(player_action_command{ player_action::turret_fire });
                 }
 
-                if (event.key.code == sf::Keyboard::Q)
+                if (event.type == sf::Event::KeyReleased)
                 {
-                    tank_body->SetTransform({ 100.0f / pixels_per_meters, 100.0f / pixels_per_meters }, tank_body->GetAngle());
+                    if (event.key.code == sf::Keyboard::W || event.key.code == sf::Keyboard::S)
+                    {
+                        tank_move_action = player_action::stop_move;
+                        connection_service->send(player_action_command{ player_action::stop_move });
+                    }
+
+                    if (event.key.code == sf::Keyboard::A || event.key.code == sf::Keyboard::D)
+                    {
+                        tank_rotate_action = player_action::stop_turn;
+                        connection_service->send(player_action_command{ player_action::stop_turn });
+                    }
+
+                    if (event.key.code == sf::Keyboard::Left || event.key.code == sf::Keyboard::Right)
+                    {
+                        tower_rotate_action = player_action::stop_turn_turret;
+                        connection_service->send(player_action_command{ player_action::stop_turn_turret });
+                    }
+
+                    if (event.key.code == sf::Keyboard::Space)
+                    {
+                        tank_fire = false;
+                        connection_service->send(player_action_command{ player_action::turret_stop_fire });
+                    }
                 }
             }
         }
@@ -186,7 +355,7 @@ int main()
 
             if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time).count() >= 1000)
             {
-                bullet_creation_time = bullet_current_time;
+                /*bullet_creation_time = bullet_current_time;
                 const float bullet_rotation_rad = bt::deg_to_rad(tank_tower_sprite->getRotation() + tank_container->getRotation());
                 const b2Vec2 bullet_pos{
                 (tank_container->getPosition().x + 80 * std::sin(bullet_rotation_rad)) / pixels_per_meters,
@@ -195,17 +364,22 @@ int main()
                 b2BodyDef bullet_body_def;
                 bullet_body_def.type = b2_dynamicBody;
                 bullet_body_def.position.Set(bullet_pos.x, bullet_pos.y);
-                auto bullet_body = game->get_physics_world()->CreateBody(&bullet_body_def);
+                auto* bullet_body = game->get_physics_world()->CreateBody(&bullet_body_def);
                 b2PolygonShape bullet_shape;
                 bullet_shape.SetAsBox(
                     static_cast<float>(bullet_texture_render_data->get_size().x) / pixels_per_meters / 2,
                     static_cast<float>(bullet_texture_render_data->get_size().y) / pixels_per_meters / 2
                 );
-                bullet_body->CreateFixture(&bullet_shape, 1.0f);
+                auto* fixture = bullet_body->CreateFixture(&bullet_shape, 1.0f);
                 bt::uuid bullet_id = bt::generate_uuid();
                 auto* bullet_link = new bt::game_object_b2d_link{ bt::game_object_type::bullet, bullet_id };
                 bullet_body->GetUserData().pointer = reinterpret_cast<uintptr_t>(bullet_link);
 
+                b2Filter filter;
+                filter.categoryBits = 0x0001;
+                filter.maskBits = 0x8001;
+                fixture->SetFilterData(filter);
+
                 auto force = b2Vec2{
                     std::sin(bullet_rotation_rad) * 500.0f / pixels_per_meters,
                     -std::cos(bullet_rotation_rad) * 500.0f / pixels_per_meters
@@ -220,75 +394,14 @@ int main()
                     static_cast<float>(bullet_texture_render_data->get_size().y) / 2.0f
                 );
                 game->get_game_scene()->add_game_object(bt);
-                game->get_render_scene()->add_child(bt->get_render_object());
+                game->get_render_scene()->add_child(bt->get_render_object());*/
             }
         }
 
-        const auto rad_rotation = tank_body->GetAngle();
-        auto tower_rotation = tank_tower_sprite->getRotation();
-
-        constexpr float move_speed = 100.0;
-        if (tank_move_action == move_action::forward)
-        {
-            auto force = b2Vec2{
-                    std::sin(rad_rotation) * move_speed / pixels_per_meters,
-                    -std::cos(rad_rotation) * move_speed / pixels_per_meters
-            };
-
-            tank_body->SetLinearVelocity(force);
-        }
-        else if (tank_move_action == move_action::backward)
-        {
-            auto force = b2Vec2{
-                    -std::sin(rad_rotation) * move_speed / pixels_per_meters,
-                    std::cos(rad_rotation) * move_speed / pixels_per_meters
-            };
-
-            tank_body->SetLinearVelocity(force);
-        }
-        else
-        {
-            tank_body->SetLinearVelocity({ 0.0f, 0.0f });
-        }
-
-        constexpr float rotate_speed = 90.0f;
-        constexpr float rotate_speed_rad = static_cast<float>(std::numbers::pi) / 2.0f;
-        if (tank_rotate_action == left)
-        {
-            tank_body->SetAngularVelocity(-rotate_speed_rad);
-        }
-        else if (tank_rotate_action == right)
-        {
-            tank_body->SetAngularVelocity(rotate_speed_rad);
-        }
-        else
-        {
-            tank_body->SetAngularVelocity(0.0f);
-        }
-
-        if (tower_rotate_action == left)
-        {
-            tower_rotation -= rotate_speed * delta_time;
-        }
-        else if (tower_rotate_action == right)
-        {
-            tower_rotation += rotate_speed * delta_time;
-        }
-
-        auto& ph_body_pos = tank_body->GetPosition();
-        float ph_body_rot = tank_body->GetAngle();
-
-        tank_container->setPosition({ph_body_pos.x * pixels_per_meters, ph_body_pos.y * pixels_per_meters});
-        tank_container->setRotation(std::fmod(bt::rad_to_deg(ph_body_rot), 360.0f));
-        tank_tower_sprite->setRotation(tower_rotation);
-
         game->update(delta_time);
     }
 
-    game->get_physics_world()->DestroyBody(edges_body);
-    game->get_physics_world()->DestroyBody(tank_body);
-
-    tank_body = nullptr;
+    game->get_physics_body_factory().destroy_body(edges_body);
 
     return 0;
 }
diff --git a/battle_tanks/client/game_data/atlases/rock_1.png b/battle_tanks/client/game_data/atlases/rock_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..0880f6aea834708ac951390cff9b27e4334e1564
GIT binary patch
literal 3030
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
Ye+vYFpk7lh_W%F@07*qoM6N<$g0FIup8x;=

literal 0
HcmV?d00001

diff --git a/battle_tanks/client/headers/game/entity/game_entities.hpp b/battle_tanks/client/headers/game/entity/game_entities.hpp
deleted file mode 100644
index e3d4f67..0000000
--- a/battle_tanks/client/headers/game/entity/game_entities.hpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#include "game/entity/game_object_type.hpp"
-#include "game/entity/game_object.hpp"
-#include "game/entity/bullet.hpp"
-#include "game/entity/game_scene.hpp"
\ No newline at end of file
diff --git a/battle_tanks/client/headers/game/entity/bullet.hpp b/battle_tanks/client/headers/game/game_objects/bullet.hpp
similarity index 74%
rename from battle_tanks/client/headers/game/entity/bullet.hpp
rename to battle_tanks/client/headers/game/game_objects/bullet.hpp
index 03191f5..57ea3ae 100644
--- a/battle_tanks/client/headers/game/entity/bullet.hpp
+++ b/battle_tanks/client/headers/game/game_objects/bullet.hpp
@@ -5,7 +5,7 @@
 #include <SFML/System/Vector2.hpp>
 #include <box2d/b2_body.h>
 
-#include "game/entity/game_object.hpp"
+#include "game/game_objects/game_object.hpp"
 #include "renderer/textures.hpp"
 #include "utils/uuid.hpp"
 
@@ -16,12 +16,11 @@ namespace bt
     class bullet : public bt::game_object
     {
     public:
-        bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_render_data>& render_data, b2Body* body);
+        bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_holder>& render_data, b2Body* body);
 
         virtual ~bullet() override = default;
 
     public:
-        virtual void initialize() override;
 
         virtual void update(float delta_time) override;
 
@@ -32,6 +31,6 @@ namespace bt
         sf::Vector2f position_{};
         sf::Vector2u field_size_{};
 
-        std::shared_ptr<bt::texture_render_data> render_data_{ nullptr };
+        std::shared_ptr<bt::texture_holder> render_data_{ nullptr };
     };
 }
diff --git a/battle_tanks/client/headers/game/entity/game_object.hpp b/battle_tanks/client/headers/game/game_objects/game_object.hpp
similarity index 60%
rename from battle_tanks/client/headers/game/entity/game_object.hpp
rename to battle_tanks/client/headers/game/game_objects/game_object.hpp
index 4382a30..59de7d4 100644
--- a/battle_tanks/client/headers/game/entity/game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/game_object.hpp
@@ -2,11 +2,12 @@
 
 #include <memory>
 
-#include <Box2D/b2_body.h>
-
+#include "game/entity/game_object_entity.hpp"
+#include "game/game_objects/game_object_frame_restorer.hpp"
 #include "utils/uuid.hpp"
 #include "renderer/render_object.hpp"
 
+
 namespace bt
 {
     class game_object
@@ -19,7 +20,9 @@ namespace bt
         virtual ~game_object() = default;
 
     public:
-        virtual void initialize() = 0;
+        virtual void restore_from_frame(const bt::game_object_frame_restorer& restorer) = 0;
+        virtual void create_render_object() = 0;
+        virtual void create_game_object_entity() = 0;
         virtual void update(float delta_time) = 0;
         virtual void free() = 0;
 
@@ -34,15 +37,16 @@ namespace bt
             return render_object_;
         }
 
-        b2Body* get_physics_body() const
+        void initialize()
         {
-            return physics_body_;
+            create_game_object_entity();
+            create_render_object();
         }
 
     protected:
-        std::shared_ptr<bt::render_object> render_object_{ nullptr };
-        b2Body* physics_body_{ nullptr };
         bt::uuid id_;
+        std::shared_ptr<bt::render_object> render_object_{ nullptr };
+        std::unique_ptr<game_object_entity> game_object_entity_{ nullptr };
     };
 
 }
diff --git a/battle_tanks/client/headers/game/game_objects/game_objects.hpp b/battle_tanks/client/headers/game/game_objects/game_objects.hpp
new file mode 100644
index 0000000..bab1e5d
--- /dev/null
+++ b/battle_tanks/client/headers/game/game_objects/game_objects.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "game/entity/game_object_type.hpp"
+#include "game/game_objects/game_object.hpp"
+#include "game/game_objects/bullet.hpp"
+#include "game/game_objects/game_scene.hpp"
\ No newline at end of file
diff --git a/battle_tanks/client/headers/game/entity/game_scene.hpp b/battle_tanks/client/headers/game/game_objects/game_scene.hpp
similarity index 92%
rename from battle_tanks/client/headers/game/entity/game_scene.hpp
rename to battle_tanks/client/headers/game/game_objects/game_scene.hpp
index 21c8aed..3ee874d 100644
--- a/battle_tanks/client/headers/game/entity/game_scene.hpp
+++ b/battle_tanks/client/headers/game/game_objects/game_scene.hpp
@@ -18,7 +18,7 @@ namespace bt
 
         void add_game_object(const std::shared_ptr<bt::game_object>& game_object)
         {
-            game_objects_.insert({ game_object->get_id(), game_object });
+            game_objects_.emplace(game_object->get_id(), game_object);
         }
 
         void remove_game_object(const std::shared_ptr<bt::game_object>& game_object)
diff --git a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
new file mode 100644
index 0000000..9b1114e
--- /dev/null
+++ b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <memory>
+
+#include <SFML/System/Vector2.hpp>
+#include <box2d/b2_body.h>
+
+#include "game/entity/player_game_object_entity.hpp"
+#include "game/game_objects/game_object.hpp"
+#include "renderer/textures.hpp"
+#include "utils/uuid.hpp"
+
+
+namespace bt
+{
+    class player_game_object : public bt::game_object
+    {
+    public:
+        player_game_object(const bt::uuid id,
+            const std::shared_ptr<bt::textures_pack>& textures_pack,
+            const physics_body_factory& ph_body_factory)
+            : game_object(id), textures_pack_{ textures_pack }, ph_body_factory_(ph_body_factory)
+        {
+        }
+
+        virtual ~player_game_object() override = default;
+
+    public:
+        virtual void restore_from_frame(const bt::game_object_frame_restorer& restorer) override
+        {
+            game_object_entity_->restore_frame(restorer);
+        }
+
+        virtual void create_render_object() override
+        {
+            auto tank_texture = textures_pack_->get_texture(texture_id::tank_base);
+            auto& texture_size = tank_texture->get_size();
+            const auto tank_container = std::make_shared<bt::container>();
+            //tank_container->setPosition(100.0, 100.0);
+            tank_container->setOrigin(static_cast<float>(texture_size.x) / 2.0f, static_cast<float>(texture_size.y) / 2.0f);
+
+            const auto tank_base_sprite = std::make_shared<bt::sprite>(tank_texture);
+            tank_container->add_child(tank_base_sprite);
+
+            auto turret_texture = textures_pack_->get_texture(texture_id::tank_turret);
+            const auto turret_sprite = std::make_shared<bt::sprite>(turret_texture);
+            turret_sprite->setPosition(16.5f, 27.0f);
+            turret_sprite->setOrigin(10.0f, 67.0f);
+            tank_container->add_child(turret_sprite);
+
+            turret_render_object_ = turret_sprite;
+
+            render_object_ = tank_container;
+        }
+
+        virtual void create_game_object_entity() override
+        {
+            auto player_entity = std::make_unique<bt::player_game_object_entity>(get_id(), ph_body_factory_);
+            player_entity->create_phy_body();
+            game_object_entity_ = std::move(player_entity);
+        }
+
+        virtual void update(float delta_time) override
+        {
+            const auto frame = std::make_shared<player_game_object_frame>();
+            game_object_entity_->write_to_frame(frame);
+            const auto& ph_body_pos = frame->position;
+            const float ph_body_rot = frame->rotation;
+
+            render_object_->setPosition({ph_body_pos.x * physics_consts::pixels_per_meters, ph_body_pos.y * physics_consts::pixels_per_meters});
+            render_object_->setRotation(std::fmod(bt::rad_to_deg(ph_body_rot), 360.0f));
+
+            if (!turret_render_object_.expired())
+            {
+	            turret_render_object_.lock()->setRotation(frame->turret_rotation);
+            }
+        }
+
+        virtual void free() override
+        {
+            
+        }
+
+    private:
+        float velocity_{ 0.0f };
+        sf::Vector2f position_{};
+        sf::Vector2u field_size_{};
+
+        std::shared_ptr<bt::textures_pack> textures_pack_;
+        const physics_body_factory& ph_body_factory_;
+
+        std::weak_ptr<bt::sprite> turret_render_object_{};
+    };
+}
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index 27fb4b9..2812cce 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -6,6 +6,8 @@
 #include "dev/debug_draw.hpp"
 
 #include "physics/collision_listener.hpp"
+#include "game_objects/game_scene.hpp"
+#include "physics/physics_body_factory.hpp"
 
 
 namespace bt
@@ -14,18 +16,18 @@ namespace bt
     {
     public:
         sfml_game(sf::Vector2u field_size, const std::shared_ptr<sf::RenderWindow>& render_target, const float pixels_per_meters)
-            : window_{ render_target }, pixels_per_meters_{ pixels_per_meters }
+            : pixels_per_meters_{ pixels_per_meters }, window_{ render_target }
         {
             game_world_ = std::make_unique<bt::game_scene>();
             render_scene_ = std::make_unique<bt::render_scene>(render_target);
-            physics_world_ = std::make_unique<b2World>(b2Vec2{ 0.0f, 0.0f });
-            physics_world_->SetAllowSleeping(true);
+            //physics_world_ = std::make_unique<b2World>(b2Vec2{ 0.0f, 0.0f });
+            physics_world_.SetAllowSleeping(true);
             //physics_world.SetContinuousPhysics(true);
-            contact_listener_ = new bt::collision_listener();
-            physics_world_->SetContactListener(contact_listener_);
+            contact_listener_ = std::make_unique<bt::collision_listener>();
+            physics_world_.SetContactListener(contact_listener_.get());
             debug_draw_ = new SFMLDebugDraw(render_target, pixels_per_meters_);
             debug_draw_->AppendFlags(b2Draw::e_shapeBit);
-            physics_world_->SetDebugDraw(debug_draw_);
+            physics_world_.SetDebugDraw(debug_draw_);
 
             contact_listener_->add_collision_handler([this](bt::game_object_b2d_link game_object_a, bt::game_object_b2d_link game_object_b)
                 {
@@ -42,11 +44,16 @@ namespace bt
 
         ~sfml_game()
         {
-            delete contact_listener_;
             delete debug_draw_;
         }
 
     public:
+        void add_game_object(const std::shared_ptr<bt::game_object>& game_object)
+        {
+            game_world_->add_game_object(game_object);
+            render_scene_->add_child(game_object->get_render_object());
+        }
+
         const std::unique_ptr<bt::game_scene>& get_game_scene() const
         {
             return game_world_;
@@ -57,9 +64,14 @@ namespace bt
             return render_scene_;
         }
 
-        const std::unique_ptr<b2World>& get_physics_world() const
+        const bt::physics_body_factory& get_physics_body_factory() const
+        {
+            return physics_body_factory_;
+        }
+
+        float get_pixels_per_meters() const
         {
-            return physics_world_;
+            return pixels_per_meters_;
         }
 
         void update(const float delta_time)
@@ -68,10 +80,10 @@ namespace bt
 
             delete_game_objects();
 
-            physics_world_->Step(delta_time, 8, 3);
+            physics_world_.Step(delta_time, 8, 3);
             game_world_->update(delta_time);
             render_scene_->draw_scene();
-            physics_world_->DebugDraw();
+            physics_world_.DebugDraw();
 
             window_->display();
         }
@@ -79,14 +91,14 @@ namespace bt
     private:
         void delete_game_objects()
         {
-            for (const auto& game_object_id : objects_to_delete_)
+            /*for (const auto& game_object_id : objects_to_delete_)
             {
                 auto game_object = game_world_->get_game_object(game_object_id);
                 physics_world_->DestroyBody(game_object->get_physics_body());
                 game_object->free();
                 game_world_->remove_game_object(game_object);
             }
-            objects_to_delete_.clear();
+            objects_to_delete_.clear();*/
         }
 
     private:
@@ -95,9 +107,10 @@ namespace bt
         std::shared_ptr<sf::RenderWindow> window_{ nullptr };
         std::unique_ptr<bt::game_scene> game_world_{ nullptr };
         std::unique_ptr<bt::render_scene> render_scene_{ nullptr };
-        std::unique_ptr<b2World> physics_world_{ nullptr };
+        b2World physics_world_{ b2Vec2{ 0.0f, 0.0f } };
+        bt::physics_body_factory physics_body_factory_{ &physics_world_ };
         SFMLDebugDraw* debug_draw_{ nullptr };
-        bt::collision_listener* contact_listener_{ nullptr };
+        std::unique_ptr<bt::collision_listener> contact_listener_{ nullptr };
 
         std::unordered_set<bt::uuid> objects_to_delete_{};
     };
diff --git a/battle_tanks/client/headers/renderer/sprite.hpp b/battle_tanks/client/headers/renderer/sprite.hpp
index b968e6c..5ceb67a 100644
--- a/battle_tanks/client/headers/renderer/sprite.hpp
+++ b/battle_tanks/client/headers/renderer/sprite.hpp
@@ -12,11 +12,11 @@ namespace bt
     public:
         explicit sprite(const std::string& path)
         {
-            texture_render_data_ = std::make_shared<texture_render_data>(path);
+            texture_render_data_ = std::make_shared<texture_holder>(path);
             sprite_.setTexture(*texture_render_data_->get_texture());
         }
 
-        explicit sprite(const std::shared_ptr<texture_render_data>& texture_render_data)
+        explicit sprite(const std::shared_ptr<texture_holder>& texture_render_data)
         {
             texture_render_data_ = texture_render_data;
             sprite_.setTexture(*texture_render_data_->get_texture());
@@ -36,6 +36,6 @@ namespace bt
 
     private:
         sf::Sprite sprite_{};
-        std::shared_ptr<texture_render_data> texture_render_data_{ nullptr };
+        std::shared_ptr<texture_holder> texture_render_data_{ nullptr };
     };
 }
diff --git a/battle_tanks/client/headers/renderer/textures.hpp b/battle_tanks/client/headers/renderer/textures.hpp
index 9d83b71..9615733 100644
--- a/battle_tanks/client/headers/renderer/textures.hpp
+++ b/battle_tanks/client/headers/renderer/textures.hpp
@@ -2,15 +2,30 @@
 
 #include <string>
 #include <memory>
+#include <unordered_map>
 
 #include <SFML/Graphics/Texture.hpp>
 
 namespace bt
 {
-    class texture_render_data
+    enum class texture_id
+    {
+        unknown = 0,
+        tank_base = 1,
+        tank_turret = 2,
+        bullet = 3,
+    };
+
+    enum class textures_pack_id
+    {
+        unknown = 0,
+        tank = 1,
+    };
+
+    class texture_holder
     {
     public:
-        explicit texture_render_data(const std::string& path)
+        explicit texture_holder(const std::string& path)
         {
             texture_ = std::make_shared<sf::Texture>();
             texture_->loadFromFile(path);
@@ -24,7 +39,7 @@ namespace bt
             return texture_;
         }
 
-        sf::Vector2u get_size() const
+        const sf::Vector2u& get_size() const
         {
             return texture_size_;
         }
@@ -33,4 +48,141 @@ namespace bt
         std::shared_ptr<sf::Texture> texture_{ nullptr };
         sf::Vector2u texture_size_{};
     };
+
+    class texture_loader
+    {
+    public:
+        virtual ~texture_loader() = default;
+    public:
+        virtual std::shared_ptr<texture_holder> load_texture(texture_id id) = 0;
+    };
+
+    class textures_pack
+    {
+    public:
+        textures_pack(const bt::textures_pack_id id, const std::vector<texture_id>& textures_ids, const std::shared_ptr<texture_loader>& loader)
+            : id_{ id }, textures_ids_{ textures_ids }, loader_{ loader }
+        {
+        }
+
+        void load_pack()
+        {
+            for (const auto& texture_id : textures_ids_)
+            {
+                loaded_textures_.emplace(texture_id, loader_->load_texture(texture_id));
+            }
+        }
+
+        std::shared_ptr<texture_holder> get_texture(const texture_id id)
+        {
+            if (!loaded_textures_.contains(id))
+            {
+                return nullptr;
+            }
+            return loaded_textures_.at(id);
+        }
+
+        bool has_texture(const texture_id id) const
+        {
+            return loaded_textures_.contains(id);
+        }
+
+    public:
+        textures_pack_id get_id() const
+        {
+            return id_;
+        }
+
+    private:
+        bt::textures_pack_id id_{ bt::textures_pack_id::unknown };
+        std::vector<texture_id> textures_ids_{};
+        std::shared_ptr<texture_loader> loader_{ nullptr };
+        std::unordered_map<texture_id, std::shared_ptr<texture_holder>> loaded_textures_{};
+    };
+
+    class texture_warehouse : public texture_loader
+    {
+    public:
+        texture_warehouse() = default;
+        virtual ~texture_warehouse() override = default;
+
+    public:
+        virtual std::shared_ptr<texture_holder> load_texture(texture_id id) override
+        {
+            if (!loaded_textures_.contains(id))
+            {
+                loaded_textures_.emplace(id, std::make_shared<texture_holder>(get_texture_path(id)));
+            }
+            return loaded_textures_.at(id);
+        }
+
+    public:
+        std::shared_ptr<textures_pack> load_pack(const textures_pack_id id)
+        {
+            if (!textures_packs_.contains(id))
+            {
+                const std::vector<texture_id>& textures_ids = get_textures_ids(id);
+                textures_packs_.emplace(id, std::make_shared<textures_pack>(id, textures_ids, std::make_shared<texture_warehouse>()));
+                textures_packs_.at(id)->load_pack();
+            }
+            
+            return textures_packs_.at(id);
+        }
+
+        std::shared_ptr<texture_holder> get_texture(const textures_pack_id pack_id, const texture_id texture_id)
+        {
+            if (!textures_packs_.contains(pack_id))
+            {
+                return nullptr;
+            }
+            return textures_packs_.at(pack_id)->get_texture(texture_id);
+        }
+
+        bool has_texture(const textures_pack_id pack_id, const texture_id texture_id) const
+        {
+            if (!textures_packs_.contains(pack_id))
+            {
+                return false;
+            }
+            return textures_packs_.at(pack_id)->has_texture(texture_id);
+        }
+
+    private:
+        //TODO:: move to config file
+        static std::vector<texture_id>& get_textures_ids(const textures_pack_id id)
+        {
+            static std::vector tank_textures_ids{ texture_id::tank_base, texture_id::tank_turret };
+            static std::vector bullet_textures_ids{ texture_id::bullet };
+            static std::vector unknown_textures_ids{ texture_id::unknown };
+            switch (id)
+            {
+            case textures_pack_id::tank:
+                return tank_textures_ids;
+            case textures_pack_id::unknown:
+                return unknown_textures_ids;
+            default:
+                return unknown_textures_ids;
+            }
+        }
+
+        static std::string get_texture_path(const texture_id id)
+        {
+            switch (id)
+            {
+            case texture_id::tank_base:
+                return "game_data/atlases/tank.png";
+            case texture_id::tank_turret:
+                return "game_data/atlases/tower.png";
+            case texture_id::bullet:
+                return "game_data/atlases/bullet_1.png";
+            case texture_id::unknown:
+            default:
+                return "";
+            }
+        }
+
+    private:
+        std::unordered_map<textures_pack_id, std::shared_ptr<textures_pack>> textures_packs_{};
+        std::unordered_map<texture_id, std::shared_ptr<texture_holder>> loaded_textures_{};
+    };
 }
diff --git a/battle_tanks/client/network/client_connection.hpp b/battle_tanks/client/network/client_connection.hpp
new file mode 100644
index 0000000..87d517e
--- /dev/null
+++ b/battle_tanks/client/network/client_connection.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "network/commands.hpp"
+#include "network/connection_base.hpp"
+
+
+namespace bt
+{
+    class client_connection : public connection_base
+    {
+    public:
+        client_connection(const std::shared_ptr<ts_deque<connection_command_in>>& commands_in)
+            : connection_base{ std::make_unique<sf::TcpSocket>(), commands_in }
+        {
+        }
+
+        virtual ~client_connection() override = default;
+
+    public:
+        void connect(const sf::IpAddress& address, const unsigned short port) const
+        {
+	        socket_->connect(address, port);
+        }
+    };
+}
diff --git a/battle_tanks/client/network/connection_service.hpp b/battle_tanks/client/network/connection_service.hpp
new file mode 100644
index 0000000..0c43526
--- /dev/null
+++ b/battle_tanks/client/network/connection_service.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <SFML/Network/Packet.hpp>
+
+#include "network/client_connection.hpp"
+
+
+namespace bt
+{
+    class connection_service
+    {
+    public:
+        explicit connection_service(const std::shared_ptr<ts_deque<connection_command_in>>& commands_in)
+            : connection_(commands_in)
+        {
+            
+        }
+
+        ~connection_service() = default;
+
+    public:
+        //TODO:: encapsulate it and add events/callback for incoming commands (commands_in)
+        bt::client_connection& get_connection()
+        {
+            return connection_;
+        }
+
+        void send(const client_command& command)
+        {
+            sf::Packet packet;
+            command.write_to_packet(packet);
+
+            connection_.send(packet);
+        }
+
+    private:
+        bt::client_connection connection_;
+    };
+}
diff --git a/battle_tanks/client/sources/game/entity/bullet.cpp b/battle_tanks/client/sources/game/entity/bullet.cpp
deleted file mode 100644
index a2ddc0d..0000000
--- a/battle_tanks/client/sources/game/entity/bullet.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <box2d/b2_math.h>
-
-#include "game/entity/bullet.hpp"
-#include "renderer/sprite.hpp"
-
-#include "utils/math.hpp"
-
-bt::bullet::bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_render_data>& render_data, b2Body* body) :
-    bt::game_object(id), velocity_{ velocity }, render_data_{ render_data }
-{
-    physics_body_ = body;
-}
-
-void bt::bullet::initialize()
-{
-    render_object_ = std::make_shared<bt::sprite>(render_data_);
-}
-
-void bt::bullet::update(float delta_time)
-{
-    if (render_object_ == nullptr || velocity_ == 0.0f)
-    {
-        return;
-    }
-
-    auto& ph_body_pos = physics_body_->GetPosition();
-    const float ph_body_rot = physics_body_->GetAngle();
-
-    render_object_->setPosition({ ph_body_pos.x * 10.0f, ph_body_pos.y * 10.0f });
-    render_object_->setRotation(rad_to_deg_360(ph_body_rot));
-}
-
-void bt::bullet::free()
-{
-    if (render_object_ != nullptr)
-    {
-        const auto render_object = render_object_;
-        render_object_ = nullptr;
-        render_object->free();
-    }
-}
diff --git a/battle_tanks/client/sources/game/game_objects/bullet.cpp b/battle_tanks/client/sources/game/game_objects/bullet.cpp
new file mode 100644
index 0000000..7711560
--- /dev/null
+++ b/battle_tanks/client/sources/game/game_objects/bullet.cpp
@@ -0,0 +1,42 @@
+#include <box2d/b2_math.h>
+
+#include "game/game_objects//bullet.hpp"
+#include "renderer/sprite.hpp"
+
+#include "utils/math.hpp"
+
+bt::bullet::bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_holder>& render_data, b2Body* body) :
+    bt::game_object(id), velocity_{ velocity }, render_data_{ render_data }
+{
+
+}
+
+//void bt::bullet::initialize()
+//{
+//    render_object_ = std::make_shared<bt::sprite>(render_data_);
+//}
+
+void bt::bullet::update(float delta_time)
+{
+    //if (render_object_ == nullptr || velocity_ == 0.0f)
+    //{
+    //    return;
+    //}
+
+    //auto& ph_body_pos = physics_body_->GetPosition();
+    //const float ph_body_rot = physics_body_->GetAngle();
+
+    ////TODO 10.0f move to constants
+    //render_object_->setPosition({ ph_body_pos.x * 10.0f, ph_body_pos.y * 10.0f });
+    //render_object_->setRotation(rad_to_deg_360(ph_body_rot));
+}
+
+void bt::bullet::free()
+{
+    /*if (render_object_ != nullptr)
+    {
+        const auto render_object = render_object_;
+        render_object_ = nullptr;
+        render_object->free();
+    }*/
+}
diff --git a/battle_tanks/common_logic/CMakeLists.txt b/battle_tanks/common_logic/CMakeLists.txt
new file mode 100644
index 0000000..3376f06
--- /dev/null
+++ b/battle_tanks/common_logic/CMakeLists.txt
@@ -0,0 +1,27 @@
+project(common-logic)
+cmake_minimum_required (VERSION 3.20)
+
+set(LIB_NAME bt-common)
+
+include_directories(${PROJECT_SOURCE_DIR}/headers)
+file(GLOB_RECURSE SOURCES_CPP "./*.cpp")
+
+find_package(SFML COMPONENTS system CONFIG REQUIRED)
+find_package(box2d CONFIG REQUIRED)
+
+add_library(${LIB_NAME} STATIC ${SOURCES_CPP})
+
+if (CMAKE_VERSION VERSION_GREATER 3.12)
+    set_property(TARGET ${LIB_NAME} PROPERTY CXX_STANDARD 20)
+endif()
+
+set_target_properties(${LIB_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+
+target_include_directories(${LIB_NAME} PUBLIC include)
+
+target_link_libraries(${LIB_NAME}
+    PUBLIC
+        sfml-system
+        sfml-network
+        box2d::box2d
+)
\ No newline at end of file
diff --git a/battle_tanks/common_logic/headers/data_structures/ts_deque.hpp b/battle_tanks/common_logic/headers/data_structures/ts_deque.hpp
new file mode 100644
index 0000000..bc344ef
--- /dev/null
+++ b/battle_tanks/common_logic/headers/data_structures/ts_deque.hpp
@@ -0,0 +1,104 @@
+#pragma once
+
+#include <deque>
+#include <mutex>
+
+
+template<typename T>
+class ts_deque final
+{
+public:
+    ts_deque() = default;
+    ts_deque(const ts_deque<T>&) = delete;
+    ~ts_deque() = default;
+
+public:
+    const T& front()
+    {
+        std::scoped_lock lock(mux_queue_);
+        return deq_queue_.front();
+    }
+
+    const T& back()
+    {
+        std::scoped_lock lock(mux_queue_);
+        return deq_queue_.back();
+    }
+
+    T pop_front()
+    {
+        std::scoped_lock lock(mux_queue_);
+        auto t = std::move(deq_queue_.front());
+        deq_queue_.pop_front();
+        return t;
+    }
+
+    // Removes and returns item from back of Queue
+    T pop_back()
+    {
+        std::scoped_lock lock(mux_queue_);
+        auto t = std::move(deq_queue_.back());
+        deq_queue_.pop_back();
+        return t;
+    }
+
+    void push_back(const T& item)
+    {
+        std::scoped_lock lock(mux_queue_);
+        deq_queue_.emplace_back(std::move(item));
+
+        std::unique_lock ul(mux_blocking_);
+        cv_blocking_.notify_one();
+    }
+
+    void push_back(T&& item)
+    {
+        std::scoped_lock lock(mux_queue_);
+        deq_queue_.emplace_back(std::move(item));
+
+        std::unique_lock ul(mux_blocking_);
+        cv_blocking_.notify_one();
+    }
+
+    void push_front(const T& item)
+    {
+        std::scoped_lock lock(mux_queue_);
+        deq_queue_.emplace_front(std::move(item));
+
+        std::unique_lock ul(mux_blocking_);
+        cv_blocking_.notify_one();
+    }
+
+    bool empty()
+    {
+        std::scoped_lock lock(mux_queue_);
+        return deq_queue_.empty();
+    }
+
+    size_t count()
+    {
+        std::scoped_lock lock(mux_queue_);
+        return deq_queue_.size();
+    }
+
+    void clear()
+    {
+        std::scoped_lock lock(mux_queue_);
+        deq_queue_.clear();
+    }
+
+    void wait()
+    {
+        while (empty())
+        {
+            std::unique_lock ul(mux_blocking_);
+            cv_blocking_.wait(ul);
+        }
+    }
+
+private:
+    std::mutex mux_queue_;
+    std::deque<T> deq_queue_;
+    std::condition_variable cv_blocking_;
+    std::mutex mux_blocking_;
+};
diff --git a/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp b/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
new file mode 100644
index 0000000..26097ff
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "SFML/System/Vector2.hpp"
+
+
+namespace bt
+{
+	namespace game_entity_consts
+	{
+		static sf::Vector2f tank_size{33.0f, 54.0f};
+	}
+
+	namespace physics_consts
+	{
+		static float pixels_per_meters = 10.0f;
+	}
+}
diff --git a/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
new file mode 100644
index 0000000..257075e
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <SFML/Config.hpp>
+
+#include "game/entity/game_object_type.hpp"
+#include "game/game_objects/game_object_frame_restorer.hpp"
+#include "network/commands.hpp"
+
+
+namespace bt
+{
+    class game_object_entity
+    {
+    public:
+        game_object_entity(const sf::Uint32 id, const bt::game_object_type type) : id_{ id }, type_ { type }
+        {
+        }
+
+        virtual ~game_object_entity() = default;
+
+    public:
+        virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const = 0;
+        virtual void update(const float delta_time) = 0;
+
+    public:
+        sf::Uint32 get_id() const
+        {
+            return id_;
+        }
+
+        bt::game_object_type get_type() const
+        {
+            return type_;
+        }
+
+        [[nodiscard]]
+        std::shared_ptr<game_object_frame> get_frame() const
+        {
+            auto object_frame = create_frame();
+            set_frame_data(object_frame);
+            return object_frame;
+        }
+
+        void write_to_frame(const std::shared_ptr<game_object_frame>& object_frame) const
+        {
+            set_frame_data(object_frame);
+        }
+
+    protected:
+        [[nodiscard]]
+        virtual std::shared_ptr<game_object_frame> create_frame() const = 0;
+
+        virtual void set_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const
+        {
+            object_frame->game_object_id = id_;
+            object_frame->game_object_type = type_;
+        }
+
+    protected:
+        sf::Uint32 id_;
+        bt::game_object_type type_;
+
+    };
+}
diff --git a/battle_tanks/client/headers/game/entity/game_object_type.hpp b/battle_tanks/common_logic/headers/game/entity/game_object_type.hpp
similarity index 100%
rename from battle_tanks/client/headers/game/entity/game_object_type.hpp
rename to battle_tanks/common_logic/headers/game/entity/game_object_type.hpp
diff --git a/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
new file mode 100644
index 0000000..2d2cb11
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "SFML/Config.hpp"
+
+#include "physics/physics_body_factory.hpp"
+#include "game/entity/game_object_entity.hpp"
+
+
+namespace bt
+{
+    class phy_game_object_entity : public bt::game_object_entity
+    {
+    public:
+        phy_game_object_entity(const sf::Uint32 id, const bt::game_object_type type, const physics_body_factory& ph_body_factory)
+            : bt::game_object_entity(id, type), ph_body_factory_{ ph_body_factory }
+        {
+        }
+
+        virtual ~phy_game_object_entity() override
+        {
+            if (phy_body_ != nullptr)
+            {
+                ph_body_factory_.destroy_body(phy_body_);
+                phy_body_ = nullptr;
+            }
+        }
+
+    public:
+        virtual void create_phy_body() = 0;
+
+    protected:
+        virtual void set_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
+        {
+            bt::game_object_entity::set_frame_data(object_frame);
+            object_frame->position = { phy_body_->GetPosition().x, phy_body_->GetPosition().y };
+            object_frame->rotation = phy_body_->GetAngle();
+            object_frame->velocity = { phy_body_->GetLinearVelocity().x, phy_body_->GetLinearVelocity().y };
+            object_frame->velocity_angle = phy_body_->GetAngularVelocity();
+        }
+
+    protected:
+        b2Body* phy_body_{ nullptr };
+        const physics_body_factory& ph_body_factory_;
+    };
+}
diff --git a/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
new file mode 100644
index 0000000..37674a3
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
@@ -0,0 +1,123 @@
+#pragma once
+
+#include "box2d/b2_fixture.h"
+#include "box2d/b2_polygon_shape.h"
+#include "SFML/Config.hpp"
+
+#include "game/entity/phy_game_object_entity.hpp"
+#include "game/entity/game_entity_constants.hpp"
+#include "physics/physics_body_factory.hpp"
+#include "game/player_action_controller.hpp"
+#include "game/game_objects/game_object_frame_restorer.hpp"
+
+
+namespace bt
+{
+    class game_object_frame_restorer;
+
+    class player_game_object_entity : public bt::phy_game_object_entity
+    {
+    public:
+        player_game_object_entity(const sf::Uint32 id, const physics_body_factory& ph_body_factory)
+            : bt::phy_game_object_entity(id, game_object_type::tank, ph_body_factory)
+        {
+        }
+
+        virtual ~player_game_object_entity() override = default;
+
+    public:
+        virtual void create_phy_body() override
+        {
+            b2BodyDef tank_body_def;
+            tank_body_def.type = b2_dynamicBody;
+            //tank_body_def.position.Set(
+            //    100.0f / bt::physics_consts::pixels_per_meters,
+            //    100.0f / bt::physics_consts::pixels_per_meters
+            //);
+            phy_body_ = ph_body_factory_.create_body(tank_body_def);
+            b2PolygonShape tank_shape;
+            tank_shape.SetAsBox(
+                bt::game_entity_consts::tank_size.x / bt::physics_consts::pixels_per_meters / 2,
+                bt::game_entity_consts::tank_size.y / physics_consts::pixels_per_meters / 2
+            );
+            auto* tank_fixture = phy_body_->CreateFixture(&tank_shape, 1.0f);
+
+            b2Filter tank_filter;
+            tank_filter.categoryBits = 0x0004;
+            tank_filter.maskBits = 0x8002;
+            tank_fixture->SetFilterData(tank_filter);
+
+            action_controller_ = std::make_shared<bt::player_action_controller>(
+                phy_body_
+                //move_speed_,
+                //rotate_speed_
+            );
+        }
+
+        virtual void update(const float dt) override
+        {
+            action_controller_->update(dt);
+        }
+
+    public:
+
+        [[nodiscard]]
+        std::weak_ptr<bt::player_action_controller> get_action_controller() const
+        {
+            return action_controller_;
+        }
+
+        virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const override
+        {
+            player_game_object_frame frame{};
+            restorer.restore_frame(frame);
+
+            phy_body_->SetTransform(
+                b2Vec2(
+                    frame.position.x,
+                    frame.position.y
+                ),
+                frame.rotation
+            );
+            //phy_body_->SetLinearVelocity(
+            //    b2Vec2(
+            //        frame.velocity.x,
+            //        frame.velocity.y
+            //    )
+            //);
+            //phy_body_->SetAngularVelocity(frame.velocity_angle);
+            phy_body_->SetAwake(true);
+
+            action_controller_->set_turret_rotation(frame.turret_rotation);
+        }
+
+    protected:
+        [[nodiscard]]
+        virtual std::shared_ptr<game_object_frame> create_frame() const override
+        {
+            auto go_frame = std::make_unique<player_game_object_frame>();
+
+            go_frame->health = 100;
+            go_frame->player_score = 0;
+            go_frame->turret_rotation = action_controller_->get_turret_rotation();
+
+            return go_frame;
+        }
+
+        virtual void set_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
+        {
+            bt::phy_game_object_entity::set_frame_data(object_frame);
+            auto* go_frame = dynamic_cast<player_game_object_frame*>(object_frame.get());
+            go_frame->turret_rotation = action_controller_->get_turret_rotation();
+        }
+
+    private:
+        //TODO:: move to config
+        float move_speed_ = 100.0f;
+        float rotate_speed_ = 90.0f;
+
+        std::shared_ptr<bt::player_action_controller> action_controller_{ nullptr };
+
+    };
+}
+
diff --git a/battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer.hpp b/battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer.hpp
new file mode 100644
index 0000000..7f2c65f
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "network/commands.hpp"
+
+namespace bt
+{
+    class game_object_frame_restorer
+    {
+    public:
+        virtual ~game_object_frame_restorer() = default;
+    public:
+        virtual void restore_frame(game_object_frame& frame) const = 0;
+    };
+}
diff --git a/battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer_packet.hpp b/battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer_packet.hpp
new file mode 100644
index 0000000..26cf22e
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/game_objects/game_object_frame_restorer_packet.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "network/commands.hpp"
+#include "game/game_objects/game_object_frame_restorer.hpp"
+
+namespace bt
+{
+    class game_object_frame_restorer_packet : public game_object_frame_restorer
+    {
+    public:
+        explicit game_object_frame_restorer_packet(const std::weak_ptr<sf::Packet>& packet)
+            : packet_{ packet }
+        {
+        }
+
+        ~game_object_frame_restorer_packet() override = default;
+
+    public:
+        virtual void restore_frame(game_object_frame& frame) const override
+        {
+            if (packet_.expired())
+            {
+                return;
+            }
+            const auto packet = packet_.lock();
+            frame.read_from_packet(*packet);
+        }
+
+    private:
+        std::weak_ptr<sf::Packet> packet_;
+    };
+}
diff --git a/battle_tanks/common_logic/headers/game/player_action_controller.hpp b/battle_tanks/common_logic/headers/game/player_action_controller.hpp
new file mode 100644
index 0000000..374ee45
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/player_action_controller.hpp
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <numbers>
+
+#include "network/player_actions.hpp"
+
+namespace bt
+{
+    class player_action_controller
+    {
+    public:
+        explicit player_action_controller(b2Body* physics_body) : phy_body_(physics_body)
+        {
+        }
+
+        ~player_action_controller() = default;
+
+    public:
+        void set_move_action(const player_action action)
+        {
+            move_action_ = action;
+
+            const auto rad_rotation = phy_body_->GetAngle();
+            constexpr float move_speed = 100.0;
+            if (move_action_ == player_action::move_forward)
+            {
+                const auto force = b2Vec2{
+                        std::sin(rad_rotation) * move_speed / physics_consts::pixels_per_meters,
+                        -std::cos(rad_rotation) * move_speed / physics_consts::pixels_per_meters
+                };
+
+                phy_body_->SetLinearVelocity(force);
+            }
+            else if (move_action_ == player_action::move_backward)
+            {
+                const auto force = b2Vec2{
+                        -std::sin(rad_rotation) * move_speed / physics_consts::pixels_per_meters,
+                        std::cos(rad_rotation) * move_speed / physics_consts::pixels_per_meters
+                };
+
+                phy_body_->SetLinearVelocity(force);
+            }
+            else
+            {
+                phy_body_->SetLinearVelocity({ 0.0f, 0.0f });
+            }
+        }
+
+        void set_rotate_action(const player_action action)
+        {
+            rotate_action_ = action;
+
+            constexpr float rotate_speed_rad = static_cast<float>(std::numbers::pi) / 2.0f;
+            if (rotate_action_ == player_action::turn_left)
+            {
+                phy_body_->SetAngularVelocity(-rotate_speed_rad);
+            }
+            else if (rotate_action_ == player_action::turn_right)
+            {
+                phy_body_->SetAngularVelocity(rotate_speed_rad);
+            }
+            else
+            {
+                phy_body_->SetAngularVelocity(0.0f);
+            }
+        }
+
+        void set_turret_rotate_action(const player_action action)
+        {
+            //TODO:: add independent from game session loop delta_time
+            turret_rotate_action_ = action;
+        }
+
+        void set_turret_fire_action(const player_action action)
+        {
+            turret_fire_ = action;
+        }
+
+        float get_turret_rotation() const
+        {
+            return turret_rotation_;
+        }
+
+        void set_turret_rotation(const float rotation)
+        {
+            turret_rotation_ = rotation;
+        }
+
+        bool turret_fire()
+        {
+            
+        }
+
+        void update(const float delta_time)
+        {
+            constexpr float rotate_speed = 90.0f;
+            if (turret_rotate_action_ == player_action::turn_turret_left)
+            {
+                turret_rotation_ -= rotate_speed * delta_time;
+            }
+            else if (turret_rotate_action_ == player_action::turn_turret_right)
+            {
+                turret_rotation_ += rotate_speed * delta_time;
+            }
+        }
+
+
+    private:
+        player_action move_action_{player_action::stop_move};
+        player_action rotate_action_{player_action::stop_turn};
+        player_action turret_rotate_action_{player_action::stop_turn_turret};
+        player_action turret_fire_{player_action::turret_stop_fire};
+
+        float turret_rotation_{0.0f};
+
+        b2Body* phy_body_{ nullptr };
+    };
+}
diff --git a/battle_tanks/common_logic/headers/network/commands.hpp b/battle_tanks/common_logic/headers/network/commands.hpp
new file mode 100644
index 0000000..974e5cc
--- /dev/null
+++ b/battle_tanks/common_logic/headers/network/commands.hpp
@@ -0,0 +1,282 @@
+#pragma once
+
+#include <SFML/Config.hpp>
+#include <SFML/Network/Packet.hpp>
+#include "SFML/System/Vector2.hpp"
+
+#include "network/player_actions.hpp"
+#include "game/entity/game_object_type.hpp"
+
+
+enum class command_id_client : sf::Uint32
+{
+    unknown = 0,
+
+    create_session = 90001,
+    join_session = 90002,
+    quit_session = 90003,
+
+    player_action = 90004,
+
+    lost_connection = 90005,
+};
+
+enum class command_id_server : sf::Uint32
+{
+    unknown = 0,
+
+    connected_to_game = 10001,
+
+    session_created = 10002,
+    player_joined_to_session = 10003,
+    player_quit_from_session = 10004,
+    session_started = 10006,
+
+    update_game_frame = 10007,
+
+    delete_game_object = 10008,
+};
+
+template <class T>
+struct simple_command
+{
+    explicit simple_command(const T id)
+    {
+        command_id = id;
+    }
+    virtual ~simple_command() = default;
+
+    T command_id;
+
+    virtual void write_to_packet(sf::Packet& packet) const
+    {
+        packet << static_cast<sf::Uint32>(command_id);
+    }
+};
+
+////// TODO:: move from common to CLIENT
+struct client_command : simple_command<command_id_client>
+{
+    explicit client_command(const command_id_client id) : simple_command{ id }
+    {}
+
+    virtual ~client_command() override = default;
+};
+
+struct join_session_command final : client_command
+{
+    explicit join_session_command(const sf::Uint32 session_id)
+        : client_command(command_id_client::join_session), session_id{ session_id }
+    {
+    }
+    virtual ~join_session_command() override = default;
+
+    sf::Uint32 session_id;
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << session_id;
+    }
+};
+
+struct player_action_command : client_command
+{
+    explicit player_action_command(const player_action action_type)
+        : client_command(command_id_client::player_action)
+    {
+        action = action_type;
+    }
+    virtual ~player_action_command() override = default;
+
+    player_action action;
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << static_cast<sf::Uint32>(action);
+    }
+};
+
+
+////// TODO:: move from common to SERVER
+struct server_command : simple_command<command_id_server>
+{
+    explicit server_command(const command_id_server id) : simple_command{ id }
+    {
+    }
+    virtual ~server_command() override = default;
+};
+
+struct game_object_frame
+{
+    game_object_frame() = default;
+    virtual ~game_object_frame() = default;
+
+    sf::Uint32 game_object_id;
+    bt::game_object_type game_object_type;
+    sf::Vector2f position;
+    float rotation;
+
+    sf::Vector2f velocity;
+    float velocity_angle;
+
+    virtual void write_to_packet(sf::Packet& packet) const
+    {
+        packet << game_object_id;
+        packet << static_cast<sf::Uint32>(game_object_type);
+        packet << position.x;
+        packet << position.y;
+        packet << rotation;
+        packet << velocity.x;
+        packet << velocity.y;
+        packet << velocity_angle;
+    }
+
+    virtual void read_from_packet(sf::Packet& packet)
+    {
+        //packet >> game_object_id;
+        packet >> reinterpret_cast<sf::Uint32&>(game_object_type);
+        packet >> position.x;
+        packet >> position.y;
+        packet >> rotation;
+        packet >> velocity.x;
+        packet >> velocity.y;
+        packet >> velocity_angle;
+    }
+    
+};
+
+struct player_game_object_frame : game_object_frame
+{
+    virtual ~player_game_object_frame() override = default;
+
+    float turret_rotation;
+    sf::Uint32 health;
+    sf::Uint32 player_score;
+
+    virtual void write_to_packet(sf::Packet& packet) const override
+    {
+        game_object_frame::write_to_packet(packet);
+        packet << turret_rotation;
+        packet << health;
+        packet << player_score;
+    }
+
+    virtual void read_from_packet(sf::Packet& packet) override
+    {
+        game_object_frame::read_from_packet(packet);
+        packet >> turret_rotation;
+        packet >> health;
+        packet >> player_score;
+    }
+};
+
+struct game_frame_command final : server_command
+{
+    game_frame_command() : server_command(command_id_server::update_game_frame)
+    {
+    }
+    virtual ~game_frame_command() override = default;
+
+    std::vector<std::shared_ptr<game_object_frame>> game_objects;
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << static_cast<sf::Uint32>(game_objects.size());
+        for (const auto& game_object : game_objects)
+        {
+            game_object->write_to_packet(packet);
+        }
+    }
+};
+
+struct deleted_game_object_command final : server_command
+{
+    explicit deleted_game_object_command(const sf::Uint32 game_object_id)
+        : server_command(command_id_server::delete_game_object), game_object_id{ game_object_id }
+    {
+    }
+    virtual ~deleted_game_object_command() override = default;
+
+    sf::Uint32 game_object_id;
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << game_object_id;
+    }
+};
+
+struct session_created_command : server_command
+{
+    session_created_command() : server_command(command_id_server::session_created)
+    {
+    }
+    virtual ~session_created_command() override = default;
+
+    sf::Uint32 session_id;
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << session_id;
+    }
+};
+
+struct player_joined_to_session_command : server_command
+{
+    player_joined_to_session_command() : server_command(command_id_server::player_joined_to_session)
+    {
+    }
+    virtual ~player_joined_to_session_command() override = default;
+
+    sf::Uint32 session_id{};
+    sf::Uint32 player_id{};
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << session_id;
+        packet << player_id;
+    }
+};
+
+struct session_started_command : server_command
+{
+    session_started_command() : server_command(command_id_server::session_started)
+    {
+    }
+    virtual ~session_started_command() override = default;
+
+    sf::Uint32 session_id{};
+    std::vector<std::shared_ptr<game_object_frame>> game_objects;
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << session_id;
+        packet << static_cast<sf::Uint32>(game_objects.size());
+        for (const auto& game_object : game_objects)
+        {
+            game_object->write_to_packet(packet);
+        }
+    }
+};
+
+///////////////////////////////////
+struct connection_command_in
+{
+    sf::Uint32 connection_id;
+    //TODO:: remove
+    sf::Uint32 session_id;
+    std::shared_ptr<sf::Packet> packet;
+};
+
+struct connection_command_out
+{
+    std::vector<sf::Uint32> connection_id;
+    std::unique_ptr<server_command> command;
+};
+
diff --git a/battle_tanks/common_logic/headers/network/connection_base.hpp b/battle_tanks/common_logic/headers/network/connection_base.hpp
new file mode 100644
index 0000000..2600617
--- /dev/null
+++ b/battle_tanks/common_logic/headers/network/connection_base.hpp
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <SFML/Network.hpp>
+
+#include "network/commands.hpp"
+#include "data_structures/ts_deque.hpp"
+
+
+class connection_base
+{
+public:
+    connection_base(std::unique_ptr<sf::TcpSocket>&& socket, const std::shared_ptr<ts_deque<connection_command_in>>& commands_in)
+        : socket_{ std::move(socket) }, commands_in_{ commands_in }
+    {
+        socket_->setBlocking(false);
+    }
+
+    virtual ~connection_base() = default;
+
+public:
+    void set_session_id(const sf::Uint32 id);
+    sf::Uint32 get_session_id();
+    sf::Uint32 get_connection_id() const;
+
+    //void connect(const sf::Uint32 id);
+    void send(const sf::Packet& packet);
+    sf::Socket::Status update();
+
+protected:
+    std::unique_ptr<sf::TcpSocket> socket_;
+    ts_deque<std::unique_ptr<sf::Packet>> packages_out_;
+    std::shared_ptr<ts_deque<connection_command_in>> commands_in_{ nullptr };
+    sf::Uint32 connection_id_{};
+    sf::Uint32 session_id_{};
+};
+
+void connection_base::set_session_id(const sf::Uint32 id)
+{
+    session_id_ = id;
+}
+
+sf::Uint32 connection_base::get_session_id()
+{
+    return session_id_;
+}
+
+sf::Uint32 connection_base::get_connection_id() const
+{
+    return connection_id_;
+}
+
+//void connection::connect(const sf::Uint32 id)
+//{
+//    connection_id_ = id;
+//    sf::Packet packet{};
+//    constexpr auto command_id = static_cast<sf::Uint32>(command_id_server::connected_to_game);
+//    packet << command_id << connection_id_;
+//    send(packet);
+//}
+
+void connection_base::send(const sf::Packet& packet)
+{
+    packages_out_.push_back(std::make_unique<sf::Packet>(packet));
+}
+
+sf::Socket::Status connection_base::update()
+{
+    //receive packets
+    auto packet = sf::Packet{};
+    auto status = socket_->receive(packet);
+    if (status == sf::Socket::Status::Done)
+    {
+        const connection_command_in command{ connection_id_, session_id_, std::make_shared<sf::Packet>(packet) };
+        commands_in_->push_back(command);
+    }
+
+    if (status == sf::Socket::Status::Disconnected)
+    {
+        return status;
+    }
+
+
+    //send packets
+    if (packages_out_.empty())
+    {
+        return status;
+    }
+
+    do
+    {
+        const auto& packet_out = packages_out_.front();
+
+        status = socket_->send(*packet_out);
+        if (status == sf::Socket::Status::Done)
+        {
+            packages_out_.pop_front();
+        }
+
+        if (status == sf::Socket::Status::Disconnected || status == sf::Socket::NotReady)
+        {
+            break;
+        }
+    }
+    while (status == sf::Socket::Status::Done && !packages_out_.empty());
+
+    return status;
+}
diff --git a/battle_tanks/common_logic/headers/network/player_actions.hpp b/battle_tanks/common_logic/headers/network/player_actions.hpp
new file mode 100644
index 0000000..7798c2f
--- /dev/null
+++ b/battle_tanks/common_logic/headers/network/player_actions.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <SFML/Config.hpp>
+
+
+enum class player_action : sf::Uint32
+{
+    unknown = 0,
+    move_forward,
+    move_backward,
+    stop_move,
+
+    turn_left,
+    turn_right,
+    stop_turn,
+
+    turn_turret_left,
+    turn_turret_right,
+    stop_turn_turret,
+
+    turret_fire,
+    turret_stop_fire,
+};
diff --git a/battle_tanks/client/headers/physics/collision_listener.hpp b/battle_tanks/common_logic/headers/physics/collision_listener.hpp
similarity index 98%
rename from battle_tanks/client/headers/physics/collision_listener.hpp
rename to battle_tanks/common_logic/headers/physics/collision_listener.hpp
index e0e61b9..0e00570 100644
--- a/battle_tanks/client/headers/physics/collision_listener.hpp
+++ b/battle_tanks/common_logic/headers/physics/collision_listener.hpp
@@ -2,6 +2,8 @@
 
 #include <functional>
 
+#include <box2d/box2d.h>
+
 #include "physics/game_object_b2d_link.hpp"
 
 namespace bt
diff --git a/battle_tanks/client/headers/physics/game_object_b2d_link.hpp b/battle_tanks/common_logic/headers/physics/game_object_b2d_link.hpp
similarity index 88%
rename from battle_tanks/client/headers/physics/game_object_b2d_link.hpp
rename to battle_tanks/common_logic/headers/physics/game_object_b2d_link.hpp
index fb37d85..7a81511 100644
--- a/battle_tanks/client/headers/physics/game_object_b2d_link.hpp
+++ b/battle_tanks/common_logic/headers/physics/game_object_b2d_link.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "game/entity/game_object_type.hpp"
+#include <utils/uuid.hpp>
 
 namespace bt
 {
diff --git a/battle_tanks/common_logic/headers/physics/physics_body_factory.hpp b/battle_tanks/common_logic/headers/physics/physics_body_factory.hpp
new file mode 100644
index 0000000..c5c92b3
--- /dev/null
+++ b/battle_tanks/common_logic/headers/physics/physics_body_factory.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <box2d/b2_world.h>
+
+
+namespace bt
+{
+    class physics_body_factory
+    {
+    public:
+        physics_body_factory(b2World* world) : world_{ world }
+        {
+        }
+
+        ~physics_body_factory() = default;
+
+    public:
+
+        b2Body* create_body(const b2BodyDef& body_def) const
+        {
+            return world_->CreateBody(&body_def);
+        }
+
+        void destroy_body(b2Body* body) const
+        {
+            if (body == nullptr)
+            {
+                return;
+            }
+            world_->DestroyBody(body);
+        }
+
+    private:
+        b2World* world_;
+    };
+}
\ No newline at end of file
diff --git a/battle_tanks/client/headers/utils/math.hpp b/battle_tanks/common_logic/headers/utils/math.hpp
similarity index 100%
rename from battle_tanks/client/headers/utils/math.hpp
rename to battle_tanks/common_logic/headers/utils/math.hpp
diff --git a/battle_tanks/client/headers/utils/uuid.hpp b/battle_tanks/common_logic/headers/utils/uuid.hpp
similarity index 53%
rename from battle_tanks/client/headers/utils/uuid.hpp
rename to battle_tanks/common_logic/headers/utils/uuid.hpp
index 6529300..7f3149f 100644
--- a/battle_tanks/client/headers/utils/uuid.hpp
+++ b/battle_tanks/common_logic/headers/utils/uuid.hpp
@@ -1,8 +1,9 @@
 #pragma once
+#include <cstdint>
 
 namespace bt
 {
-    typedef long long unsigned uuid;
+    typedef std::uint32_t uuid;
 
     uuid generate_uuid();
 
diff --git a/battle_tanks/client/sources/util/uuid.cpp b/battle_tanks/common_logic/sources/util/uuid.cpp
similarity index 100%
rename from battle_tanks/client/sources/util/uuid.cpp
rename to battle_tanks/common_logic/sources/util/uuid.cpp
diff --git a/battle_tanks/server/CMakeLists.txt b/battle_tanks/server/CMakeLists.txt
new file mode 100644
index 0000000..fbba9c2
--- /dev/null
+++ b/battle_tanks/server/CMakeLists.txt
@@ -0,0 +1,25 @@
+project(battle_tanks_server)
+
+file(GLOB_RECURSE SOURCES "./*.cpp")
+
+include_directories(${PROJECT_SOURCE_DIR}/headers)
+
+find_package(SFML COMPONENTS system CONFIG REQUIRED)
+find_package(box2d CONFIG REQUIRED)
+
+add_executable (${PROJECT_NAME} ${SOURCES})
+
+if (CMAKE_VERSION VERSION_GREATER 3.12)
+  set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
+endif()
+
+target_include_directories(${PROJECT_NAME}
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/../external/headers
+        ${CMAKE_CURRENT_SOURCE_DIR}/../common_logic/headers
+)
+
+target_link_libraries(${PROJECT_NAME}
+    PRIVATE
+        bt-common
+)
diff --git a/battle_tanks/server/battle_tanks_server.cpp b/battle_tanks/server/battle_tanks_server.cpp
new file mode 100644
index 0000000..cdd4787
--- /dev/null
+++ b/battle_tanks/server/battle_tanks_server.cpp
@@ -0,0 +1,13 @@
+#include "game_server.hpp"
+
+int main()
+{
+    game_server server{};
+
+    if (server.start(52000))
+    {
+        server.run_infinity_loop(100, 100, true);
+    }
+
+    return 0;
+}
diff --git a/battle_tanks/server/headers/game_server.hpp b/battle_tanks/server/headers/game_server.hpp
new file mode 100644
index 0000000..84e03d2
--- /dev/null
+++ b/battle_tanks/server/headers/game_server.hpp
@@ -0,0 +1,195 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include "SFML/Config.hpp"
+#include "SFML/Network/Packet.hpp"
+
+#include "network/network_server.hpp"
+#include "game_session.hpp"
+
+
+class game_server
+{
+public:
+    game_server()
+    {
+        commands_out_ = std::make_shared<ts_deque<connection_command_out>>();
+    }
+
+    ~game_server()
+    {
+        is_running_ = false;
+        if (thread_commands_send_.joinable())
+        {
+            thread_commands_send_.join();
+        }
+    }
+
+public:
+    bool start(const unsigned short port);
+    [[noreturn]] void run_infinity_loop(const size_t max_messages_in, const size_t max_messages_out, const bool wait_in);
+
+private:
+    void send_commands();
+
+    void create_game_session(const sf::Uint32 connection_id);
+    void join_game_session(const sf::Uint32 connection_id, const sf::Uint32 connection_session_id, const sf::Uint32 join_session_id);
+
+private:
+    bool is_running_{ false };
+    size_t max_messages_out_{};
+    std::unordered_map<sf::Uint32, std::unique_ptr<game_session>> sessions_{};
+    std::unique_ptr<network_server> network_server_{};
+    std::shared_ptr<ts_deque<connection_command_out>> commands_out_{ nullptr };
+    std::thread thread_commands_send_;
+
+    std::unordered_map<sf::Uint32, sf::Uint32> connection_to_session_link_{};
+};
+
+bool game_server::start(const unsigned short port)
+{
+    network_server_ = std::make_unique<network_server>(port);
+
+    network_server_->register_client_command_handler(command_id_client::create_session,
+        [this](const sf::Uint32 connection_id, sf::Packet& packet)
+        {
+            create_game_session(connection_id);
+        });
+
+    network_server_->register_client_command_handler(command_id_client::join_session,
+        [this](const sf::Uint32 connection_id, sf::Packet& packet)
+        {
+            sf::Uint32 join_session_id;
+            packet >> join_session_id;
+
+            sf::Uint32 current_session_id{};
+            if (connection_to_session_link_.contains(connection_id))
+            {
+                current_session_id = connection_to_session_link_.at(connection_id);
+            }
+            join_game_session(connection_id, current_session_id, join_session_id);
+        });
+
+    network_server_->register_client_command_handler(command_id_client::player_action,
+        [this](const sf::Uint32 connection_id, sf::Packet& packet)
+        {
+            sf::Uint32 action_rough;
+            packet >> action_rough;
+
+            const auto action = static_cast<player_action>(action_rough);
+
+            sf::Uint32 session_id{};
+            if (connection_to_session_link_.contains(connection_id))
+            {
+                session_id = connection_to_session_link_.at(connection_id);
+            }
+            //TODO:: else send error to client
+
+            if (const auto session = sessions_.find(session_id); session != sessions_.end())
+            {
+                switch(action)
+                {
+                case player_action::move_forward:
+                case player_action::move_backward:
+                case player_action::stop_move:
+                    session->second->move_player(connection_id, action);
+	                break;
+                case player_action::turn_left:
+                case player_action::turn_right:
+                case player_action::stop_turn:
+                    session->second->rotate_player(connection_id, action);
+	                break;
+                case player_action::turn_turret_left:
+                case player_action::turn_turret_right:
+                case player_action::stop_turn_turret:
+                    session->second->rotate_player_turret(connection_id, action);
+	                break;
+                case player_action::turret_fire:
+                case player_action::turret_stop_fire:
+
+	                break;
+                case player_action::unknown:
+                default:
+                    //TODO:: send error to client
+                	;
+                }
+            }
+
+        });
+
+    network_server_->register_client_command_handler(command_id_client::lost_connection,
+        [this](const sf::Uint32 connection_id, sf::Packet& packet)
+        {
+            //TODO:: remove player from session and remove session if it has one or less players
+            connection_to_session_link_.erase(connection_id);
+        });
+
+    return network_server_->start();
+}
+
+[[noreturn]] void game_server::run_infinity_loop(const size_t max_messages_in, const size_t max_messages_out, const bool wait_in)
+{
+    is_running_ = true;
+    max_messages_out_ = max_messages_out;
+    thread_commands_send_ = std::thread(&game_server::send_commands, this);
+    while (true)
+    {
+        network_server_->update(max_messages_in, wait_in);
+    }
+}
+
+void game_server::send_commands()
+{
+    while (is_running_)
+    {
+        commands_out_->wait();
+
+        size_t message_count = 0;
+        while (message_count < max_messages_out_ && !commands_out_->empty())
+        {
+            auto [connection_ids, command] = commands_out_->pop_front();
+            network_server_->send_command(connection_ids, command);
+            message_count++;
+        }
+    }
+}
+
+void game_server::create_game_session(const sf::Uint32 connection_id)
+{
+    if (const auto session_pair = sessions_.find(connection_id); session_pair == sessions_.end())
+    {
+        const auto session_id = bt::generate_uuid();
+        sessions_[session_id] = std::make_unique<game_session>(session_id, commands_out_);
+
+        auto command = std::make_unique<session_created_command>();
+        command->session_id = session_id;
+
+        network_server_->send_command(connection_id, std::move(command));
+
+        //sessions_[session_id]->join_player(connection_id);
+    }
+}
+
+void game_server::join_game_session(const sf::Uint32 connection_id, const sf::Uint32 connection_session_id, const sf::Uint32 join_session_id)
+{
+    //TODO:: player has no active sessions
+    if (connection_session_id == 0)
+    {
+        if (const auto session_pair = sessions_.find(join_session_id); session_pair != sessions_.end())
+        {
+            const auto& session = session_pair->second;
+
+            if (session->get_state() == game_session_state::waiting_for_players)
+            {
+                if (session->join_player(connection_id))
+                {
+                    connection_to_session_link_[connection_id] = join_session_id;
+                }
+                // TODO:: else{} send error
+            }
+        }
+
+    }
+}
diff --git a/battle_tanks/server/headers/game_session.hpp b/battle_tanks/server/headers/game_session.hpp
new file mode 100644
index 0000000..11a14c4
--- /dev/null
+++ b/battle_tanks/server/headers/game_session.hpp
@@ -0,0 +1,268 @@
+#pragma once
+
+#include <unordered_set>
+
+#include "SFML/System/Clock.hpp"
+#include "box2d/b2_world.h"
+
+#include "game/entity/game_object_entity.hpp"
+#include "game/entity/player_game_object_entity.hpp"
+#include "game/game_objects/game_object_frame_restorer_packet.hpp"
+
+#include "network/commands.hpp"
+#include "physics/collision_listener.hpp"
+
+
+enum class game_session_type : sf::Uint32
+{
+    unknown = 0,
+    pvp_1x1,
+    team_2x2,
+    deathmatch_4,
+};
+
+enum class game_session_state : unsigned
+{
+    unknown = 0,
+    waiting_for_players,
+    starting,
+    game_play_progress,
+    finished
+};
+
+class game_session
+{
+public:
+    explicit game_session(const sf::Uint32 session_id, const std::shared_ptr<ts_deque<connection_command_out>>& commands_out)
+        : commands_out_{ commands_out }, session_id_{ session_id }
+    {
+        game_objects_ = std::unordered_map<sf::Uint32, std::unique_ptr<bt::game_object_entity>>{};
+        physics_world_.SetAllowSleeping(true);
+        //physics_world.SetContinuousPhysics(true);;
+        physics_world_.SetContactListener(&contact_listener_);
+
+        contact_listener_.add_collision_handler([this](bt::game_object_b2d_link game_object_a, bt::game_object_b2d_link game_object_b)
+            {
+                if (game_object_a.type == bt::game_object_type::bullet)
+                {
+                    objects_to_delete_.insert(game_object_a.id);
+                }
+                else if (game_object_b.type == bt::game_object_type::bullet)
+                {
+                    objects_to_delete_.insert(game_object_b.id);
+                }
+            });
+
+        state_ = game_session_state::waiting_for_players;
+    }
+
+    ~game_session()
+    {
+        state_ = game_session_state::finished;
+        if (thread_game_loop_.joinable())
+        {
+            thread_game_loop_.join();
+        }
+    }
+
+    sf::Uint32 get_session_id() const
+    {
+        return session_id_;
+    }
+
+    game_session_state get_state() const
+    {
+        return state_;
+    }
+
+    const std::vector<sf::Uint32>& get_players_ids() const
+    {
+        return players_ids_;
+    }
+
+    bool join_player(sf::Uint32 player_id);
+
+    void move_player(const sf::Uint32 player_id, const player_action action)
+    {
+        std::lock_guard lock{ mutex_game_loop_ };
+        if (const auto controller = get_player_action_controller(player_id))
+        {
+            controller->set_move_action(action);
+        }
+    }
+
+    void rotate_player(const sf::Uint32 player_id, const player_action action)
+    {
+        std::lock_guard lock{ mutex_game_loop_ };
+        if (const auto controller = get_player_action_controller(player_id))
+        {
+            controller->set_rotate_action(action);
+        }
+    }
+
+    void rotate_player_turret(const sf::Uint32 player_id, const player_action action)
+    {
+        std::lock_guard lock{ mutex_game_loop_ };
+        if (const auto controller = get_player_action_controller(player_id))
+        {
+            controller->set_turret_rotate_action(action);
+        }
+    }
+
+private:
+    void update();
+
+    void delete_game_objects();
+    void send_game_session_frame(const float delta_time);
+
+
+    std::shared_ptr<bt::player_action_controller> get_player_action_controller(const sf::Uint32 player_id)
+    {
+        //std::lock_guard lock{ mutex_game_loop_ };
+        if (const auto action_controller = players_action_controllers_.find(player_id); action_controller != players_action_controllers_.end())
+        {
+            if (action_controller->second.expired())
+            {
+                players_action_controllers_.erase(player_id);
+            }
+            else
+            {
+                return action_controller->second.lock();
+            }
+        }
+        return nullptr;
+    }
+
+private:
+    std::shared_ptr<ts_deque<connection_command_out>> commands_out_{ nullptr };
+
+    std::thread thread_game_loop_;
+    std::mutex mutex_game_loop_;
+
+    sf::Uint32 session_id_{};
+    game_session_state state_{};
+
+    b2World physics_world_ = b2World{ b2Vec2{ 0.0f, 0.0f } };
+    bt::collision_listener contact_listener_{};
+    bt::physics_body_factory physics_body_factory_{ &physics_world_ };
+
+    std::unordered_set<bt::uuid> objects_to_delete_{};
+    std::unordered_map<sf::Uint32, std::unique_ptr<bt::game_object_entity>> game_objects_{};
+    std::unordered_map<sf::Uint32, std::weak_ptr<bt::player_action_controller>> players_action_controllers_{};
+
+    std::vector<sf::Uint32> players_ids_{};
+};
+
+void game_session::update()
+{
+    sf::Clock clock;
+    constexpr int count_down_to_start_milliseconds{ 3000 };
+    int current_count_down_time{ count_down_to_start_milliseconds };
+    while (state_ != game_session_state::finished)
+    {
+        if (state_ == game_session_state::starting)
+        {
+            current_count_down_time -= clock.restart().asMilliseconds();
+            if (current_count_down_time <= 0)
+            {
+                state_ = game_session_state::game_play_progress;
+
+                auto command = std::make_unique<session_started_command>();
+                command->session_id = session_id_;
+
+                for (auto player_id : players_ids_)
+                {
+                    command->game_objects.push_back(game_objects_.at(player_id)->get_frame());
+                }
+
+                commands_out_->push_back({ players_ids_, std::move(command) });
+                continue;
+            }
+        }
+
+        if (state_ == game_session_state::game_play_progress)
+        {
+            std::lock_guard lock{ mutex_game_loop_ };
+            delete_game_objects();
+            const float delta_time = clock.restart().asSeconds();
+            physics_world_.Step(delta_time, 2, 1);
+            send_game_session_frame(delta_time);
+        }
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000 / 60));
+    }
+}
+
+void game_session::delete_game_objects()
+{
+    for (const auto& game_object_id : objects_to_delete_)
+    {
+        game_objects_.erase(game_object_id);
+        commands_out_->push_back({
+            players_ids_,
+            std::make_unique<deleted_game_object_command>(game_object_id)
+        });
+    }
+    objects_to_delete_.clear();
+}
+
+void game_session::send_game_session_frame(const float delta_time)
+{
+    auto command = std::make_unique<game_frame_command>();
+    for (const auto& game_object : game_objects_ | std::views::values)
+    {
+        game_object->update(delta_time);
+        command->game_objects.push_back(game_object->get_frame());
+    }
+    commands_out_->push_back({ players_ids_, std::move(command) });
+}
+
+bool game_session::join_player(sf::Uint32 player_id)
+{
+    if (state_ != game_session_state::waiting_for_players)
+    {
+        return false;
+    }
+
+
+    std::lock_guard lock{ mutex_game_loop_ };
+
+    auto player_entity = std::make_unique<bt::player_game_object_entity>(player_id, physics_body_factory_);
+    player_entity->create_phy_body();
+
+
+    //TODO:: new player state configuration
+    const auto packet = std::make_shared<sf::Packet>();
+    player_game_object_frame frame{};
+    if (players_ids_.empty())
+    {
+        frame.position = { 10.0f, 10.f };
+    }
+    else
+    {
+        frame.position = { 40.0f, 40.f };
+    }
+    frame.write_to_packet(*packet);
+    sf::Uint32 id;
+    *packet >> id;
+    const bt::game_object_frame_restorer_packet restorer{ packet };
+    player_entity->restore_frame(restorer);
+    /////////////////////////////////////////
+
+    players_action_controllers_.emplace(player_id, player_entity->get_action_controller());
+    game_objects_.emplace(player_id, std::move(player_entity));
+    players_ids_.push_back(player_id);
+
+    auto joined_command = std::make_unique<player_joined_to_session_command>();
+    joined_command->session_id = session_id_;
+    joined_command->player_id = player_id;
+    commands_out_->push_back({ players_ids_, std::move(joined_command) });
+
+    if (players_ids_.size() == 2)
+    {
+        state_ = game_session_state::starting;
+        thread_game_loop_ = std::thread{ &game_session::update, this };
+    }
+
+    return true;
+}
diff --git a/battle_tanks/server/headers/network/network_server.hpp b/battle_tanks/server/headers/network/network_server.hpp
new file mode 100644
index 0000000..8bd08d2
--- /dev/null
+++ b/battle_tanks/server/headers/network/network_server.hpp
@@ -0,0 +1,219 @@
+#pragma once
+
+#include <functional>
+#include <iostream>
+#include <ranges>
+
+#include <SFML/Network.hpp>
+
+#include "network/server_connection.hpp"
+#include "network/commands.hpp"
+#include "utils/uuid.hpp"
+
+using client_command_handler = std::function<void(const sf::Uint32 connection_id, sf::Packet&)>;
+//template<typename T>
+//using client_command_handler = std::function<void(const sf::Uint32 connection_id, const sf::Uint32 session_id, const T& command)>;
+
+class network_server
+{
+public:
+    network_server(const unsigned short port) : port_{ port }
+    {}
+
+    ~network_server()
+    {
+        stop();
+    }
+
+    bool start();
+    void stop();
+    void update(size_t max_messages = -1, bool wait = false);
+
+    void send_command(const sf::Uint32 connection_id, const std::unique_ptr<server_command>& command);
+    void send_command(const std::vector<sf::Uint32>& connection_id, const std::unique_ptr<server_command>& command);
+
+    void register_client_command_handler(const command_id_client command_id, const client_command_handler& handler);
+
+private:
+    void wait_for_client_connection();
+    sf::Uint32 generate_client_id();
+    void on_client_message(const sf::Uint32 connection_id, const std::shared_ptr<sf::Packet>& packet);
+    void update_connection();
+
+private:
+    unsigned short port_{};
+    bool is_running_{ false };
+
+    std::thread thread_accept_awaiter_;
+    std::thread thread_connections_worker_;
+    std::mutex mutex_connections_;
+
+    std::unique_ptr<sf::TcpListener> listener_{ nullptr };
+
+    std::unordered_map<sf::Uint32, std::shared_ptr<server_connection>> connections_{};
+
+    std::shared_ptr<ts_deque<connection_command_in>> commands_in_{ nullptr };
+
+    std::unordered_map<command_id_client, client_command_handler> client_command_handlers_;
+
+};
+
+bool network_server::start()
+{
+    commands_in_ = std::make_shared<ts_deque<connection_command_in>>();
+    listener_ = std::make_unique<sf::TcpListener>();
+
+    if (listener_->listen(port_) != sf::Socket::Done)
+    {
+        return false;
+    }
+
+    is_running_ = true;
+    thread_accept_awaiter_ = std::thread{ &network_server::wait_for_client_connection, this };
+    thread_connections_worker_ = std::thread{ &network_server::update_connection, this };
+
+
+    return true;
+}
+
+void network_server::stop()
+{
+    is_running_ = false;
+    if (thread_accept_awaiter_.joinable())
+    {
+        thread_accept_awaiter_.join();
+    }
+    if (thread_connections_worker_.joinable())
+    {
+        thread_connections_worker_.join();
+    }
+}
+
+void network_server::update(const size_t max_messages, const bool wait)
+{
+    if (wait)
+    {
+        commands_in_->wait();
+    }
+
+    size_t message_count = 0;
+    while (message_count < max_messages && !commands_in_->empty())
+    {
+        auto [client_id, session_id, packet] = commands_in_->pop_front();
+
+        on_client_message(client_id, packet);
+
+        message_count++;
+    }
+}
+
+void network_server::send_command(const sf::Uint32 connection_id, const std::unique_ptr<server_command>& command)
+{
+    auto packet = sf::Packet{};
+    command->write_to_packet(packet);
+
+    std::lock_guard lock(mutex_connections_);
+    if (connections_.contains(connection_id))
+    {
+        connections_[connection_id]->send(packet);
+    }
+}
+
+void network_server::send_command(const std::vector<sf::Uint32>& connection_id, const std::unique_ptr<server_command>& command)
+{
+    auto packet = sf::Packet{};
+    command->write_to_packet(packet);
+
+    std::lock_guard lock(mutex_connections_);
+    for (const auto& id : connection_id)
+    {
+        if (connections_.contains(id))
+        {
+            connections_[id]->send(packet);
+        }
+    }
+}
+
+void network_server::register_client_command_handler(const command_id_client command_id, const client_command_handler& handler)
+{
+    client_command_handlers_[command_id] = handler;
+}
+
+void network_server::on_client_message(const sf::Uint32 connection_id, const std::shared_ptr<sf::Packet>& packet)
+{
+    sf::Uint32 rough_cmd_id;
+    *packet >> rough_cmd_id;
+
+    const auto command_id = static_cast<::command_id_client>(rough_cmd_id);
+
+    if (client_command_handlers_.contains(command_id))
+    {
+        client_command_handlers_[command_id](connection_id, *packet);
+    }
+    else
+    {
+        std::cout << "Unregistered command handler for command id: " << rough_cmd_id
+            << "; connection id: " << connection_id << std::endl;
+    }
+}
+
+void network_server::update_connection()
+{
+    while (is_running_)
+    {
+        //TODO:: check connection without valuable packaged during some timeout and kill
+        std::lock_guard lock(mutex_connections_);
+        std::vector<sf::Uint32> connections_to_remove;
+        for (const auto& connection : connections_ | std::views::values)
+        {
+            if (connection->update() == sf::Socket::Disconnected)
+            {
+                auto packet = sf::Packet{};
+                const auto connection_id = connection->get_connection_id();
+                const auto session_id = connection->get_session_id();
+
+                packet << static_cast<sf::Uint32>(command_id_client::lost_connection);
+                packet << connection_id;
+                packet << session_id;
+                connection_command_in command
+                {
+                    connection_id,
+                    session_id,
+                    std::make_shared<sf::Packet>(packet)
+                };
+
+                commands_in_->push_back(command);
+                connections_to_remove.push_back(connection_id);
+            }
+        }
+
+        for (const auto connection_id : connections_to_remove)
+        {
+            connections_.erase(connection_id);
+        }
+    }
+}
+
+void network_server::wait_for_client_connection()
+{
+    while (is_running_)
+    {
+        auto client_socket = std::make_unique<sf::TcpSocket>();
+        listener_->accept(*client_socket);
+
+        std::cout << "Client connected: " << client_socket->getRemoteAddress().toString() << std::endl;
+
+        const auto client_connection = std::make_shared<server_connection>(std::move(client_socket), commands_in_);
+        const sf::Uint32 connection_id = generate_client_id();
+
+        client_connection->connect(connection_id);
+
+        std::lock_guard lock(mutex_connections_);
+        connections_.emplace(connection_id, client_connection);
+    }
+}
+
+sf::Uint32 network_server::generate_client_id()
+{
+    return bt::generate_uuid();
+}
diff --git a/battle_tanks/server/headers/network/server_connection.hpp b/battle_tanks/server/headers/network/server_connection.hpp
new file mode 100644
index 0000000..f8f7e31
--- /dev/null
+++ b/battle_tanks/server/headers/network/server_connection.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "network/commands.hpp"
+#include "network/connection_base.hpp"
+
+
+class server_connection : public connection_base
+{
+public:
+    server_connection(std::unique_ptr<sf::TcpSocket>&& socket, const std::shared_ptr<ts_deque<connection_command_in>>& commands_in)
+        : connection_base{ std::move(socket) , commands_in }
+    {
+    }
+
+    virtual ~server_connection() override = default;
+
+public:
+    void connect(const sf::Uint32 id);
+};
+
+void server_connection::connect(const sf::Uint32 id)
+{
+    connection_id_ = id;
+    sf::Packet packet{};
+    constexpr auto command_id = static_cast<sf::Uint32>(command_id_server::connected_to_game);
+    packet << command_id << connection_id_;
+    send(packet);
+}
diff --git a/external/headers/boost/di.hpp b/external/headers/boost/di.hpp
deleted file mode 100644
index a07a2eb..0000000
--- a/external/headers/boost/di.hpp
+++ /dev/null
@@ -1,3355 +0,0 @@
-//
-// Copyright (c) 2012-2020 Kris Jusiak (kris at jusiak dot net)
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#pragma once
-#if (__cplusplus < 201305L && _MSC_VER < 1900)
-#error "[Boost::ext].DI requires C++14 support (Clang-3.4+, GCC-5.1+, MSVC-2015+)"
-#else
-#define BOOST_DI_VERSION 1'3'0
-#define BOOST_DI_NAMESPACE_BEGIN \
-  namespace boost {              \
-  inline namespace ext {         \
-  namespace di {                 \
-  inline namespace v1_3_0 {
-#define BOOST_DI_NAMESPACE_END \
-  }                            \
-  }                            \
-  }                            \
-  }
-#if !defined(BOOST_DI_CFG_DIAGNOSTICS_LEVEL)
-#define BOOST_DI_CFG_DIAGNOSTICS_LEVEL 1
-#endif
-#if defined(BOOST_DI_CFG_FWD)
-BOOST_DI_CFG_FWD
-#endif
-#define __BOOST_DI_COMPILER(arg, ...) __BOOST_DI_COMPILER_IMPL(arg, __VA_ARGS__)
-#define __BOOST_DI_COMPILER_IMPL(arg, ...) arg##__VA_ARGS__
-#if defined(__clang__)
-#define __CLANG__ __BOOST_DI_COMPILER(__clang_major__, __clang_minor__)
-#define __BOOST_DI_UNUSED __attribute__((unused))
-#define __BOOST_DI_DEPRECATED(...) [[deprecated(__VA_ARGS__)]]
-#define __BOOST_DI_TYPE_WKND(T)
-#define __BOOST_DI_ACCESS_WKND private
-#define __BOOST_DI_VARIABLE_TEMPLATE_INIT_WKND \
-  {}
-#elif defined(__GNUC__)
-#define __GCC__
-#define __BOOST_DI_UNUSED __attribute__((unused))
-#define __BOOST_DI_DEPRECATED(...) [[deprecated(__VA_ARGS__)]]
-#define __BOOST_DI_TYPE_WKND(T)
-#define __BOOST_DI_ACCESS_WKND private
-#define __BOOST_DI_VARIABLE_TEMPLATE_INIT_WKND \
-  {}
-#elif defined(_MSC_VER)
-#define __MSVC__
-#if !defined(__has_include)
-#define __has_include(...) 0
-#endif
-#define __BOOST_DI_UNUSED
-#define __BOOST_DI_DEPRECATED(...) __declspec(deprecated(__VA_ARGS__))
-#define __BOOST_DI_TYPE_WKND(T) (T &&)
-#define __BOOST_DI_ACCESS_WKND public
-#define __BOOST_DI_VARIABLE_TEMPLATE_INIT_WKND
-#endif
-#if !defined(__has_builtin)
-#define __has_builtin(...) 0
-#endif
-#if !defined(__has_extension)
-#define __has_extension(...) 0
-#endif
-#if defined(__CLANG__)
-#if (!BOOST_DI_CFG_DIAGNOSTICS_LEVEL)
-#pragma clang diagnostic error "-Wdeprecated-declarations"
-#else
-#pragma clang diagnostic warning "-Wdeprecated-declarations"
-#endif
-#pragma clang diagnostic push
-#pragma clang diagnostic error "-Wundefined-inline"
-#pragma clang diagnostic error "-Wundefined-internal"
-#pragma clang diagnostic ignored "-Wmissing-field-initializers"
-#elif defined(__GCC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic error "-Wdeprecated-declarations"
-#if (__GNUC__ < 6)
-#pragma GCC diagnostic error "-Werror"
-#endif
-#elif defined(__MSVC__)
-#pragma warning(disable : 4503)
-#pragma warning(disable : 4822)
-#pragma warning(disable : 4505)
-#endif
-#if defined(_LIBCPP_VERSION)
-#define NAMESPACE_STD_BEGIN _LIBCPP_BEGIN_NAMESPACE_STD {
-#else
-#define NAMESPACE_STD_BEGIN namespace std {
-#endif
-#if defined(_LIBCPP_VERSION)
-#define NAMESPACE_STD_END _LIBCPP_END_NAMESPACE_STD
-#else
-#define NAMESPACE_STD_END }
-#endif
-#if __has_include(<__config>)
-#include <__config>
-#endif
-#if __has_include(<memory>)
-#include <memory>
-#else
-NAMESPACE_STD_BEGIN
-template <class>
-class shared_ptr;
-template <class>
-class weak_ptr;
-template <class, class>
-class unique_ptr;
-NAMESPACE_STD_END
-#endif
-#if __has_include(<vector>)
-#include <vector>
-#else
-NAMESPACE_STD_BEGIN
-template <class, class>
-class vector;
-NAMESPACE_STD_END
-#endif
-#if __has_include(<set>)
-#include <set>
-#else
-NAMESPACE_STD_BEGIN
-template <class, class, class>
-class set;
-NAMESPACE_STD_END
-#endif
-#if __has_include(<initializer_list>)
-#include <initializer_list>
-#else
-NAMESPACE_STD_BEGIN
-template <class>
-class initializer_list;
-NAMESPACE_STD_END
-#endif
-#if __has_include(<tuple>)
-#include <tuple>
-#else
-NAMESPACE_STD_BEGIN
-template <class...>
-class tuple;
-NAMESPACE_STD_END
-#endif
-#if __has_include(<iterator>)
-#include <iterator>
-#else
-NAMESPACE_STD_BEGIN
-template <class>
-class move_iterator;
-NAMESPACE_STD_END
-#endif
-#if __has_include(<string>)
-#include <string>
-#else
-NAMESPACE_STD_BEGIN
-template <class>
-struct char_traits;
-NAMESPACE_STD_END
-#endif
-// clang-format off
-#if __has_include(<boost/shared_ptr.hpp>)
-// clang-format on
-#include <boost/shared_ptr.hpp>
-#else
-namespace boost {
-template <class>
-class shared_ptr;
-}
-#endif
-BOOST_DI_NAMESPACE_BEGIN
-struct _ {
-  _(...) {}
-};
-namespace aux {
-using swallow = int[];
-template <class T>
-using owner = T;
-template <class...>
-struct valid {
-  using type = int;
-};
-template <class... Ts>
-using valid_t = typename valid<Ts...>::type;
-template <class...>
-struct type {};
-struct none_type {};
-template <class T, T>
-struct non_type {};
-template <class...>
-struct always {
-  static constexpr auto value = true;
-};
-template <class...>
-struct never {
-  static constexpr auto value = false;
-};
-template <class T, class...>
-struct identity {
-  using type = T;
-};
-template <class...>
-struct type_list {
-  using type = type_list;
-};
-template <bool...>
-struct bool_list {
-  using type = bool_list;
-};
-template <class T1, class T2>
-struct pair {
-  using type = pair;
-  using first = T1;
-  using second = T2;
-};
-template <class... Ts>
-struct inherit : Ts... {
-  using type = inherit;
-};
-template <class... Ts>
-struct join {
-  using type = type_list<>;
-};
-template <class T>
-struct join<T> {
-  using type = T;
-};
-template <class... T1s, class... T2s, class... Ts>
-struct join<type_list<T1s...>, type_list<T2s...>, Ts...> : join<type_list<T1s..., T2s...>, Ts...> {};
-template <class... Ts, class... T1s, class... T2s, class... T3s, class... T4s, class... T5s, class... T6s, class... T7s,
-          class... T8s, class... T9s, class... T10s, class... T11s, class... T12s, class... T13s, class... T14s, class... T15s,
-          class... T16s, class... Us>
-struct join<type_list<Ts...>, type_list<T1s...>, type_list<T2s...>, type_list<T3s...>, type_list<T4s...>, type_list<T5s...>,
-            type_list<T6s...>, type_list<T7s...>, type_list<T8s...>, type_list<T9s...>, type_list<T10s...>, type_list<T11s...>,
-            type_list<T12s...>, type_list<T13s...>, type_list<T14s...>, type_list<T15s...>, type_list<T16s...>, Us...>
-    : join<type_list<Ts..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s..., T8s..., T9s..., T10s..., T11s..., T12s...,
-                     T13s..., T14s..., T15s..., T16s...>,
-           Us...> {};
-template <class... TArgs>
-using join_t = typename join<TArgs...>::type;
-template <int...>
-struct index_sequence {
-  using type = index_sequence;
-};
-#if __has_builtin(__make_integer_seq)
-template <class T, T... Ns>
-struct integer_sequence {
-  using type = index_sequence<Ns...>;
-};
-template <int N>
-struct make_index_sequence_impl {
-  using type = typename __make_integer_seq<integer_sequence, int, N>::type;
-};
-#else
-template <class...>
-struct build_index_sequence;
-template <int... Cs1, int... Cs2>
-struct build_index_sequence<index_sequence<Cs1...>, index_sequence<Cs2...>> {
-  using type = index_sequence<Cs1..., sizeof...(Cs1) + Cs1..., 2 * sizeof...(Cs1) + Cs2...>;
-};
-template <int N>
-struct make_index_sequence_impl {
-  using type = typename build_index_sequence<typename make_index_sequence_impl<N / 2>::type,
-                                             typename make_index_sequence_impl<N % 2>::type>::type;
-};
-template <>
-struct make_index_sequence_impl<0> : index_sequence<> {};
-template <>
-struct make_index_sequence_impl<1> : index_sequence<0> {};
-template <>
-struct make_index_sequence_impl<2> : index_sequence<0, 1> {};
-template <>
-struct make_index_sequence_impl<3> : index_sequence<0, 1, 2> {};
-template <>
-struct make_index_sequence_impl<4> : index_sequence<0, 1, 2, 3> {};
-template <>
-struct make_index_sequence_impl<5> : index_sequence<0, 1, 2, 3, 4> {};
-template <>
-struct make_index_sequence_impl<6> : index_sequence<0, 1, 2, 3, 4, 5> {};
-template <>
-struct make_index_sequence_impl<7> : index_sequence<0, 1, 2, 3, 4, 5, 6> {};
-template <>
-struct make_index_sequence_impl<8> : index_sequence<0, 1, 2, 3, 4, 5, 6, 7> {};
-template <>
-struct make_index_sequence_impl<9> : index_sequence<0, 1, 2, 3, 4, 5, 6, 7, 8> {};
-template <>
-struct make_index_sequence_impl<10> : index_sequence<0, 1, 2, 3, 4, 5, 6, 7, 8, 9> {};
-#endif
-template <int N>
-using make_index_sequence = typename make_index_sequence_impl<N>::type;
-}
-namespace placeholders {
-__BOOST_DI_UNUSED static const struct arg {
-} _{};
-}
-template <class, class = void>
-struct named {};
-struct no_name {
-  constexpr auto operator()() const noexcept { return ""; }
-};
-template <class, class = int>
-struct ctor_traits;
-template <class>
-struct self {};
-struct ignore_policies {};
-namespace core {
-template <class>
-struct any_type_fwd;
-template <class>
-struct any_type_ref_fwd;
-template <class>
-struct any_type_1st_fwd;
-template <class>
-struct any_type_1st_ref_fwd;
-struct dependency_base {};
-struct injector_base {};
-template <class T>
-struct dependency__ : T {
-  using T::create;
-  using T::is_referable;
-  using T::try_create;
-};
-template <class T>
-struct injector__ : T {
-  using T::cfg;
-  using T::create_impl;
-  using T::create_successful_impl;
-#if defined(__MSVC__)
-  template <class... Ts>
-  using is_creatable = typename T::template is_creatable<Ts...>;
-  template <class... Ts>
-  using try_create = typename T::template try_create<Ts...>;
-#else
-  using T::is_creatable;
-  using T::try_create;
-#endif
-};
-template <class, class...>
-struct array;
-struct deduced {};
-struct none {};
-template <class, class TExpected = deduced, class = TExpected, class = no_name, class = void, class = none>
-class dependency;
-}
-namespace scopes {
-class deduce;
-class instance;
-class singleton;
-class unique;
-}
-#define __BOOST_DI_REQUIRES(...) typename ::boost::ext::di::v1_3_0::aux::enable_if<__VA_ARGS__, int>::type
-#define __BOOST_DI_REQUIRES_MSG(...) typename ::boost::ext::di::v1_3_0::aux::concept_check<__VA_ARGS__>::type
-namespace aux {
-template <class T>
-T&& declval();
-template <class T, T V>
-struct integral_constant {
-  using type = integral_constant;
-  static constexpr T value = V;
-};
-using true_type = integral_constant<bool, true>;
-using false_type = integral_constant<bool, false>;
-template <bool B, class T, class F>
-struct conditional {
-  using type = T;
-};
-template <class T, class F>
-struct conditional<false, T, F> {
-  using type = F;
-};
-template <bool B, class T, class F>
-using conditional_t = typename conditional<B, T, F>::type;
-template <bool B, class T = void>
-struct enable_if {};
-template <class T>
-struct enable_if<true, T> {
-  using type = T;
-};
-template <bool B, class T = void>
-using enable_if_t = typename enable_if<B, T>::type;
-template <class T>
-struct concept_check {
-  static_assert(T::value, "constraint not satisfied");
-};
-template <>
-struct concept_check<true_type> {
-  using type = int;
-};
-template <class T>
-struct remove_reference {
-  using type = T;
-};
-template <class T>
-struct remove_reference<T&> {
-  using type = T;
-};
-template <class T>
-struct remove_reference<T&&> {
-  using type = T;
-};
-template <class T>
-using remove_reference_t = typename remove_reference<T>::type;
-template <class T>
-struct remove_pointer {
-  using type = T;
-};
-template <class T>
-struct remove_pointer<T*> {
-  using type = T;
-};
-template <class T>
-using remove_pointer_t = typename remove_pointer<T>::type;
-template <class T>
-struct remove_smart_ptr {
-  using type = T;
-};
-template <class T, class TDeleter>
-struct remove_smart_ptr<std::unique_ptr<T, TDeleter>> {
-  using type = T;
-};
-template <class T>
-struct remove_smart_ptr<std::shared_ptr<T>> {
-  using type = T;
-};
-template <class T>
-struct remove_smart_ptr<std::weak_ptr<T>> {
-  using type = T;
-};
-template <class T>
-struct remove_smart_ptr<boost::shared_ptr<T>> {
-  using type = T;
-};
-template <class T>
-using remove_smart_ptr_t = typename remove_smart_ptr<T>::type;
-template <class T>
-struct remove_qualifiers {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<const T> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<T&> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<const T&> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<T*> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<const T*> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<T* const&> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<T* const> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<const T* const> {
-  using type = T;
-};
-template <class T>
-struct remove_qualifiers<T&&> {
-  using type = T;
-};
-template <class T>
-using remove_qualifiers_t = typename remove_qualifiers<T>::type;
-template <class T>
-struct remove_extent {
-  using type = T;
-};
-template <class T>
-struct remove_extent<T[]> {
-  using type = T;
-};
-template <class T>
-using remove_extent_t = typename remove_extent<T>::type;
-template <class T>
-struct deref_type {
-  using type = T;
-};
-template <class T, class TDeleter>
-struct deref_type<std::unique_ptr<T, TDeleter>> {
-  using type = remove_qualifiers_t<typename deref_type<T>::type>;
-};
-template <class T>
-struct deref_type<std::shared_ptr<T>> {
-  using type = remove_qualifiers_t<typename deref_type<T>::type>;
-};
-template <class T>
-struct deref_type<boost::shared_ptr<T>> {
-  using type = remove_qualifiers_t<typename deref_type<T>::type>;
-};
-template <class T>
-struct deref_type<std::weak_ptr<T>> {
-  using type = remove_qualifiers_t<typename deref_type<T>::type>;
-};
-template <class T, class TAllocator>
-struct deref_type<std::vector<T, TAllocator>> {
-  using type = core::array<remove_qualifiers_t<typename deref_type<T>::type>>;
-};
-template <class TKey, class TCompare, class TAllocator>
-struct deref_type<std::set<TKey, TCompare, TAllocator>> {
-  using type = core::array<remove_qualifiers_t<typename deref_type<TKey>::type>>;
-};
-template <class T>
-struct deref_type<std::initializer_list<T>> {
-  using type = core::array<remove_qualifiers_t<typename deref_type<T>::type>>;
-};
-template <class T>
-using decay_t = typename deref_type<remove_qualifiers_t<T>>::type;
-template <class, class>
-struct is_same : false_type {};
-template <class T>
-struct is_same<T, T> : true_type {};
-template <class T, class U>
-struct is_base_of : integral_constant<bool, __is_base_of(T, U)> {};
-template <class T>
-struct is_class : integral_constant<bool, __is_class(T)> {};
-template <class T>
-struct is_abstract : integral_constant<bool, __is_abstract(T)> {};
-template <class T>
-struct is_polymorphic : integral_constant<bool, __is_polymorphic(T)> {};
-template <class T>
-struct is_final : integral_constant<bool, __is_final(T)> {};
-template <class...>
-using is_valid_expr = true_type;
-#if __has_extension(is_constructible) && !((__clang_major__ == 3) && (__clang_minor__ == 5))
-template <class T, class... TArgs>
-using is_constructible = integral_constant<bool, __is_constructible(T, TArgs...)>;
-#else
-template <class T, class... TArgs>
-decltype(void(T(declval<TArgs>()...)), true_type{}) test_is_constructible(int);
-template <class, class...>
-false_type test_is_constructible(...);
-template <class T, class... TArgs>
-struct is_constructible : decltype(test_is_constructible<T, TArgs...>(0)) {};
-#endif
-template <class T, class... TArgs>
-using is_constructible_t = typename is_constructible<T, TArgs...>::type;
-template <class T, class... TArgs>
-decltype(void(T{declval<TArgs>()...}), true_type{}) test_is_braces_constructible(int);
-template <class, class...>
-false_type test_is_braces_constructible(...);
-template <class T, class... TArgs>
-using is_braces_constructible = decltype(test_is_braces_constructible<T, TArgs...>(0));
-template <class T, class... TArgs>
-using is_braces_constructible_t = typename is_braces_constructible<T, TArgs...>::type;
-#if defined(__MSVC__)
-template <class T>
-struct is_copy_constructible : integral_constant<bool, __is_constructible(T, const T&)> {};
-template <class T>
-struct is_default_constructible : integral_constant<bool, __is_constructible(T)> {};
-#else
-template <class T>
-using is_copy_constructible = is_constructible<T, const T&>;
-template <class T>
-using is_default_constructible = is_constructible<T>;
-#endif
-#if defined(__CLANG__) || defined(__MSVC__)
-template <class T, class U>
-struct is_convertible : integral_constant<bool, __is_convertible_to(T, U)> {};
-#else
-struct test_is_convertible__ {
-  template <class T>
-  static void test(T);
-};
-template <class T, class U, class = decltype(test_is_convertible__::test<U>(declval<T>()))>
-true_type test_is_convertible(int);
-template <class, class>
-false_type test_is_convertible(...);
-template <class T, class U>
-using is_convertible = decltype(test_is_convertible<T, U>(0));
-#endif
-template <class TSrc, class TDst, class U = remove_qualifiers_t<TDst>>
-using is_narrowed = integral_constant<bool, !is_class<TSrc>::value && !is_class<U>::value && !is_same<TSrc, U>::value>;
-template <class, class...>
-struct is_array : false_type {};
-template <class T, class... Ts>
-struct is_array<T[], Ts...> : true_type {};
-template <class T, class = decltype(sizeof(T))>
-true_type is_complete_impl(int);
-template <class T>
-false_type is_complete_impl(...);
-template <class T>
-struct is_complete : decltype(is_complete_impl<T>(0)) {};
-template <class T, class U, class = decltype(sizeof(U))>
-is_base_of<T, U> is_a_impl(int);
-template <class T, class U>
-false_type is_a_impl(...);
-template <class T, class U>
-struct is_a : decltype(is_a_impl<T, U>(0)) {};
-template <class, class...>
-struct is_unique_impl;
-template <class...>
-struct not_unique : false_type {
-  using type = not_unique;
-};
-template <>
-struct not_unique<> : true_type {
-  using type = not_unique;
-};
-template <class T>
-struct is_unique_impl<T> : not_unique<> {};
-template <class T1, class T2, class... Ts>
-struct is_unique_impl<T1, T2, Ts...>
-    : conditional_t<is_base_of<type<T2>, T1>::value, not_unique<T2>, is_unique_impl<inherit<T1, type<T2>>, Ts...>> {};
-template <class... Ts>
-using is_unique = is_unique_impl<none_type, Ts...>;
-template <class...>
-struct unique;
-template <class... Rs, class T, class... Ts>
-struct unique<type<Rs...>, T, Ts...> : conditional_t<is_base_of<type<T>, inherit<type<Rs>...>>::value,
-                                                     unique<type<Rs...>, Ts...>, unique<type<Rs..., T>, Ts...>> {};
-template <class... Rs>
-struct unique<type<Rs...>> : type_list<Rs...> {};
-template <class... Ts>
-using unique_t = typename unique<type<>, Ts...>::type;
-false_type has_shared_ptr__(...);
-#if !defined(BOOST_DI_DISABLE_SHARED_PTR_DEDUCTION)
-template <class T>
-auto has_shared_ptr__(T&&) -> is_valid_expr<decltype(std::shared_ptr<T>{})>;
-#endif
-template <class T, class... TArgs>
-decltype(::boost::ext::di::v1_3_0::aux::declval<T>().operator()(::boost::ext::di::v1_3_0::aux::declval<TArgs>()...),
-         ::boost::ext::di::v1_3_0::aux::true_type())
-is_invocable_impl(int);
-template <class, class...>
-::boost::ext::di::v1_3_0::aux::false_type is_invocable_impl(...);
-template <class T, class... TArgs>
-struct is_invocable : decltype(is_invocable_impl<T, TArgs...>(0)) {};
-struct callable_base_impl {
-  void operator()(...) {}
-};
-template <class T>
-struct callable_base : callable_base_impl,
-                       aux::conditional_t<aux::is_class<T>::value && !aux::is_final<T>::value, T, aux::none_type> {};
-template <typename T>
-aux::false_type is_callable_impl(T*, aux::non_type<void (callable_base_impl::*)(...), &T::operator()>* = 0);
-aux::true_type is_callable_impl(...);
-template <class T>
-struct is_callable : decltype(is_callable_impl(aux::declval<callable_base<T>*>())) {};
-template <class, class = int>
-struct is_empty_expr : false_type {};
-template <class TExpr>
-#if defined(__MSVC__)
-struct is_empty_expr<TExpr, valid_t<decltype(declval<TExpr>()())>> : integral_constant<bool, sizeof(TExpr) == 1> {
-};
-#else
-struct is_empty_expr<TExpr, valid_t<decltype(+declval<TExpr>()), decltype(declval<TExpr>()())>> : true_type {
-};
-#endif
-template <class>
-struct function_traits;
-template <class R, class... TArgs>
-struct function_traits<R (*)(TArgs...)> {
-  using result_type = R;
-  using args = type_list<TArgs...>;
-};
-template <class R, class... TArgs>
-struct function_traits<R(TArgs...)> {
-  using result_type = R;
-  using args = type_list<TArgs...>;
-};
-template <class R, class T, class... TArgs>
-struct function_traits<R (T::*)(TArgs...)> {
-  using result_type = R;
-  using args = type_list<TArgs...>;
-};
-template <class R, class T, class... TArgs>
-struct function_traits<R (T::*)(TArgs...) const> {
-  using result_type = R;
-  using args = type_list<TArgs...>;
-};
-template <class T>
-using function_traits_t = typename function_traits<T>::args;
-}
-namespace core {
-template <class T, class = typename aux::is_a<injector_base, T>::type>
-struct bindings_impl;
-template <class T>
-struct bindings_impl<T, aux::true_type> {
-  using type = typename T::deps;
-};
-template <class T>
-struct bindings_impl<T, aux::false_type> {
-  using type = aux::type_list<T>;
-};
-#if defined(__MSVC__)
-template <class... Ts>
-struct bindings : aux::join_t<typename bindings_impl<Ts>::type...> {};
-template <class... Ts>
-using bindings_t = typename bindings<Ts...>::type;
-#else
-template <class... Ts>
-using bindings_t = aux::join_t<typename bindings_impl<Ts>::type...>;
-#endif
-}
-namespace concepts {
-template <class T, class...>
-struct type_ {
-  template <class TName>
-  struct named {
-    struct is_bound_more_than_once : aux::false_type {};
-  };
-  struct is_bound_more_than_once : aux::false_type {};
-  struct is_neither_a_dependency_nor_an_injector : aux::false_type {};
-  struct has_disallowed_qualifiers : aux::false_type {};
-  struct is_abstract :
-#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL >= 2)
-      // clang-format off
-      decltype(
-    T{}
-   ),
-// clang-format on
-#endif
-      aux::false_type {
-  };
-  template <class>
-  struct is_not_related_to : aux::false_type {};
-};
-template <class...>
-struct any_of : aux::false_type {};
-template <class... TDeps>
-struct is_supported
-    : aux::is_same<aux::bool_list<aux::always<TDeps>::value...>,
-                   aux::bool_list<(aux::is_constructible<TDeps, TDeps&&>::value &&
-                                   (aux::is_a<core::injector_base, TDeps>::value ||
-                                    aux::is_a<core::dependency_base, TDeps>::value || aux::is_empty_expr<TDeps>::value))...>> {
-};
-template <class...>
-struct get_not_supported;
-template <class T>
-struct get_not_supported<T> {
-  using type = T;
-};
-template <class T, class... TDeps>
-struct get_not_supported<T, TDeps...>
-    : aux::conditional<aux::is_a<core::injector_base, T>::value || aux::is_a<core::dependency_base, T>::value,
-                       typename get_not_supported<TDeps...>::type, T> {};
-template <class>
-struct is_unique;
-template <class T, class = int>
-struct unique_dependency : aux::type<T> {};
-template <class T>
-struct unique_dependency<T, __BOOST_DI_REQUIRES(aux::is_a<core::dependency_base, T>::value)>
-    : aux::pair<aux::pair<typename T::expected, typename T::name>, typename T::priority> {};
-template <class... TDeps>
-struct is_unique<aux::type_list<TDeps...>> : aux::is_unique<typename unique_dependency<TDeps>::type...> {};
-template <class>
-struct get_is_unique_error_impl : aux::true_type {};
-template <class T, class TName, class TPriority>
-struct get_is_unique_error_impl<aux::not_unique<aux::pair<aux::pair<T, TName>, TPriority>>> {
-  using type = typename type_<T>::template named<TName>::is_bound_more_than_once;
-};
-template <class T, class TPriority>
-struct get_is_unique_error_impl<aux::not_unique<aux::pair<aux::pair<T, no_name>, TPriority>>> {
-  using type = typename type_<T>::is_bound_more_than_once;
-};
-template <class T>
-struct get_is_unique_error_impl<aux::not_unique<T>> {
-  using type = typename type_<T>::is_bound_more_than_once;
-};
-template <class>
-struct get_is_unique_error;
-template <class... TDeps>
-struct get_is_unique_error<aux::type_list<TDeps...>>
-    : get_is_unique_error_impl<typename aux::is_unique<typename unique_dependency<TDeps>::type...>::type> {};
-template <class... TDeps>
-using boundable_bindings =
-    aux::conditional_t<is_supported<TDeps...>::value, typename get_is_unique_error<core::bindings_t<TDeps...>>::type,
-                       typename type_<typename get_not_supported<TDeps...>::type>::is_neither_a_dependency_nor_an_injector>;
-template <class... Ts>
-struct get_any_of_error : aux::conditional<aux::is_same<aux::bool_list<aux::always<Ts>::value...>,
-                                                        aux::bool_list<aux::is_same<aux::true_type, Ts>::value...>>::value,
-                                           aux::true_type, any_of<Ts...>> {};
-template <bool, class...>
-struct is_related {
-  static constexpr auto value = true;
-};
-template <class I, class T>
-struct is_related<true, I, T> {
-  static constexpr auto value =
-      aux::is_base_of<I, T>::value || (aux::is_convertible<T, I>::value && !aux::is_narrowed<I, T>::value);
-};
-template <bool, class>
-struct is_abstract {
-  static constexpr auto value = false;
-};
-template <class T>
-struct is_abstract<true, T> {
-  static constexpr auto value = aux::is_abstract<T>::value;
-};
-auto boundable_impl(any_of<>&&) -> aux::true_type;
-template <class T, class... Ts>
-auto boundable_impl(any_of<T, Ts...>&&)
-    -> aux::conditional_t<aux::is_same<T, aux::decay_t<T>>::value, decltype(boundable_impl(aux::declval<any_of<Ts...>>())),
-                          typename type_<T>::has_disallowed_qualifiers>;
-template <class I, class T>
-using boundable_impl__ = aux::conditional_t<
-    is_related<aux::is_complete<I>::value && aux::is_complete<T>::value, I, T>::value,
-    aux::conditional_t<is_abstract<aux::is_complete<T>::value, T>::value, typename type_<T>::is_abstract, aux::true_type>,
-    typename type_<T>::template is_not_related_to<I>>;
-template <class I, class T>
-auto boundable_impl(I&&, T&&) -> aux::conditional_t<aux::is_same<T, aux::decay_t<T>>::value || !aux::is_complete<I>::value,
-                                                    boundable_impl__<I, T>, typename type_<T>::has_disallowed_qualifiers>;
-template <class I, class T>
-auto boundable_impl(I&&, T&&, aux::valid<>&&)
-    -> aux::conditional_t<is_related<aux::is_complete<I>::value && aux::is_complete<T>::value, I, T>::value, aux::true_type,
-                          typename type_<T>::template is_not_related_to<I>>;
-template <class I, class T>
-auto boundable_impl(I*[], T&&) -> aux::conditional_t<aux::is_same<I, aux::decay_t<I>>::value, boundable_impl__<I, T>,
-                                                     typename type_<I>::has_disallowed_qualifiers>;
-template <class I, class T>
-auto boundable_impl(I[], T&&) -> aux::conditional_t<aux::is_same<I, aux::decay_t<I>>::value, boundable_impl__<I, T>,
-                                                    typename type_<I>::has_disallowed_qualifiers>;
-template <class... TDeps>
-auto boundable_impl(aux::type_list<TDeps...>&&) -> boundable_bindings<TDeps...>;
-template <class T, class... Ts>
-auto boundable_impl(concepts::any_of<Ts...>&&, T&&) ->
-    typename get_any_of_error<decltype(boundable_impl(aux::declval<Ts>(), aux::declval<T>()))...>::type;
-template <class... TDeps>
-auto boundable_impl(aux::type<TDeps...>&&) -> typename get_is_unique_error_impl<typename aux::is_unique<TDeps...>::type>::type;
-aux::true_type boundable_impl(...);
-template <class... Ts>
-struct boundable__ {
-  using type = decltype(boundable_impl(aux::declval<Ts>()...));
-};
-template <class... Ts>
-using boundable = typename boundable__<Ts...>::type;
-}
-namespace type_traits {
-struct stack {};
-struct heap {};
-template <class T, class = int>
-struct memory_traits {
-  using type = stack;
-};
-template <class T>
-struct memory_traits<T*> {
-  using type = heap;
-};
-template <class T>
-struct memory_traits<const T&> {
-  using type = typename memory_traits<T>::type;
-};
-template <class T, class TDeleter>
-struct memory_traits<std::unique_ptr<T, TDeleter>> {
-  using type = heap;
-};
-template <class T>
-struct memory_traits<std::shared_ptr<T>> {
-  using type = heap;
-};
-template <class T>
-struct memory_traits<boost::shared_ptr<T>> {
-  using type = heap;
-};
-template <class T>
-struct memory_traits<std::weak_ptr<T>> {
-  using type = heap;
-};
-template <class T>
-struct memory_traits<T, __BOOST_DI_REQUIRES(aux::is_polymorphic<T>::value)> {
-  using type = heap;
-};
-}
-namespace concepts {
-template <class...>
-struct scope {
-  struct is_referable {};
-  struct try_create {};
-  struct create {};
-  template <class...>
-  struct requires_ : aux::false_type {};
-};
-template <class>
-struct scope__ {
-  template <class...>
-  struct scope {
-    template <class...>
-    using is_referable = aux::true_type;
-    template <class T, class, class TProvider>
-    T try_create(const TProvider&);
-    template <class T, class, class TProvider>
-    T create(const TProvider&);
-  };
-};
-template <class>
-struct config__ {
-  template <class T>
-  struct scope_traits {
-    using type = scope__<T>;
-  };
-  template <class T>
-  struct memory_traits {
-    using type = type_traits::heap;
-  };
-};
-template <class T>
-struct provider__ {
-  using config = config__<T>;
-  template <class TMemory = type_traits::heap>
-  aux::conditional_t<aux::is_same<TMemory, type_traits::stack>::value, T, T*> try_get(const TMemory& = {}) const;
-  template <class TMemory = type_traits::heap>
-  T* get(const TMemory& = {}) const {
-    return nullptr;
-  }
-  config& cfg() const;
-};
-template <class T>
-typename scope<T>::template requires_<typename scope<_, _>::is_referable, typename scope<_, _>::try_create,
-                                      typename scope<_, _>::create>
-scopable_impl(...);
-template <class T>
-auto scopable_impl(T&&)
-    -> aux::is_valid_expr<typename T::template scope<_, _>::template is_referable<_, config__<_>>,
-                          decltype(T::template scope<_, _>::template try_create<_, _>(provider__<_>{})),
-                          decltype(aux::declval<typename T::template scope<_, _>>().template create<_, _>(provider__<_>{}))>;
-template <class T>
-struct scopable__ {
-  using type = decltype(scopable_impl<T>(aux::declval<T>()));
-};
-template <class T>
-using scopable = typename scopable__<T>::type;
-}
-namespace core {
-template <class = aux::type_list<>>
-struct pool;
-template <class... TArgs>
-using pool_t = pool<aux::type_list<TArgs...>>;
-template <class... TArgs>
-struct pool<aux::type_list<TArgs...>> : TArgs... {
-  template <class... Ts>
-  explicit pool(Ts... args) noexcept : Ts(static_cast<Ts&&>(args))... {}
-  template <class... Ts, class TPool>
-  pool(const aux::type_list<Ts...>&, TPool p) noexcept : pool(static_cast<Ts&&>(p)...) {
-    (void)p;
-  }
-  template <class T>
-  pool& operator=(T&& other) noexcept {
-    (void)aux::swallow{0, (static_cast<TArgs&>(*this).operator=(static_cast<TArgs&&>(other)), 0)...};
-    return *this;
-  }
-};
-}
-#if !defined(BOOST_DI_CFG_CTOR_LIMIT_SIZE)
-#define BOOST_DI_CFG_CTOR_LIMIT_SIZE 10
-#endif
-namespace type_traits {
-template <class, class = int>
-struct is_injectable : ::boost::ext::di::v1_3_0::aux::false_type {};
-template <class T>
-struct is_injectable<T, ::boost::ext::di::v1_3_0::aux::valid_t<typename T::boost_di_inject__>>
-    : ::boost::ext::di::v1_3_0::aux::true_type {};
-struct direct {};
-struct uniform {};
-template <class T, int>
-using get = T;
-template <template <class...> class, class, class, class = int>
-struct ctor_impl;
-template <template <class...> class TIsConstructible, class T>
-struct ctor_impl<TIsConstructible, T, aux::index_sequence<>> : aux::type_list<> {};
-template <template <class...> class TIsConstructible, class T>
-struct ctor_impl<TIsConstructible, T, aux::index_sequence<0>,
-                 __BOOST_DI_REQUIRES(TIsConstructible<T, core::any_type_1st_fwd<T>>::value)>
-    : aux::type_list<core::any_type_1st_fwd<T>> {};
-template <template <class...> class TIsConstructible, class T>
-struct ctor_impl<TIsConstructible, T, aux::index_sequence<0>,
-                 __BOOST_DI_REQUIRES(!TIsConstructible<T, core::any_type_1st_fwd<T>>::value)>
-    : aux::conditional_t<TIsConstructible<T, core::any_type_1st_ref_fwd<T>>::value,
-                         aux::type_list<core::any_type_1st_ref_fwd<T>>, aux::type_list<>> {};
-template <template <class...> class TIsConstructible, class T, int... Ns>
-struct ctor_impl<TIsConstructible, T, aux::index_sequence<Ns...>,
-                 __BOOST_DI_REQUIRES((sizeof...(Ns) > 1) && TIsConstructible<T, get<core::any_type_fwd<T>, Ns>...>::value)>
-    : aux::type_list<get<core::any_type_fwd<T>, Ns>...> {};
-template <template <class...> class TIsConstructible, class T, int... Ns>
-struct ctor_impl<TIsConstructible, T, aux::index_sequence<Ns...>,
-                 __BOOST_DI_REQUIRES((sizeof...(Ns) > 1) && !TIsConstructible<T, get<core::any_type_fwd<T>, Ns>...>::value)>
-    : aux::conditional<TIsConstructible<T, get<core::any_type_ref_fwd<T>, Ns>...>::value,
-                       aux::type_list<get<core::any_type_ref_fwd<T>, Ns>...>,
-                       typename ctor_impl<TIsConstructible, T, aux::make_index_sequence<sizeof...(Ns) - 1>>::type> {};
-template <template <class...> class TIsConstructible, class T>
-using ctor_impl_t = typename ctor_impl<TIsConstructible, T, aux::make_index_sequence<BOOST_DI_CFG_CTOR_LIMIT_SIZE>>::type;
-template <class...>
-struct ctor;
-template <class T>
-struct ctor<T, aux::type_list<>> : aux::pair<uniform, ctor_impl_t<aux::is_braces_constructible, T>> {};
-template <class T, class... TArgs>
-struct ctor<T, aux::type_list<TArgs...>> : aux::pair<direct, aux::type_list<TArgs...>> {};
-template <class T, class, class = typename is_injectable<ctor_traits<T>>::type>
-struct ctor_traits_impl;
-template <class T, class = void, class = void, class = typename is_injectable<T>::type>
-struct ctor_traits__;
-template <class T, class _1, class _2>
-struct ctor_traits__<T, _1, _2, aux::true_type> : aux::pair<T, aux::pair<direct, typename T::boost_di_inject__::type>> {};
-template <class T, class _1, class _2>
-struct ctor_traits__<T, _1, _2, aux::false_type> : ctor_traits_impl<T, _1> {};
-template <class T, class _1, class... Ts>
-struct ctor_traits__<T, _1, core::pool_t<Ts...>, aux::false_type> : aux::pair<T, aux::pair<uniform, aux::type_list<Ts...>>> {};
-template <class T, class _>
-struct ctor_traits_impl<T, _, aux::true_type>
-    : aux::pair<T, aux::pair<direct, typename ctor_traits<T>::boost_di_inject__::type>> {};
-template <class T, class _>
-struct ctor_traits_impl<T, _, aux::false_type> : aux::pair<T, typename ctor_traits<T>::type> {};
-}
-template <class T, class>
-struct ctor_traits : type_traits::ctor<T, type_traits::ctor_impl_t<aux::is_constructible, T>> {};
-template <class T>
-struct ctor_traits<std::initializer_list<T>> {
-  using boost_di_inject__ = aux::type_list<>;
-};
-template <class... Ts>
-struct ctor_traits<std::tuple<Ts...>> {
-  using boost_di_inject__ = aux::type_list<Ts...>;
-};
-template <class T>
-struct ctor_traits<T, __BOOST_DI_REQUIRES(aux::is_same<std::char_traits<char>, typename T::traits_type>::value)> {
-  using boost_di_inject__ = aux::type_list<>;
-};
-template <class T>
-struct ctor_traits<T, __BOOST_DI_REQUIRES(!aux::is_class<T>::value)> {
-  using boost_di_inject__ = aux::type_list<>;
-};
-namespace type_traits {
-template <class T>
-struct remove_named {
-  using type = T;
-};
-template <class TName, class T>
-struct remove_named<named<TName, T>> {
-  using type = T;
-};
-template <class T>
-using remove_named_t = typename remove_named<T>::type;
-template <class T>
-struct add_named {
-  using type = named<no_name, T>;
-};
-template <class TName, class T>
-struct add_named<named<TName, T>> {
-  using type = named<TName, T>;
-};
-template <class T>
-using add_named_t = typename add_named<T>::type;
-template <class T>
-struct named_decay {
-  using type = aux::decay_t<T>;
-};
-template <class TName, class T>
-struct named_decay<named<TName, T>> {
-  using type = named<TName, aux::decay_t<T>>;
-};
-template <class T>
-using named_decay_t = typename named_decay<T>::type;
-}
-namespace type_traits {
-template <class, class T>
-struct rebind_traits {
-  using type = T;
-};
-template <class T, class TName, class _>
-struct rebind_traits<T, named<TName, _>> {
-  using type = named<TName, T>;
-};
-template <class T, class D, class U>
-struct rebind_traits<std::unique_ptr<T, D>, U> {
-  using type = std::unique_ptr<U, D>;
-};
-template <class T, class D, class TName, class _>
-struct rebind_traits<std::unique_ptr<T, D>, named<TName, _>> {
-  using type = named<TName, std::unique_ptr<T, D>>;
-};
-template <class T, class U>
-struct rebind_traits<std::shared_ptr<T>, U> {
-  using type = std::shared_ptr<U>;
-};
-template <class T, class TName, class _>
-struct rebind_traits<std::shared_ptr<T>, named<TName, _>> {
-  using type = named<TName, std::shared_ptr<T>>;
-};
-template <class T, class U>
-struct rebind_traits<std::weak_ptr<T>, U> {
-  using type = std::weak_ptr<U>;
-};
-template <class T, class TName, class _>
-struct rebind_traits<std::weak_ptr<T>, named<TName, _>> {
-  using type = named<TName, std::weak_ptr<T>>;
-};
-template <class T, class U>
-struct rebind_traits<boost::shared_ptr<T>, U> {
-  using type = boost::shared_ptr<U>;
-};
-template <class T, class TName, class _>
-struct rebind_traits<boost::shared_ptr<T>, named<TName, _>> {
-  using type = named<TName, boost::shared_ptr<T>>;
-};
-template <class T, class U>
-using rebind_traits_t = typename rebind_traits<T, U>::type;
-}
-namespace core {
-template <class T, class... Ts>
-struct array_impl : _ {
-  using boost_di_inject__ = aux::type_list<Ts...>;
-  explicit array_impl(type_traits::remove_named_t<Ts>&&... args)
-      : array{static_cast<type_traits::remove_named_t<Ts>&&>(args)...} {}
-  T array[sizeof...(Ts)];
-};
-template <class T, class... Ts>
-struct array<T(), Ts...> : T {
-  using value_type = typename aux::identity<T>::type::value_type;
-  using array_t = array_impl<value_type, type_traits::rebind_traits_t<value_type, Ts>...>;
-  using boost_di_inject__ = aux::type_list<array_t&&>;
-  template <__BOOST_DI_REQUIRES(
-                aux::is_constructible<T, std::move_iterator<value_type*>, std::move_iterator<value_type*>>::value) = 0>
-  explicit array(array_t&& a)
-      : T(std::move_iterator<value_type*>(a.array), std::move_iterator<value_type*>(a.array + sizeof...(Ts))) {}
-};
-template <class T>
-struct array<T()> : T {
-  using boost_di_inject__ = aux::type_list<>;
-};
-template <class T>
-struct array<T> {};
-}
-namespace type_traits {
-template <class _, class T, class _1, class... Ts>
-struct ctor_traits__<core::array<_, Ts...>, T, _1, aux::false_type>
-    : type_traits::ctor_traits__<core::array<aux::remove_smart_ptr_t<aux::remove_qualifiers_t<T>>(), Ts...>> {};
-}
-namespace scopes {
-class deduce {
- public:
-  template <class TExpected, class TGiven>
-  class scope {
-   public:
-    template <class T, class TConfig>
-    using is_referable =
-        typename TConfig::template scope_traits<T>::type::template scope<TExpected, TGiven>::template is_referable<T, TConfig>;
-    template <class T, class TName, class TProvider>
-    static decltype(typename TProvider::config::template scope_traits<T>::type::template scope<TExpected, TGiven>{}
-                        .template try_create<T, TName>(aux::declval<TProvider>()))
-    try_create(const TProvider&);
-    template <class T, class TName, class TProvider>
-    auto create(const TProvider& provider) {
-      using scope_traits = typename TProvider::config::template scope_traits<T>::type;
-      using scope = typename scope_traits::template scope<TExpected, TGiven>;
-      return scope{}.template create<T, TName>(provider);
-    }
-  };
-};
-}
-static constexpr __BOOST_DI_UNUSED scopes::deduce deduce{};
-namespace concepts {
-template <class T>
-struct abstract_type {
-  struct is_not_bound {
-    operator T*() const {
-      using constraint_not_satisfied = is_not_bound;
-      return constraint_not_satisfied{}.error();
-    }
-    // clang-format off
-    static inline T*
- error(_ = "type is not bound, did you forget to add: 'di::bind<interface>.to<implementation>()'?");
-    // clang-format on
-  };
-  template <class TName>
-  struct named {
-    struct is_not_bound {
-      operator T*() const {
-        using constraint_not_satisfied = is_not_bound;
-        return constraint_not_satisfied{}.error();
-      }
-      // clang-format off
-      static inline T*
-   error(_ = "type is not bound, did you forget to add: 'di::bind<interface>.named(name).to<implementation>()'?");
-      // clang-format on
-    };
-  };
-};
-template <class TScope, class T>
-struct scoped {
-  template <class To>
-  struct is_not_convertible_to {
-    operator To() const {
-      using constraint_not_satisfied = is_not_convertible_to;
-      return constraint_not_satisfied{}.error();
-    }
-    // clang-format off
-    static inline To
- error(_ = "scoped object is not convertible to the requested type, did you mistake the scope: 'di::bind<T>.in(scope)'?");
-    // clang-format on
-  };
-};
-template <class T>
-struct scoped<scopes::instance, T> {
-  template <class To>
-  struct is_not_convertible_to {
-    operator To() const {
-      using constraint_not_satisfied = is_not_convertible_to;
-      return constraint_not_satisfied{}.error();
-    }
-    // clang-format off
-    static inline To
- error(_ = "instance is not convertible to the requested type, verify binding: 'di::bind<T>.to(value)'?");
-    // clang-format on
-  };
-};
-template <class T>
-struct type {
-  struct has_ambiguous_number_of_constructor_parameters {
-    template <int Given>
-    struct given {
-      template <int Expected>
-      struct expected {
-        operator T*() const {
-          using constraint_not_satisfied = expected;
-          return constraint_not_satisfied{}.error();
-        }
-        // clang-format off
-        static inline T*
-  error(_ = "verify BOOST_DI_INJECT_TRAITS or di::ctor_traits");
-        // clang-format on
-      };
-    };
-  };
-  struct has_to_many_constructor_parameters {
-    template <int TMax>
-    struct max {
-      operator T*() const {
-        using constraint_not_satisfied = max;
-        return constraint_not_satisfied{}.error();
-      }
-      // clang-format off
-      static inline T*
-   error(_ = "increase BOOST_DI_CFG_CTOR_LIMIT_SIZE value or reduce number of constructor parameters");
-      // clang-format on
-    };
-  };
-  struct is_not_exposed {
-    operator T() const {
-      using constraint_not_satisfied = is_not_exposed;
-      return constraint_not_satisfied{}.error();
-    }
-    // clang-format off
-      static inline T
-   error(_ = "type is not exposed, did you forget to add: 'di::injector<T>'?");
-    // clang-format on
-  };
-  template <class TName>
-  struct named {
-    struct is_not_exposed {
-      operator T() const {
-        using constraint_not_satisfied = is_not_exposed;
-        return constraint_not_satisfied{}.error();
-      }
-      // clang-format off
-      static inline T
-   error(_ = "type is not exposed, did you forget to add: 'di::injector<BOOST_DI_EXPOSE((named = name)T)>'?");
-      // clang-format on
-    };
-  };
-};
-template <class>
-struct ctor_size;
-template <class TInit, class... TCtor>
-struct ctor_size<aux::pair<TInit, aux::type_list<TCtor...>>> : aux::integral_constant<int, sizeof...(TCtor)> {};
-template <class... TCtor>
-struct ctor_size<aux::type_list<TCtor...>> : aux::integral_constant<int, sizeof...(TCtor)> {};
-template <class T>
-using ctor_size_t = ctor_size<typename type_traits::ctor<T, type_traits::ctor_impl_t<aux::is_constructible, T>>::type>;
-template <class TInitialization, class TName, class _, class TCtor, class T = aux::decay_t<_>>
-struct creatable_error_impl
-    : aux::conditional_t<
-          aux::is_polymorphic<T>::value,
-          aux::conditional_t<aux::is_same<TName, no_name>::value, typename abstract_type<T>::is_not_bound,
-                             typename abstract_type<T>::template named<TName>::is_not_bound>,
-          aux::conditional_t<ctor_size_t<T>::value == ctor_size<TCtor>::value,
-                             typename type<T>::has_to_many_constructor_parameters::template max<BOOST_DI_CFG_CTOR_LIMIT_SIZE>,
-                             typename type<T>::has_ambiguous_number_of_constructor_parameters::template given<
-                                 ctor_size<TCtor>::value>::template expected<ctor_size_t<T>::value>>> {};
-template <class TInit, class T, class... TArgs>
-struct creatable {
-  static constexpr auto value = aux::is_constructible<T, TArgs...>::value;
-};
-template <class T, class... TArgs>
-struct creatable<type_traits::uniform, T, TArgs...> {
-  static constexpr auto value = aux::is_braces_constructible<T, TArgs...>::value;
-};
-template <class TInitialization, class TName, class T, class... TArgs>
-T creatable_error() {
-  return creatable_error_impl<TInitialization, TName, T, aux::type_list<TArgs...>>{};
-}
-}
-namespace wrappers {
-template <class TScope, class T, class TObject = std::shared_ptr<T>>
-struct shared {
-  using scope = TScope;
-  template <class>
-  struct is_referable_impl : aux::true_type {};
-  template <class I>
-  struct is_referable_impl<std::shared_ptr<I>> : aux::is_same<I, T> {};
-  template <class I>
-  struct is_referable_impl<boost::shared_ptr<I>> : aux::false_type {};
-  template <class T_>
-  using is_referable = is_referable_impl<aux::remove_qualifiers_t<T_>>;
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator std::shared_ptr<I>() const noexcept {
-    return object;
-  }
-  inline operator std::shared_ptr<T>&() noexcept { return object; }
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator boost::shared_ptr<I>() const noexcept {
-    struct sp_holder {
-      std::shared_ptr<T> object;
-      void operator()(...) noexcept { object.reset(); }
-    };
-    return {object.get(), sp_holder{object}};
-  }
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator std::weak_ptr<I>() const noexcept {
-    return object;
-  }
-  inline operator T&() noexcept { return *object; }
-  inline operator const T&() const noexcept { return *object; }
-  TObject object;
-};
-template <class TScope, class T>
-struct shared<TScope, T&> {
-  using scope = TScope;
-  template <class>
-  struct is_referable : aux::true_type {};
-  explicit shared(T& object) : object(&object) {}
-  template <class I>
-  explicit shared(I);
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T, I>::value) = 0>
-  inline operator I() const noexcept {
-    return *object;
-  }
-  inline operator T&() const noexcept { return *object; }
-  T* object = nullptr;
-};
-}
-namespace wrappers {
-template <class TScope, class T>
-struct unique {
-  using scope = TScope;
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T, I>::value) = 0>
-  inline operator I() const noexcept {
-    return object;
-  }
-  inline operator T&&() noexcept { return static_cast<T&&>(object); }
-  T object;
-};
-template <class TScope, class T>
-struct unique<TScope, T*> {
-  using scope = TScope;
-#if defined(__MSVC__)
-  explicit unique(T* object) : object(object) {}
-#endif
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T, I>::value) = 0>
-  inline operator I() const noexcept {
-    struct scoped_ptr {
-      aux::owner<T*> ptr;
-      ~scoped_ptr() noexcept { delete ptr; }
-    };
-    return static_cast<T&&>(*scoped_ptr{object}.ptr);
-  }
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator aux::owner<I*>() const noexcept {
-    return object;
-  }
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, const I*>::value) = 0>
-  inline operator aux::owner<const I*>() const noexcept {
-    return object;
-  }
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator std::shared_ptr<I>() const noexcept {
-    return std::shared_ptr<I>{object};
-  }
-  template <class I, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator boost::shared_ptr<I>() const noexcept {
-    return boost::shared_ptr<I>{object};
-  }
-  template <class I, class D, __BOOST_DI_REQUIRES(aux::is_convertible<T*, I*>::value) = 0>
-  inline operator std::unique_ptr<I, D>() const noexcept {
-    return std::unique_ptr<I, D>{object};
-  }
-  T* object = nullptr;
-};
-}
-namespace scopes {
-class instance;
-namespace detail {
-template <class T, class TExpected, class TGiven>
-struct arg {
-  using type = T;
-  using expected = TExpected;
-  using given = TGiven;
-};
-template <class T>
-struct wrapper_traits {
-  using type = wrappers::unique<instance, T>;
-};
-template <class T>
-struct wrapper_traits<std::shared_ptr<T>> {
-  using type = wrappers::shared<instance, T>;
-};
-template <class T>
-using wrapper_traits_t = typename wrapper_traits<T>::type;
-template <class, class = int>
-struct has_result_type : ::boost::ext::di::v1_3_0::aux::false_type {};
-template <class T>
-struct has_result_type<T, ::boost::ext::di::v1_3_0::aux::valid_t<typename T::result_type>>
-    : ::boost::ext::di::v1_3_0::aux::true_type {};
-template <class TGiven, class TProvider, class... Ts>
-struct is_expr : aux::integral_constant<bool, aux::is_invocable<TGiven, typename TProvider::injector, Ts...>::value &&
-                                                  !has_result_type<TGiven>::value> {};
-}
-template <class T>
-struct wrapper {
-  inline operator T() noexcept { return static_cast<T&&>(object); }
-  T object;
-};
-class instance {
- public:
-  template <class, class TGiven, class = int>
-  struct scope {
-    template <class...>
-    using is_referable = aux::false_type;
-    explicit scope(const TGiven& object) : object_{object} {}
-    template <class, class, class TProvider>
-    static wrappers::unique<instance, TGiven> try_create(const TProvider&);
-    template <class, class, class TProvider>
-    auto create(const TProvider&) const noexcept {
-      return wrappers::unique<instance, TGiven>{object_};
-    }
-    TGiven object_;
-  };
-  template <class TExpected, class TGiven>
-  struct scope<TExpected, std::shared_ptr<TGiven>> {
-    template <class T, class>
-    using is_referable = typename wrappers::shared<instance, TGiven>::template is_referable<aux::remove_qualifiers_t<T>>;
-    explicit scope(const std::shared_ptr<TGiven>& object) : object_{object} {}
-    template <class, class, class TProvider>
-    static wrappers::shared<instance, TGiven> try_create(const TProvider&);
-    template <class, class, class TProvider>
-    auto create(const TProvider&) const noexcept {
-      return wrappers::shared<instance, TGiven>{object_};
-    }
-    std::shared_ptr<TGiven> object_;
-  };
-  template <class TExpected, class TGiven>
-  struct scope<TExpected, std::initializer_list<TGiven>> {
-    template <class...>
-    using is_referable = aux::false_type;
-    scope(const std::initializer_list<TGiven>& object) : object_(object) {}
-    template <class, class, class TProvider>
-    static std::initializer_list<TGiven> try_create(const TProvider&);
-    template <class, class, class TProvider>
-    auto create(const TProvider&) const noexcept {
-      return wrappers::unique<instance, std::initializer_list<TGiven>>{object_};
-    }
-    std::initializer_list<TGiven> object_;
-  };
-  template <class TExpected, class TGiven>
-  struct scope<TExpected, TGiven&, __BOOST_DI_REQUIRES(!aux::is_callable<TGiven>::value)> {
-    template <class...>
-    using is_referable = aux::true_type;
-    explicit scope(TGiven& object) : object_{object} {}
-    template <class, class, class TProvider>
-    static wrappers::shared<instance, TGiven&> try_create(const TProvider&);
-    template <class, class, class TProvider>
-    auto create(const TProvider&) const noexcept {
-      return object_;
-    }
-    wrappers::shared<instance, TGiven&> object_;
-  };
-  template <class TExpected, class TGiven>
-  struct scope<TExpected, TGiven, __BOOST_DI_REQUIRES(aux::is_callable<TGiven>::value)> {
-    template <class...>
-    using is_referable =
-        aux::integral_constant<bool, !aux::is_callable<TExpected>::value || !detail::has_result_type<TExpected>::value>;
-    explicit scope(const TGiven& object) : object_(object) {}
-#if defined(__MSVC__)
-    template <class T, class, class TProvider>
-    static T try_create(const TProvider&) noexcept;
-#else
-    template <class, class, class TProvider,
-              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_callable<TGiven>::value &&
-                                  aux::is_callable<TExpected>::value) = 0>
-    static wrappers::unique<instance, TExpected> try_create(const TProvider&) noexcept;
-    template <class T, class, class TProvider,
-              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_invocable<TGiven>::value &&
-                                  !aux::is_callable<TExpected>::value) = 0>
-    static auto try_create(const TProvider&) noexcept
-        -> detail::wrapper_traits_t<decltype(aux::declval<typename aux::identity<TGiven, T>::type>()())>;
-    template <class, class, class TProvider, __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider>::value) = 0>
-    static detail::wrapper_traits_t<decltype(aux::declval<TGiven>()(aux::declval<typename TProvider::injector>()))> try_create(
-        const TProvider&) noexcept;
-    template <class T, class, class TProvider,
-              __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider, const detail::arg<T, TExpected, TGiven>&>::value) = 0>
-    static detail::wrapper_traits_t<decltype(aux::declval<TGiven>()(aux::declval<typename TProvider::injector>(),
-                                                                    aux::declval<detail::arg<T, TExpected, TGiven>>()))>
-    try_create(const TProvider&) noexcept;
-#endif
-    template <class, class, class TProvider,
-              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_callable<TGiven>::value &&
-                                  aux::is_callable<TExpected>::value) = 0>
-    auto create(const TProvider&) const noexcept {
-      return wrappers::unique<instance, TExpected>{object_};
-    }
-    template <class T, class, class TProvider,
-              __BOOST_DI_REQUIRES(!detail::is_expr<TGiven, TProvider>::value && aux::is_invocable<TGiven>::value &&
-                                  !aux::is_callable<TExpected>::value) = 0>
-    auto create(const TProvider&) const {
-      using wrapper = detail::wrapper_traits_t<decltype(aux::declval<TGiven>()())>;
-      return wrapper{object_()};
-    }
-    template <class, class, class TProvider, __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider>::value) = 0>
-    auto create(const TProvider& provider) {
-      using wrapper = detail::wrapper_traits_t<decltype((object_)(provider.super()))>;
-      return wrapper{(object_)(provider.super())};
-    }
-    template <class T, class, class TProvider,
-              __BOOST_DI_REQUIRES(detail::is_expr<TGiven, TProvider, const detail::arg<T, TExpected, TGiven>&>::value) = 0>
-    auto create(const TProvider& provider) {
-      using wrapper = detail::wrapper_traits_t<decltype((object_)(provider.super(), detail::arg<T, TExpected, TGiven>{}))>;
-      return wrapper{(object_)(provider.super(), detail::arg<T, TExpected, TGiven>{})};
-    }
-    TGiven object_;
-  };
-  template <class _, class... Ts>
-  class scope<_, aux::type_list<Ts...>> {
-    template <class>
-    struct injector__;
-    template <class TName, class T>
-    struct injector__<named<TName, T>> {
-      T (*f)(const injector__*) = nullptr;
-      explicit injector__(const decltype(f)& ptr) : f(ptr) {}
-    };
-    struct injector : injector__<Ts>... {
-      void (*dtor)(injector*) = nullptr;
-      ~injector() noexcept { static_cast<injector*>(this)->dtor(this); }
-      template <class TName, class T>
-      T create(const named<TName, T>&, const aux::true_type&) const {
-        return static_cast<const injector__<named<TName, T>>*>(this)->f(static_cast<const injector__<named<TName, T>>*>(this));
-      }
-      template <class T>
-      T create(const named<no_name, T>&, const aux::false_type&) const {
-        return typename concepts::type<T>::is_not_exposed{};
-      }
-      template <class TName, class T>
-      T create(const named<TName, T>&, const aux::false_type&) const {
-        return typename concepts::type<T>::template named<TName>::is_not_exposed{};
-      }
-    };
-    template <class TInjector>
-    class injector_impl : injector__<Ts>... {
-      void (*dtor)(injector_impl*) = nullptr;
-      static void dtor_impl(injector_impl* object) { object->~injector_impl(); }
-      template <class, class>
-      struct create;
-      template <class TName, class T>
-      struct create<named<TName, T>, aux::true_type> {
-        static T impl(const injector__<named<TName, T>>* object) {
-          using type = aux::type<aux::conditional_t<aux::is_same<TName, no_name>::value, T, named<TName, T>>>;
-          return static_cast<const core::injector__<TInjector>&>(static_cast<const injector_impl*>(object)->injector_)
-              .create_successful_impl(type{});
-        }
-      };
-      template <class TName, class T>
-      struct create<named<TName, T>, aux::false_type> {
-        static T impl(const injector__<named<TName, T>>* object) {
-          using type = aux::type<aux::conditional_t<aux::is_same<TName, no_name>::value, T, named<TName, T>>>;
-          return static_cast<const core::injector__<TInjector>&>(static_cast<const injector_impl*>(object)->injector_)
-              .create_impl(type{});
-        }
-      };
-      template <class T>
-      struct is_creatable : aux::integral_constant<bool, core::injector__<TInjector>::template is_creatable<T>::value> {};
-      template <class TName, class T>
-      struct is_creatable<named<TName, T>>
-          : aux::integral_constant<bool, core::injector__<TInjector>::template is_creatable<T, TName>::value> {};
-
-     public:
-      explicit injector_impl(TInjector&& injector) noexcept
-          : injector__<Ts>(&injector_impl::template create<Ts, typename is_creatable<Ts>::type>::impl)...,
-            dtor(&injector_impl::dtor_impl),
-            injector_(static_cast<TInjector&&>(injector)) {}
-
-     private:
-      TInjector injector_;
-    };
-
-   public:
-    template <class...>
-    using is_referable = aux::true_type;
-    template <class TInjector, __BOOST_DI_REQUIRES(aux::is_a<core::injector_base, TInjector>::value) = 0>
-    explicit scope(TInjector&& i) noexcept : injector_((injector*)new injector_impl<TInjector>{static_cast<TInjector&&>(i)}) {}
-    scope(scope&& other) noexcept : injector_(other.injector_) { other.injector_ = nullptr; }
-    ~scope() noexcept { delete injector_; }
-    template <class T, class TName, class TProvider>
-    static aux::conditional_t<aux::is_base_of<injector__<named<TName, T>>, injector>::value, T, void> try_create(
-        const TProvider&);
-    template <class T, class TName, class TProvider>
-    auto create(const TProvider&) {
-      return wrapper<T>{injector_->create(named<TName, T>{}, aux::is_base_of<injector__<named<TName, T>>, injector>{})};
-    }
-
-   private:
-    injector* injector_;
-  };
-};
-}
-namespace core {
-template <class, int, class T>
-struct ctor_arg {
-  explicit ctor_arg(T&& t) : value(static_cast<T&&>(t)) {}
-  constexpr operator T() const { return value; }
-
- private:
-  T value;
-};
-template <class, class>
-struct dependency_concept {};
-template <class T, class TDependency>
-struct dependency_impl : aux::pair<T, TDependency> {};
-template <class T>
-struct make_dependency_concept {
-  using type = dependency_concept<T, no_name>;
-};
-template <class TName, class T>
-struct make_dependency_concept<named<TName, T>> {
-  using type = dependency_concept<T, TName>;
-};
-template <class... Ts, class TName, class TDependency>
-struct dependency_impl<dependency_concept<concepts::any_of<Ts...>, TName>, TDependency>
-    : aux::pair<dependency_concept<Ts, TName>, TDependency>... {};
-template <class... Ts, class TDependency>
-struct dependency_impl<dependency_concept<aux::type_list<Ts...>, no_name>, TDependency>
-    : aux::pair<typename make_dependency_concept<Ts>::type, TDependency>... {};
-struct override {};
-template <class TScope, class TExpected, class TGiven, class TName, class TPriority, class TCtor>
-class dependency : dependency_base,
-                   public TScope::template scope<TExpected, TGiven>,
-                   public dependency_impl<dependency_concept<TExpected, TName>,
-                                          dependency<TScope, TExpected, TGiven, TName, TPriority, TCtor>>,
-                   protected TCtor {
-  template <class, class, class, class, class, class>
-  friend class dependency;
-  using scope_t = typename TScope::template scope<TExpected, TGiven>;
-  template <class T>
-  using externable = aux::integral_constant<bool, aux::always<T>::value && aux::is_same<TScope, scopes::deduce>::value &&
-                                                      aux::is_same<TExpected, TGiven>::value>;
-  template <class T>
-  struct ref_traits {
-    using type = T;
-  };
-  template <int N>
-  struct ref_traits<const char (&)[N]> {
-    using type = TExpected;
-  };
-  template <class R, class... Ts>
-  struct ref_traits<R (&)(Ts...)> {
-    using type = TExpected;
-  };
-  template <class T>
-  struct ref_traits<std::shared_ptr<T>&> {
-    using type = std::shared_ptr<T>;
-  };
-  template <class T, class>
-  struct deduce_traits {
-    using type = T;
-  };
-  template <class T>
-  struct deduce_traits<deduced, T> {
-    using type = aux::decay_t<T>;
-  };
-  template <class T, class U>
-  using deduce_traits_t = typename deduce_traits<T, U>::type;
-  template <class TParent, int N, class T>
-  using ctor_arg_traits = ctor_arg<TParent, N, T>;
-
- public:
-  using scope = TScope;
-  using expected = TExpected;
-  using given = TGiven;
-  using name = TName;
-  using priority = TPriority;
-  using ctor = TCtor;
-  dependency() noexcept {}
-  template <class T>
-  explicit dependency(T&& object) noexcept : scope_t(static_cast<T&&>(object)) {}
-  explicit dependency(TCtor&& ctor) noexcept : TCtor{static_cast<TCtor&&>(ctor)} {}
-  template <class T, __BOOST_DI_REQUIRES(aux::is_same<TName, no_name>::value && !aux::is_same<T, no_name>::value) = 0>
-  auto named() noexcept {
-    return dependency<TScope, TExpected, TGiven, T, TPriority, TCtor>{static_cast<dependency&&>(*this)};
-  }
-  template <class T, __BOOST_DI_REQUIRES(aux::is_same<TName, no_name>::value && !aux::is_same<T, no_name>::value) = 0>
-  auto named(const T&) noexcept {
-    return dependency<TScope, TExpected, TGiven, T, TPriority, TCtor>{static_cast<dependency&&>(*this)};
-  }
-  template <class T, __BOOST_DI_REQUIRES_MSG(concepts::scopable<T>) = 0>
-  auto in(const T&) noexcept {
-    return dependency<T, TExpected, TGiven, TName, TPriority, TCtor>{};
-  }
-  template <class T, __BOOST_DI_REQUIRES(!aux::is_array<TExpected, T>::value) = 0,
-            __BOOST_DI_REQUIRES_MSG(concepts::boundable<TExpected, T>) = 0>
-  auto to() noexcept {
-    return dependency<TScope, TExpected, T, TName, TPriority, TCtor>{};
-  }
-  template <class... Ts, __BOOST_DI_REQUIRES(aux::is_array<TExpected, Ts...>::value) = 0>
-  auto to() noexcept {
-    using type = aux::remove_pointer_t<aux::remove_extent_t<TExpected>>;
-    return dependency<TScope, array<type>, array<type, Ts...>, TName, TPriority, TCtor>{};
-  }
-  template <class T, __BOOST_DI_REQUIRES_MSG(concepts::boundable<TExpected, T>) = 0>
-  auto to(std::initializer_list<T> il) noexcept {
-    using type = aux::remove_pointer_t<aux::remove_extent_t<TExpected>>;
-    using dependency = dependency<scopes::instance, array<type>, std::initializer_list<T>, TName, TPriority, TCtor>;
-    return dependency{il};
-  }
-  template <class T, __BOOST_DI_REQUIRES(externable<T>::value && !aux::is_callable<T>::value) = 0,
-            __BOOST_DI_REQUIRES_MSG(concepts::boundable<deduce_traits_t<TExpected, T>, aux::decay_t<T>, aux::valid<>>) = 0>
-  auto to(T&& object) noexcept {
-    using dependency =
-        dependency<scopes::instance, deduce_traits_t<TExpected, T>, typename ref_traits<T>::type, TName, TPriority, TCtor>;
-    return dependency{static_cast<T&&>(object)};
-  }
-  template <class T, __BOOST_DI_REQUIRES(externable<T>::value&& aux::is_callable<T>::value) = 0>
-  auto to(T&& object) noexcept {
-    using dependency =
-        dependency<scopes::instance, deduce_traits_t<TExpected, T>, typename ref_traits<T>::type, TName, TPriority, TCtor>;
-    return dependency{static_cast<T&&>(object)};
-  }
-  template <class TConcept, class T, __BOOST_DI_REQUIRES(externable<T>::value && !aux::is_callable<T>::value) = 0,
-            __BOOST_DI_REQUIRES_MSG(concepts::boundable<deduce_traits_t<TExpected, T>, aux::decay_t<T>, aux::valid<>>) = 0>
-  auto to(T&& object) noexcept {
-    using dependency = dependency<scopes::instance, deduce_traits_t<concepts::any_of<TExpected, TConcept>, T>,
-                                  typename ref_traits<T>::type, TName, TPriority, TCtor>;
-    return dependency{static_cast<T&&>(object)};
-  }
-  template <class TConcept, class T, __BOOST_DI_REQUIRES(externable<T>::value&& aux::is_callable<T>::value) = 0>
-  auto to(T&& object) noexcept {
-    using dependency = dependency<scopes::instance, deduce_traits_t<concepts::any_of<TExpected, TConcept>, T>,
-                                  typename ref_traits<T>::type, TName, TPriority, TCtor>;
-    return dependency{static_cast<T&&>(object)};
-  }
-  template <class T, class... Ts, __BOOST_DI_REQUIRES(!aux::is_array<TExpected, T>::value) = 0>
-  auto to(Ts&&... args) noexcept {
-    return to_impl<T>(aux::make_index_sequence<sizeof...(Ts)>{}, static_cast<Ts&&>(args)...);
-  }
-  template <template <class...> class T>
-  auto to() noexcept {
-    return dependency<TScope, TExpected, aux::identity<T<>>, TName, TPriority, TCtor>{};
-  }
-  template <class...>
-  dependency& to(...) const noexcept;
-  auto operator[](const override&) noexcept {
-    return dependency<TScope, TExpected, TGiven, TName, override>{static_cast<dependency&&>(*this)};
-  }
-#if defined(__cpp_variable_templates)
-  dependency& operator()() noexcept { return *this; }
-#endif
-  template <class... Ts, __BOOST_DI_REQUIRES(sizeof...(Ts) && !aux::is_array<TExpected, Ts...>::value) = 0>
-  auto operator()(Ts&&... args) noexcept {
-    return to_impl<TExpected>(aux::make_index_sequence<sizeof...(Ts)>{}, static_cast<Ts&&>(args)...);
-  }
-
- protected:
-  using scope_t::create;
-  using scope_t::is_referable;
-  using scope_t::try_create;
-  template <class, class>
-  static void try_create(...);
-
- private:
-  template <class T, int... Ns, class... Ts>
-  auto to_impl(aux::index_sequence<Ns...>, Ts&&... args) noexcept {
-    using ctor_t = core::pool_t<ctor_arg_traits<T, Ns, Ts>...>;
-    using dependency = dependency<TScope, TExpected, T, TName, TPriority, ctor_t>;
-    return dependency{ctor_t{ctor_arg_traits<T, Ns, Ts>(static_cast<Ts&&>(args))...}};
-  }
-};
-}
-namespace concepts {
-struct call_operator_with_one_argument {};
-template <class>
-struct policy {
-  template <class>
-  struct requires_ : aux::false_type {};
-};
-struct arg_wrapper {
-  using type = _;
-  using expected = _;
-  using given = _;
-  using name = no_name;
-  using arity = aux::integral_constant<int, 0>;
-  using scope = scopes::deduce;
-  using is_root = aux::false_type;
-  template <class, class, class>
-  struct resolve;
-};
-aux::false_type callable_impl(...);
-template <class T, class TArg>
-auto callable_impl(const T&& t, TArg&& arg) -> aux::is_valid_expr<decltype(t(arg))>;
-template <class...>
-struct is_callable_impl;
-template <class T, class... Ts>
-struct is_callable_impl<T, Ts...> {
-  using callable_with_arg = decltype(callable_impl(aux::declval<T>(), arg_wrapper{}));
-  using type = aux::conditional_t<callable_with_arg::value, typename is_callable_impl<Ts...>::type,
-                                  typename policy<T>::template requires_<call_operator_with_one_argument>>;
-};
-template <>
-struct is_callable_impl<> : aux::true_type {};
-template <class... Ts>
-struct is_callable : is_callable_impl<Ts...> {};
-template <class... Ts>
-struct is_callable<core::pool<aux::type_list<Ts...>>> : is_callable_impl<Ts...> {};
-template <>
-struct is_callable<void> {
-  using type = policy<void>::requires_<call_operator_with_one_argument>;
-};
-template <class... Ts>
-using callable = typename is_callable<Ts...>::type;
-}
-namespace providers {
-class stack_over_heap {
- public:
-  template <class TInitialization, class T, class... TArgs>
-  struct is_creatable {
-    static constexpr auto value = concepts::creatable<TInitialization, T, TArgs...>::value;
-  };
-  template <class T, class... TArgs>
-  auto get(const type_traits::direct&, const type_traits::heap&, TArgs&&... args) const {
-    return new T(static_cast<TArgs&&>(args)...);
-  }
-  template <class T, class... TArgs>
-  auto get(const type_traits::uniform&, const type_traits::heap&, TArgs&&... args) const {
-    return new T{static_cast<TArgs&&>(args)...};
-  }
-  template <class T, class... TArgs>
-  auto get(const type_traits::direct&, const type_traits::stack&, TArgs&&... args) const {
-    return T(static_cast<TArgs&&>(args)...);
-  }
-  template <class T, class... TArgs>
-  auto get(const type_traits::uniform&, const type_traits::stack&, TArgs&&... args) const {
-    return T{static_cast<TArgs&&>(args)...};
-  }
-};
-}
-namespace scopes {
-class singleton {
-  template <class T, class = decltype(aux::has_shared_ptr__(aux::declval<T>()))>
-  class scope_impl {
-   public:
-    template <class T_, class>
-    using is_referable = typename wrappers::shared<singleton, T&>::template is_referable<T_>;
-    template <class, class, class TProvider>
-    static decltype(wrappers::shared<singleton, T&>{aux::declval<TProvider>().get(type_traits::stack{})}) try_create(
-        const TProvider&);
-    template <class, class, class TProvider>
-    auto create(const TProvider& provider) {
-      return create_impl(provider);
-    }
-
-   private:
-    template <class TProvider>
-    wrappers::shared<singleton, T&> create_impl(const TProvider& provider) {
-      static auto object(provider.get(type_traits::stack{}));
-      return wrappers::shared<singleton, T&>(object);
-    }
-  };
-  template <class T>
-  class scope_impl<T, aux::true_type> {
-   public:
-    template <class T_, class>
-    using is_referable = typename wrappers::shared<singleton, T>::template is_referable<T_>;
-    template <class, class, class TProvider, class T_ = aux::decay_t<decltype(aux::declval<TProvider>().get())>>
-    static decltype(wrappers::shared<singleton, T_>{std::shared_ptr<T_>{std::shared_ptr<T_>{aux::declval<TProvider>().get()}}})
-    try_create(const TProvider&);
-    template <class, class, class TProvider>
-    auto create(const TProvider& provider) {
-      return create_impl<aux::decay_t<decltype(provider.get())>>(provider);
-    }
-
-   private:
-    template <class T_, class TProvider>
-    auto create_impl(const TProvider& provider) {
-      static std::shared_ptr<T_> object{provider.get()};
-      return wrappers::shared<singleton, T_, std::shared_ptr<T_>&>{object};
-    }
-  };
-
- public:
-  template <class, class T>
-  using scope = scope_impl<T>;
-};
-}
-static constexpr __BOOST_DI_UNUSED scopes::singleton singleton{};
-namespace scopes {
-class unique {
- public:
-  template <class, class>
-  class scope {
-   public:
-    template <class...>
-    using is_referable = aux::false_type;
-    template <class T, class, class TProvider>
-    static decltype(wrappers::unique<unique, decltype(aux::declval<TProvider>().get(
-                                                 typename TProvider::config::template memory_traits<T>::type{}))>{
-        aux::declval<TProvider>().get(typename TProvider::config::template memory_traits<T>::type{})})
-    try_create(const TProvider&);
-    template <class T, class, class TProvider>
-    auto create(const TProvider& provider) const {
-      using memory = typename TProvider::config::template memory_traits<T>::type;
-      using wrapper = wrappers::unique<unique, decltype(provider.get(memory{}))>;
-      return wrapper{provider.get(memory{})};
-    }
-  };
-};
-}
-static constexpr __BOOST_DI_UNUSED scopes::unique unique{};
-namespace type_traits {
-template <class T>
-struct scope_traits {
-  using type = scopes::unique;
-};
-template <class T>
-struct scope_traits<T&> {
-  using type = scopes::singleton;
-};
-template <class T>
-struct scope_traits<std::shared_ptr<T>> {
-  using type = scopes::singleton;
-};
-template <class T>
-struct scope_traits<boost::shared_ptr<T>> {
-  using type = scopes::singleton;
-};
-template <class T>
-struct scope_traits<std::weak_ptr<T>> {
-  using type = scopes::singleton;
-};
-}
-#if !defined(BOOST_DI_CFG)
-#define BOOST_DI_CFG ::boost::ext::di::v1_3_0::config
-#endif
-template <class... TPolicies, __BOOST_DI_REQUIRES_MSG(concepts::callable<TPolicies...>) = 0>
-inline auto make_policies(TPolicies... args) noexcept {
-  return core::pool_t<TPolicies...>(static_cast<TPolicies&&>(args)...);
-}
-struct config {
-  template <class T>
-  auto provider(T*) noexcept {
-    return providers::stack_over_heap{};
-  }
-  template <class T>
-  auto policies(T*) noexcept {
-    return make_policies();
-  }
-  template <class T>
-  using scope_traits = type_traits::scope_traits<T>;
-  template <class T>
-  using memory_traits = type_traits::memory_traits<T>;
-};
-namespace detail {
-template <class...>
-struct bind;
-template <class TScope>
-struct bind<int, TScope> {
-  using type = core::dependency<TScope>;
-};
-template <class TScope, class T>
-struct bind<int, TScope, T> {
-  using type = core::dependency<TScope, T>;
-};
-template <class TScope, class... Ts>
-struct bind<int, TScope, Ts...> {
-  using type = core::dependency<TScope, concepts::any_of<Ts...>>;
-};
-}
-template <class... Ts>
-#if defined(__cpp_variable_templates)
-typename
-#else
-struct bind :
-#endif
-    detail::bind<__BOOST_DI_REQUIRES_MSG(concepts::boundable<concepts::any_of<Ts...>>), scopes::deduce, Ts...>::type
-#if defined(__cpp_variable_templates)
-        bind
-#endif
-{};
-static constexpr __BOOST_DI_UNUSED core::override override{};
-namespace concepts {
-struct get {};
-struct is_creatable {};
-template <class>
-struct provider {
-  template <class...>
-  struct requires_ : aux::false_type {};
-};
-template <class T>
-typename provider<T>::template requires_<get, is_creatable> providable_impl(...);
-template <class T>
-auto providable_impl(T&& t)
-    -> aux::is_valid_expr<decltype(t.template get<_>(type_traits::direct{}, type_traits::heap{})),
-                          decltype(t.template get<_>(type_traits::direct{}, type_traits::heap{}, int{})),
-                          decltype(t.template get<_>(type_traits::uniform{}, type_traits::stack{})),
-                          decltype(t.template get<_>(type_traits::uniform{}, type_traits::stack{}, int{})),
-                          decltype(T::template is_creatable<type_traits::direct, type_traits::heap, _>::value),
-                          decltype(T::template is_creatable<type_traits::uniform, type_traits::stack, _, int>::value)>;
-template <class T>
-struct providable__ {
-  using type = decltype(providable_impl<T>(aux::declval<T>()));
-};
-template <class T>
-using providable = typename providable__<T>::type;
-}
-namespace concepts {
-template <class>
-struct policies {};
-struct providable_type {};
-struct callable_type {};
-template <class>
-struct config {
-  template <class...>
-  struct requires_ : aux::false_type {};
-};
-template <class TConfig>
-struct injector {
-  using config = TConfig;
-  using deps = aux::type_list<>;
-  template <class T>
-  T create() const;
-};
-aux::false_type configurable_impl(...);
-template <class T>
-auto configurable_impl(T&&) -> aux::is_valid_expr<decltype(aux::declval<T>().provider(aux::declval<injector<T>*>())),
-                                                  decltype(aux::declval<T>().policies(aux::declval<injector<T>*>()))>;
-template <class T1, class T2>
-struct get_configurable_error : aux::type_list<T1, T2> {};
-template <class T>
-struct get_configurable_error<aux::true_type, T> {
-  using type = T;
-};
-template <class T>
-struct get_configurable_error<T, aux::true_type> {
-  using type = T;
-};
-template <>
-struct get_configurable_error<aux::true_type, aux::true_type> : aux::true_type {};
-template <class T>
-auto is_configurable(const aux::true_type&) {
-  return typename get_configurable_error<decltype(providable<decltype(aux::declval<T>().provider(aux::declval<injector<T>*>()))>()),
-                                         decltype(callable<decltype(aux::declval<T>().policies(aux::declval<injector<T>*>()))>())>::type{};
-}
-template <class T>
-auto is_configurable(const aux::false_type&) {
-  return typename config<T>::template requires_<provider<providable_type(...)>, policies<callable_type(...)>>{};
-}
-template <class T>
-struct configurable__ {
-  using type = decltype(is_configurable<T>(decltype(configurable_impl(aux::declval<T>())){}));
-};
-template <class T>
-using configurable = typename configurable__<T>::type;
-}
-namespace core {
-struct binder {
-  template <class TDefault, class>
-  static TDefault resolve_impl(...) noexcept {
-    return {};
-  }
-  template <class, class TConcept, class TDependency>
-  static decltype(auto) resolve_impl(aux::pair<TConcept, TDependency>* dep) noexcept {
-    return static_cast<TDependency&>(*dep);
-  }
-  template <class, class TConcept, class TScope, class TExpected, class TGiven, class TName, class TCtor,
-            template <class, class, class, class, class, class> class TDependency>
-  static decltype(auto) resolve_impl(
-      aux::pair<TConcept, TDependency<TScope, TExpected, TGiven, TName, override, TCtor>>* dep) noexcept {
-    return static_cast<TDependency<TScope, TExpected, TGiven, TName, override, TCtor>&>(*dep);
-  }
-  template <class TDefault, class>
-  static TDefault resolve_impl__(...);
-  template <class, class TConcept, class TDependency>
-  static TDependency resolve_impl__(aux::pair<TConcept, TDependency>*);
-  template <class, class TConcept, class TScope, class TExpected, class TGiven, class TName, class TCtor,
-            template <class, class, class, class, class, class> class TDependency>
-  static dependency<TScope, TExpected, TGiven, TName, override, TCtor> resolve_impl__(
-      aux::pair<TConcept, TDependency<TScope, TExpected, TGiven, TName, override, TCtor>>*);
-  template <class TDeps, class T, class TName, class TDefault>
-  struct resolve__ {
-    using type = decltype(resolve_impl__<TDefault, dependency_concept<aux::decay_t<T>, TName>>(aux::declval<TDeps*>()));
-  };
-#if (defined(__CLANG__) && __CLANG__ >= 3'9)  //
-  template <class TDeps, class T>
-  static T& resolve_(TDeps* deps, const aux::type<T&>&) noexcept {
-    return static_cast<T&>(*deps);
-  }
-  template <class TDeps, class T>
-  static T resolve_(TDeps*, const aux::type<T>&) noexcept {
-    return {};
-  }
-#endif
-  template <class, class T>
-  struct resolve_template_impl {
-    using type = T;
-  };
-  template <class TDeps, template <class...> class T, class... Ts>
-  struct resolve_template_impl<TDeps, aux::identity<T<Ts...>>> {
-    using type = T<typename resolve_template_impl<
-        TDeps, aux::remove_qualifiers_t<typename resolve__<
-                   TDeps, Ts, no_name, dependency<scopes::deduce, aux::decay_t<Ts>>>::type::given>>::type...>;
-  };
-  template <class T, class TName = no_name, class TDefault = dependency<scopes::deduce, aux::decay_t<T>>, class TDeps>
-  static decltype(auto) resolve(TDeps* deps) noexcept {
-    using dependency = dependency_concept<aux::decay_t<T>, TName>;
-#if (defined(__CLANG__) && __CLANG__ >= 3'9)  //
-    return resolve_(deps, aux::type<decltype(resolve_impl<TDefault, dependency>(aux::declval<TDeps*>()))>{});
-#else
-    return resolve_impl<TDefault, dependency>(deps);
-#endif
-  }
-  template <class TDeps, class T, class TName = no_name, class TDefault = dependency<scopes::deduce, aux::decay_t<T>>>
-  using resolve_t = typename resolve__<TDeps, T, TName, TDefault>::type;
-  template <class TDeps, class T>
-  using resolve_template_t = typename resolve_template_impl<TDeps, aux::remove_qualifiers_t<T>>::type;
-};
-}
-namespace core {
-template <class T, class TInjector, class TError = aux::false_type>
-struct is_referable__ {
-  static constexpr auto value =
-      dependency__<binder::resolve_t<TInjector, T>>::template is_referable<T, typename TInjector::config>::value;
-};
-template <class T, class TInjector>
-struct is_referable__<T, TInjector, aux::true_type> {
-  static constexpr auto value = true;
-};
-template <class T, class TInjector, class TError>
-struct is_creatable__ {
-  static constexpr auto value = injector__<TInjector>::template is_creatable<T>::value;
-};
-template <class T, class TInjector>
-struct is_creatable__<T, TInjector, aux::false_type> {
-  static constexpr auto value = true;
-};
-template <class, class>
-struct is_copy_ctor__ : aux::false_type {};
-template <class T>
-struct is_copy_ctor__<T, T> : aux::true_type {};
-template <class T>
-struct is_copy_ctor__<T, const T> : aux::true_type {};
-template <class TParent, class TInjector, class TError = aux::false_type>
-struct any_type {
-  template <class T, class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
-  }
-  const TInjector& injector_;
-};
-template <class TParent, class TInjector, class TError = aux::false_type, class TRefError = aux::false_type>
-struct any_type_ref {
-  template <class T, class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector, TRefError>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<T&&, TInjector, TError>::value)>
-  operator T&&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector, TRefError>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<T&, TInjector, TError>::value)>
-  operator T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector, TRefError>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<const T&, TInjector, TError>::value)>
-  operator const T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<const T&>{});
-  }
-  const TInjector& injector_;
-};
-template <class TParent, class TInjector, class TError = aux::false_type>
-struct any_type_1st {
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
-  }
-  const TInjector& injector_;
-};
-template <class TParent, class TInjector, class TError = aux::false_type, class TRefError = aux::false_type>
-struct any_type_1st_ref {
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<T, TInjector, TError>::value)>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector, TRefError>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<T&&, TInjector, TError>::value)>
-  operator T&&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector, TRefError>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<T&, TInjector, TError>::value)>
-  operator T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<T&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector, TRefError>::value),
-            class = __BOOST_DI_REQUIRES(is_creatable__<const T&, TInjector, TError>::value)>
-  operator const T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_impl(aux::type<const T&>{});
-  }
-  const TInjector& injector_;
-};
-namespace successful {
-template <class TParent, class TInjector>
-struct any_type {
-  template <class T>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
-  }
-  const TInjector& injector_;
-};
-template <class TParent, class TInjector>
-struct any_type_ref {
-  template <class T>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector>::value)>
-  operator T&&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector>::value)>
-  operator T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector>::value)>
-  operator const T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<const T&>{});
-  }
-  const TInjector& injector_;
-};
-template <class TParent, class TInjector>
-struct any_type_1st {
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
-  }
-  const TInjector& injector_;
-};
-template <class TParent, class TInjector>
-struct any_type_1st_ref {
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator T() {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_referable__<T&&, TInjector>::value)>
-  operator T&&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_referable__<T&, TInjector>::value)>
-  operator T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<T&>{});
-  }
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value),
-            class = __BOOST_DI_REQUIRES(is_referable__<const T&, TInjector>::value)>
-  operator const T&() const {
-    return static_cast<const core::injector__<TInjector>&>(injector_).create_successful_impl(aux::type<const T&>{});
-  }
-  const TInjector& injector_;
-};
-}
-template <class>
-struct any_type_fwd {
-  template <class T>
-  operator T();
-
- private:
-  template <class T>
-  operator const T&() const;
-};
-template <class>
-struct any_type_ref_fwd {
-  template <class T>
-  operator T();
-  template <class T>
-  operator T&() const;
-  template <class T>
-  operator T&&() const;
-  template <class T>
-  operator const T&() const;
-};
-template <class TParent>
-struct any_type_1st_fwd {
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator T();
-
- private:
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator const T&() const;
-};
-template <class TParent>
-struct any_type_1st_ref_fwd {
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator T();
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator T&() const;
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator T&&() const;
-  template <class T, class = __BOOST_DI_REQUIRES(!is_copy_ctor__<TParent, T>::value)>
-  operator const T&() const;
-};
-}
-namespace core {
-template <class...>
-struct arg_wrapper;
-template <class T, class TName, class TIsRoot, template <class...> class TList, class... TCtor, class TDependency, class TDeps>
-struct arg_wrapper<T, TName, TIsRoot, TList<TCtor...>, TDependency, TDeps> {
-  using type __BOOST_DI_UNUSED = T;
-  using expected __BOOST_DI_UNUSED = typename TDependency::expected;
-  using given __BOOST_DI_UNUSED = typename TDependency::given;
-  using name __BOOST_DI_UNUSED = TName;
-  using arity __BOOST_DI_UNUSED = aux::integral_constant<int, sizeof...(TCtor)>;
-  using scope __BOOST_DI_UNUSED = typename TDependency::scope;
-  using is_root __BOOST_DI_UNUSED = TIsRoot;
-  template <class T_, class TName_, class TDefault_>
-  using resolve = decltype(core::binder::resolve<T_, TName_, TDefault_>(aux::declval<TDeps*>()));
-};
-template <class T>
-struct allow_void : T {};
-template <>
-struct allow_void<void> : aux::true_type {};
-class policy {
-  template <class TArg, class TPolicy, class TPolicies,
-            __BOOST_DI_REQUIRES(!aux::is_base_of<_, aux::remove_reference_t<typename TArg::type>>::value) = 0>
-  static void call_impl(const TPolicies& policies) noexcept {
-    static_cast<const TPolicy&>(policies)(TArg{});
-  }
-  template <class TArg, class, class TPolicies,
-            __BOOST_DI_REQUIRES(aux::is_base_of<_, aux::remove_reference_t<typename TArg::type>>::value) = 0>
-  static void call_impl(const TPolicies&) noexcept {}
-  template <class TArg, class TPolicy>
-  struct try_call_impl
-      : aux::conditional_t<aux::is_base_of<_, aux::remove_reference_t<typename TArg::type>>::value, aux::true_type,
-                           allow_void<decltype((aux::declval<TPolicy>())(aux::declval<TArg>()))>> {};
-
- public:
-  template <class, class>
-  struct try_call;
-  template <class TArg, class... TPolicies>
-  struct try_call<TArg, pool_t<TPolicies...>> : aux::is_same<aux::bool_list<aux::always<TPolicies>::value...>,
-                                                             aux::bool_list<try_call_impl<TArg, TPolicies>::value...>> {};
-  template <class TArg, class... TPolicies>
-  static void call(__BOOST_DI_UNUSED const pool_t<TPolicies...>& policies) noexcept {
-    (void)aux::swallow{0, (call_impl<TArg, TPolicies>(policies), 0)...};
-  }
-};
-}
-namespace core {
-#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL >= 2)
-template <class T>
-struct creating {
-  creating() { type(); }
-  static inline T type(_ = "creating...");
-};
-#endif
-template <class, class, class>
-struct try_provider;
-template <class T, class TInjector, class TProvider, class TInitialization, template <class...> class TList, class... TCtor>
-struct try_provider<aux::pair<T, aux::pair<TInitialization, TList<TCtor...>>>, TInjector, TProvider> {
-  using injector = TInjector;
-  using config = typename TInjector::config;
-  template <class>
-  struct is_creatable {
-    static constexpr auto value =
-        TProvider::template is_creatable<TInitialization, T,
-                                         typename injector__<TInjector>::template try_create<TCtor>::type...>::value;
-  };
-  template <class TMemory = type_traits::heap>
-  auto get(const TMemory& = {}) const
-      -> aux::enable_if_t<is_creatable<TMemory>::value,
-                          aux::conditional_t<aux::is_same<TMemory, type_traits::stack>::value, T, aux::remove_reference_t<T>*>>;
-};
-template <class, class, class>
-struct provider;
-template <class T, class TName, class TInjector, class TInitialization, template <class...> class TList, class... TCtor>
-struct provider<aux::pair<T, aux::pair<TInitialization, TList<TCtor...>>>, TName, TInjector> {
-  using injector = TInjector;
-  using config = typename TInjector::config;
-  template <class, class... TArgs>
-  struct is_creatable {
-    using type = decltype(aux::declval<injector__<TInjector>>().cfg().provider(aux::declval<TInjector*>()));
-    static constexpr auto value = type::template is_creatable<TInitialization, T, TArgs...>::value;
-  };
-  template <class TMemory = type_traits::heap>
-  auto get(const TMemory& memory = {}) const {
-    return get_impl(memory, ((const injector__<TInjector>*)injector_)->create_impl(aux::type<TCtor>{})...);
-  }
-  template <class TMemory, class... TArgs, __BOOST_DI_REQUIRES(is_creatable<TMemory, TArgs...>::value) = 0>
-  auto get_impl(const TMemory& memory, TArgs&&... args) const {
-#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL >= 2)
-    (void)aux::conditional_t<injector__<TInjector>::template is_creatable<T>::value, _, creating<T>>{};
-#endif
-    return cfg().provider(injector_).template get<T>(TInitialization{}, memory, static_cast<TArgs&&>(args)...);
-  }
-  template <class TMemory, class... TArgs, __BOOST_DI_REQUIRES(!is_creatable<TMemory, TArgs...>::value) = 0>
-  auto get_impl(const TMemory&, TArgs&&...) const {
-#if (BOOST_DI_CFG_DIAGNOSTICS_LEVEL > 0)
-    return concepts::creatable_error<TInitialization, TName, T*, TArgs...>();
-#else
-    return nullptr;
-#endif
-  }
-  auto& super() const { return *injector_; }
-  auto& cfg() const { return ((injector__<TInjector>*)injector_)->cfg(); }
-  const TInjector* injector_;
-};
-namespace successful {
-template <class, class>
-struct provider;
-template <class T, class TInjector, class TInitialization, template <class...> class TList, class... TCtor>
-struct provider<aux::pair<T, aux::pair<TInitialization, TList<TCtor...>>>, TInjector> {
-  using injector = TInjector;
-  using config = typename TInjector::config;
-  template <class TMemory = type_traits::heap>
-  auto get(const TMemory& memory = {}) const {
-    return cfg().provider(injector_).template get<T>(
-        TInitialization{}, memory, ((const injector__<TInjector>*)injector_)->create_successful_impl(aux::type<TCtor>{})...);
-  }
-  auto& super() const { return *injector_; }
-  auto& cfg() const { return ((injector__<TInjector>*)injector_)->cfg(); }
-  const TInjector* injector_;
-};
-}
-}
-namespace core {
-namespace successful {
-template <class T, class TWrapper>
-struct wrapper {
-  inline operator T() noexcept { return wrapper_; }
-  TWrapper wrapper_;
-};
-}
-template <class T, class TWrapper, class = int>
-struct wrapper_impl {
-  inline operator T() noexcept { return wrapper_; }
-  TWrapper wrapper_;
-};
-template <class T, template <class...> class TWrapper, class TScope, class T_, class... Ts>
-struct wrapper_impl<T, TWrapper<TScope, T_, Ts...>,
-                    __BOOST_DI_REQUIRES(!aux::is_convertible<TWrapper<TScope, T_, Ts...>, T>::value)> {
-  inline operator T() noexcept {
-    return typename concepts::scoped<TScope, aux::remove_qualifiers_t<T_>>::template is_not_convertible_to<T>{};
-  }
-  TWrapper<TScope, T_, Ts...> wrapper_;
-};
-template <class T, class TWrapper>
-using wrapper = wrapper_impl<T, TWrapper>;
-}
-namespace core {
-struct from_injector {};
-struct from_deps {};
-struct init {};
-struct with_error {};
-template <class T, class, class>
-struct referable {
-  using type = T;
-};
-template <class T, class TConfig, class TDependency>
-struct referable<T&, TConfig, TDependency> {
-  using type = aux::conditional_t<TDependency::template is_referable<T&, TConfig>::value, T&, T>;
-};
-template <class T, class TConfig, class TDependency>
-struct referable<const T&, TConfig, TDependency> {
-  using type = aux::conditional_t<TDependency::template is_referable<const T&, TConfig>::value, const T&, T>;
-};
-#if defined(__MSVC__)
-template <class T, class TConfig, class TDependency>
-struct referable<T&&, TConfig, TDependency> {
-  using type = aux::conditional_t<TDependency::template is_referable<T&&, TConfig>::value, T&&, T>;
-};
-#endif
-template <class T, class TConfig, class TDependency>
-using referable_t = typename referable<T, TConfig, TDependency>::type;
-#if defined(__MSVC__)
-template <class T, class TInjector>
-inline auto build(TInjector&& injector) noexcept {
-  return T{static_cast<TInjector&&>(injector)};
-}
-#endif
-template <class TConfig, class TPolicies = pool<>, class... TDeps>
-class injector : public injector_base, public pool<bindings_t<TDeps...>> {
-  using pool_t = pool<bindings_t<TDeps...>>;
-
- protected:
-  template <class T, class TName = no_name, class TIsRoot = aux::false_type>
-  struct is_creatable {
-    using dependency_t = binder::resolve_t<injector, T, TName>;
-    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
-                                                       typename dependency_t::ctor>::type;
-    using ctor_args_t = typename ctor_t::second::second;
-    static constexpr auto value =
-        aux::is_convertible<decltype(dependency__<dependency_t>::template try_create<T, TName>(
-                                try_provider<ctor_t, injector, decltype(aux::declval<TConfig>().provider(aux::declval<injector*>()))>{})),
-                            T>::value &&
-        policy::template try_call<arg_wrapper<T, TName, TIsRoot, ctor_args_t, dependency_t, pool_t>, TPolicies>::value;
-  };
-  auto& cfg() { return config_; }
-  const auto& cfg() const { return config_; }
-
- public:
-  using deps = bindings_t<TDeps...>;
-  using config = TConfig;
-  injector(injector&&) = default;
-  template <class... TArgs>
-  explicit injector(const init&, TArgs... args) noexcept : injector{from_deps{}, static_cast<TArgs&&>(args)...} {}
-  template <class TConfig_, class TPolicies_, class... TDeps_>
-  explicit injector(injector<TConfig_, TPolicies_, TDeps_...>&& other) noexcept
-      : injector{from_injector{}, static_cast<injector<TConfig_, TPolicies_, TDeps_...>&&>(other), deps{}} {}
-  template <class T>
-  injector& operator=(T&& other) noexcept {
-    static_cast<pool_t&>(*this).operator=(static_cast<T&&>(other));
-    return *this;
-  }
-  template <class T, __BOOST_DI_REQUIRES(is_creatable<T, no_name, aux::true_type>::value) = 0>
-  T create() const {
-    return __BOOST_DI_TYPE_WKND(T) create_successful_impl<aux::true_type>(aux::type<T>{});
-  }
-  template <class T, __BOOST_DI_REQUIRES(!is_creatable<T, no_name, aux::true_type>::value) = 0>
-  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
-  T
-      // clang-format off
-  create
-      // clang-format on
-      () const {
-    return __BOOST_DI_TYPE_WKND(T) create_impl<aux::true_type>(aux::type<T>{});
-  }
-  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
-            __BOOST_DI_REQUIRES(is_creatable<R, no_name, aux::true_type>::value) = 0>
-  R
-  // clang-format off
-  create()
-      // clang-format on
-      const {
-    return __BOOST_DI_TYPE_WKND(R) create_successful_impl<aux::true_type>(aux::type<R>{});
-  }
-  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
-            __BOOST_DI_REQUIRES(!is_creatable<R, no_name, aux::true_type>::value) = 0>
-  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
-  R
-      // clang-format off
-  create()
-      // clang-format on
-      const {
-    return __BOOST_DI_TYPE_WKND(R) create_impl<aux::true_type>(aux::type<R>{});
-  }
-
- protected:
-  template <class T>
-  struct try_create {
-    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
-  };
-  template <class TParent>
-  struct try_create<any_type_fwd<TParent>> {
-    using type = any_type<TParent, injector, with_error>;
-  };
-  template <class TParent>
-  struct try_create<any_type_ref_fwd<TParent>> {
-    using type = any_type_ref<TParent, injector, with_error>;
-  };
-  template <class TParent>
-  struct try_create<any_type_1st_fwd<TParent>> {
-    using type = any_type_1st<TParent, injector, with_error>;
-  };
-  template <class TParent>
-  struct try_create<any_type_1st_ref_fwd<TParent>> {
-    using type = any_type_1st_ref<TParent, injector, with_error>;
-  };
-  template <class TName, class T>
-  struct try_create<::boost::ext::di::v1_3_0::named<TName, T>> {
-    using type = aux::conditional_t<is_creatable<T, TName>::value, T, void>;
-  };
-  template <class TParent, int N, class T>
-  struct try_create<core::ctor_arg<TParent, N, T&&>> {
-    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
-  };
-  template <class TParent, int N>
-  struct try_create<core::ctor_arg<TParent, N, const placeholders::arg&>> {
-    using type = any_type_1st_ref<TParent, injector, with_error>;
-  };
-  template <class T>
-  struct try_create<self<T>> {
-    using type = injector;
-  };
-  template <class TIsRoot = aux::false_type, class T>
-  auto create_impl(const aux::type<T>&) const {
-    return create_impl__<TIsRoot, T>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_fwd<TParent>>&) const {
-    return any_type<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
-    return any_type_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
-    return any_type_1st<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
-    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T, class TName>
-  auto create_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
-    return create_impl__<TIsRoot, T, TName>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
-  auto create_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
-    auto& dependency = binder::resolve<TParent>((injector*)this);
-    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N>
-  auto create_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
-    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T>
-  auto create_successful_impl(const aux::type<T>&) const {
-    return create_successful_impl__<TIsRoot, T>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_fwd<TParent>>&) const {
-    return successful::any_type<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
-    return successful::any_type_ref<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
-    return successful::any_type_1st<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
-    return successful::any_type_1st_ref<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T, class TName>
-  auto create_successful_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
-    return create_successful_impl__<TIsRoot, T, TName>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
-  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
-    auto& dependency = binder::resolve<TParent>((injector*)this);
-    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N>
-  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
-    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T>
-  decltype(auto) create_successful_impl(const aux::type<self<T>>&) const {
-    return *this;
-  }
-
- private:
-  explicit injector(const from_deps&) noexcept {}
-  template <class... TArgs>
-  explicit injector(const from_deps&, TArgs... args) noexcept
-      : pool_t{bindings_t<TArgs...>{}, core::pool_t<TArgs...>{static_cast<TArgs&&>(args)...}} {}
-  template <class TInjector, class... TArgs>
-  injector(const from_injector&, TInjector&& injector, const aux::type_list<TArgs...>&) noexcept
-#if defined(__MSVC__)
-      : pool_t{bindings_t<TArgs...>{},
-               pool_t {
-                 build<TArgs>(static_cast<TInjector&&>(injector))...
-               }}
-#else
-      : pool_t{bindings_t<TArgs...>{},
-               pool_t {
-                 TArgs{static_cast<TInjector&&>(injector)}...
-               }}
-#endif
-  {
-  }
-  template <class TInjector>
-  injector(const from_injector&, TInjector&&, const aux::type_list<>&) noexcept {}
-  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
-  auto create_impl__() const {
-    auto&& dependency = binder::resolve<T, TName>((injector*)this);
-    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
-    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
-                                                       typename dependency_t::ctor>::type;
-    using provider_t = core::provider<ctor_t, TName, injector>;
-    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
-    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
-    using ctor_args_t = typename ctor_t::second::second;
-    policy::template call<arg_wrapper<T, TName, TIsRoot, ctor_args_t, dependency_t, pool_t>>(
-        ((injector*)this)->cfg().policies(this));
-    return wrapper<T, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
-  }
-  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
-  auto create_successful_impl__() const {
-    auto&& dependency = binder::resolve<T, TName>((injector*)this);
-    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
-    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
-                                                       typename dependency_t::ctor>::type;
-    using provider_t = successful::provider<ctor_t, injector>;
-    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
-    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
-    using create_t = referable_t<T, config, dependency__<dependency_t>>;
-    using ctor_args_t = typename ctor_t::second::second;
-    policy::template call<arg_wrapper<T, TName, TIsRoot, ctor_args_t, dependency_t, pool_t>>(
-        ((injector*)this)->cfg().policies(this));
-    return successful::wrapper<create_t, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
-  }
-  config config_;
-};
-template <class TConfig, class... TDeps>
-class injector<TConfig, pool<>, TDeps...> : public injector_base, public pool<bindings_t<TDeps...>> {
-  using pool_t = pool<bindings_t<TDeps...>>;
-
- protected:
-  template <class T, class TName = no_name, class TIsRoot = aux::false_type>
-  struct is_creatable {
-    using dependency_t = binder::resolve_t<injector, T, TName>;
-    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
-                                                       typename dependency_t::ctor>::type;
-    using ctor_args_t = typename ctor_t::second::second;
-    static constexpr auto value =
-        aux::is_convertible<decltype(dependency__<dependency_t>::template try_create<T, TName>(
-                                try_provider<ctor_t, injector, decltype(aux::declval<TConfig>().provider(aux::declval<injector*>()))>{})),
-                            T>::value;
-  };
-  auto& cfg() { return config_; }
-  const auto& cfg() const { return config_; }
-
- public:
-  using deps = bindings_t<TDeps...>;
-  using config = TConfig;
-  injector(injector&&) = default;
-  template <class... TArgs>
-  explicit injector(const init&, TArgs... args) noexcept : injector{from_deps{}, static_cast<TArgs&&>(args)...} {}
-  template <class TConfig_, class TPolicies_, class... TDeps_>
-  explicit injector(injector<TConfig_, TPolicies_, TDeps_...>&& other) noexcept
-      : injector{from_injector{}, static_cast<injector<TConfig_, TPolicies_, TDeps_...>&&>(other), deps{}} {}
-  template <class T>
-  injector& operator=(T&& other) noexcept {
-    static_cast<pool_t&>(*this).operator=(static_cast<T&&>(other));
-    return *this;
-  }
-  template <class T, __BOOST_DI_REQUIRES(is_creatable<T, no_name, aux::true_type>::value) = 0>
-  T create() const {
-    return __BOOST_DI_TYPE_WKND(T) create_successful_impl<aux::true_type>(aux::type<T>{});
-  }
-  template <class T, __BOOST_DI_REQUIRES(!is_creatable<T, no_name, aux::true_type>::value) = 0>
-  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
-  T
-      // clang-format off
-  create
-      // clang-format on
-      () const {
-    return __BOOST_DI_TYPE_WKND(T) create_impl<aux::true_type>(aux::type<T>{});
-  }
-  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
-            __BOOST_DI_REQUIRES(is_creatable<R, no_name, aux::true_type>::value) = 0>
-  R
-  // clang-format off
-  create()
-      // clang-format on
-      const {
-    return __BOOST_DI_TYPE_WKND(R) create_successful_impl<aux::true_type>(aux::type<R>{});
-  }
-  template <template <class...> class T, class R = binder::resolve_template_t<injector, aux::identity<T<>>>,
-            __BOOST_DI_REQUIRES(!is_creatable<R, no_name, aux::true_type>::value) = 0>
-  __BOOST_DI_DEPRECATED("creatable constraint not satisfied")
-  R
-      // clang-format off
-  create()
-      // clang-format on
-      const {
-    return __BOOST_DI_TYPE_WKND(R) create_impl<aux::true_type>(aux::type<R>{});
-  }
-
- protected:
-  template <class T>
-  struct try_create {
-    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
-  };
-  template <class TParent>
-  struct try_create<any_type_fwd<TParent>> {
-    using type = any_type<TParent, injector, with_error>;
-  };
-  template <class TParent>
-  struct try_create<any_type_ref_fwd<TParent>> {
-    using type = any_type_ref<TParent, injector, with_error>;
-  };
-  template <class TParent>
-  struct try_create<any_type_1st_fwd<TParent>> {
-    using type = any_type_1st<TParent, injector, with_error>;
-  };
-  template <class TParent>
-  struct try_create<any_type_1st_ref_fwd<TParent>> {
-    using type = any_type_1st_ref<TParent, injector, with_error>;
-  };
-  template <class TName, class T>
-  struct try_create<::boost::ext::di::v1_3_0::named<TName, T>> {
-    using type = aux::conditional_t<is_creatable<T, TName>::value, T, void>;
-  };
-  template <class TParent, int N, class T>
-  struct try_create<core::ctor_arg<TParent, N, T&&>> {
-    using type = aux::conditional_t<is_creatable<T>::value, T, void>;
-  };
-  template <class TParent, int N>
-  struct try_create<core::ctor_arg<TParent, N, const placeholders::arg&>> {
-    using type = any_type_1st_ref<TParent, injector, with_error>;
-  };
-  template <class T>
-  struct try_create<self<T>> {
-    using type = injector;
-  };
-  template <class TIsRoot = aux::false_type, class T>
-  auto create_impl(const aux::type<T>&) const {
-    return create_impl__<TIsRoot, T>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_fwd<TParent>>&) const {
-    return any_type<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
-    return any_type_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
-    return any_type_1st<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
-    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T, class TName>
-  auto create_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
-    return create_impl__<TIsRoot, T, TName>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
-  auto create_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
-    auto& dependency = binder::resolve<TParent>((injector*)this);
-    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N>
-  auto create_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
-    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T>
-  auto create_successful_impl(const aux::type<T>&) const {
-    return create_successful_impl__<TIsRoot, T>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_fwd<TParent>>&) const {
-    return successful::any_type<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_ref_fwd<TParent>>&) const {
-    return successful::any_type_ref<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_1st_fwd<TParent>>&) const {
-    return successful::any_type_1st<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class TParent>
-  auto create_successful_impl(const aux::type<any_type_1st_ref_fwd<TParent>>&) const {
-    return successful::any_type_1st_ref<TParent, injector>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T, class TName>
-  auto create_successful_impl(const aux::type<::boost::ext::di::v1_3_0::named<TName, T>>&) const {
-    return create_successful_impl__<TIsRoot, T, TName>();
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N, class T>
-  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, T>>&) const {
-    auto& dependency = binder::resolve<TParent>((injector*)this);
-    return static_cast<core::ctor_arg<TParent, N, T>&>(dependency);
-  }
-  template <class TIsRoot = aux::false_type, class TParent, int N>
-  auto create_successful_impl(const aux::type<core::ctor_arg<TParent, N, const placeholders::arg&>>&) const {
-    return any_type_1st_ref<TParent, injector, aux::false_type, aux::true_type>{*this};
-  }
-  template <class TIsRoot = aux::false_type, class T>
-  decltype(auto) create_successful_impl(const aux::type<self<T>>&) const {
-    return *this;
-  }
-
- private:
-  explicit injector(const from_deps&) noexcept {}
-  template <class... TArgs>
-  explicit injector(const from_deps&, TArgs... args) noexcept
-      : pool_t{bindings_t<TArgs...>{}, core::pool_t<TArgs...>{static_cast<TArgs&&>(args)...}} {}
-  template <class TInjector, class... TArgs>
-  injector(const from_injector&, TInjector&& injector, const aux::type_list<TArgs...>&) noexcept
-#if defined(__MSVC__)
-      : pool_t{bindings_t<TArgs...>{},
-               pool_t {
-                 build<TArgs>(static_cast<TInjector&&>(injector))...
-               }}
-#else
-      : pool_t{bindings_t<TArgs...>{},
-               pool_t {
-                 TArgs{static_cast<TInjector&&>(injector)}...
-               }}
-#endif
-  {
-  }
-  template <class TInjector>
-  injector(const from_injector&, TInjector&&, const aux::type_list<>&) noexcept {}
-  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
-  auto create_impl__() const {
-    auto&& dependency = binder::resolve<T, TName>((injector*)this);
-    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
-    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
-                                                       typename dependency_t::ctor>::type;
-    using provider_t = core::provider<ctor_t, TName, injector>;
-    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
-    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
-    return wrapper<T, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
-  }
-  template <class TIsRoot = aux::false_type, class T, class TName = no_name>
-  auto create_successful_impl__() const {
-    auto&& dependency = binder::resolve<T, TName>((injector*)this);
-    using dependency_t = typename aux::remove_reference<decltype(dependency)>::type;
-    using ctor_t = typename type_traits::ctor_traits__<binder::resolve_template_t<injector, typename dependency_t::given>, T,
-                                                       typename dependency_t::ctor>::type;
-    using provider_t = successful::provider<ctor_t, injector>;
-    auto& creatable_dept = static_cast<dependency__<dependency_t>&>(dependency);
-    using wrapper_t = decltype(creatable_dept.template create<T, TName>(provider_t{this}));
-    using create_t = referable_t<T, config, dependency__<dependency_t>>;
-    return successful::wrapper<create_t, wrapper_t>{creatable_dept.template create<T, TName>(provider_t{this})};
-  }
-  config config_;
-};
-}
-template <class T, class TInjector>
-auto create(const TInjector& injector) -> decltype(injector.template create<T>()) {
-  return injector.template create<T>();
-}
-template <template <class...> class T, class TInjector>
-auto create(const TInjector& injector) -> decltype(injector.template create<T>()) {
-  return injector.template create<T>();
-}
-template <class T, class TInjector>
-constexpr auto is_creatable(const TInjector&) {
-  return core::injector__<TInjector>::template is_creatable<T, no_name, aux::true_type>::value;
-}
-template <template <class...> class T, class TInjector>
-constexpr auto is_creatable(const TInjector&) {
-  return core::injector__<TInjector>::template is_creatable<core::binder::resolve_template_t<TInjector, aux::identity<T<>>>,
-                                                            no_name, aux::true_type>::value;
-}
-namespace detail {
-template <class>
-void create(const aux::true_type&) {}
-// clang-format off
-template <class>
-__BOOST_DI_DEPRECATED("creatable constraint not satisfied") void
-create
-(const aux::false_type&) {}
-// clang-format on
-template <class, class, class...>
-struct injector;
-template <class, class>
-struct is_creatable_impl;
-template <class TInjector, class TName, class T>
-struct is_creatable_impl<TInjector, named<TName, T>> {
-  static constexpr auto value = core::injector__<TInjector>::template is_creatable<T, TName>::value;
-};
-template <class TConfig, class T, class... TGivens>
-struct injector<TConfig, int, core::dependency<scopes::instance, T, aux::type_list<TGivens...>>>
-    : core::injector<TConfig, core::pool<>, core::dependency<scopes::instance, T, aux::type_list<TGivens...>>> {
-  template <class... Ts>
-  injector(core::injector<Ts...>&& injector) noexcept
-      : core::injector<TConfig, core::pool<>, core::dependency<scopes::instance, T, aux::type_list<TGivens...>>>(
-            static_cast<core::injector<Ts...>&&>(injector)) {
-    using injector_t = core::injector<Ts...>;
-    int _[]{0,
-            // clang-format off
-            (detail::
-create<T> (
-     aux::integral_constant<bool, is_creatable_impl<injector_t, TGivens>::value>{}),
-             0)...};
-    // clang-format on
-    (void)_;
-  }
-};
-}
-#if defined(__MSVC__)
-template <class T, class... Ts>
-struct injector
-    : detail::injector<
-          BOOST_DI_CFG, __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type<T, Ts...>>),
-          core::dependency<scopes::instance, aux::unique_t<type_traits::named_decay_t<T>, type_traits::named_decay_t<Ts>...>,
-                           aux::type_list<type_traits::add_named_t<T>, type_traits::add_named_t<Ts>...>>> {
-  using detail::injector<
-      BOOST_DI_CFG, __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type<T, Ts...>>),
-      core::dependency<scopes::instance, aux::unique_t<type_traits::named_decay_t<T>, type_traits::named_decay_t<Ts>...>,
-                       aux::type_list<type_traits::add_named_t<T>, type_traits::add_named_t<Ts>...>>>::injector;
-};
-#else
-template <class T, class... Ts>
-using injector = detail::injector<
-    BOOST_DI_CFG, __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type<T, Ts...>>),
-    core::dependency<scopes::instance, aux::unique_t<type_traits::named_decay_t<T>, type_traits::named_decay_t<Ts>...>,
-                     aux::type_list<type_traits::add_named_t<T>, type_traits::add_named_t<Ts>...>>>;
-#endif
-// clang-format off
-#define __BOOST_DI_EXPOSE_IMPL__(...) decltype(::boost::ext::di::v1_3_0::detail::__VA_ARGS__),
-#define __BOOST_DI_EXPOSE_IMPL(...) ::boost::ext::di::v1_3_0::named<__BOOST_DI_EXPOSE_IMPL__ __VA_ARGS__>
-#define BOOST_DI_EXPOSE(...) __BOOST_DI_IF(__BOOST_DI_IBP(__VA_ARGS__), __BOOST_DI_EXPOSE_IMPL, __BOOST_DI_EXPAND)(__VA_ARGS__)
-// clang-format on
-#if defined(__MSVC__)
-#define __BOOST_DI_MAKE_INJECTOR(...) __VA_ARGS__
-#else
-namespace detail {
-static auto make_injector = [](auto injector) {
-  using injector_t = decltype(injector);
-  struct i : injector_t {
-    explicit i(injector_t&& other) : injector_t(static_cast<injector_t&&>(other)) {}
-  };
-  return i{static_cast<injector_t&&>(injector)};
-};
-}
-#define __BOOST_DI_MAKE_INJECTOR(...) detail::make_injector(__VA_ARGS__)
-#endif
-template <class TConfig = BOOST_DI_CFG, class... TDeps,
-          __BOOST_DI_REQUIRES_MSG(concepts::boundable<aux::type_list<TDeps...>>) = 0,
-          __BOOST_DI_REQUIRES_MSG(concepts::configurable<TConfig>) = 0>
-inline auto make_injector(TDeps... args) noexcept {
-  return __BOOST_DI_MAKE_INJECTOR(
-      core::injector<TConfig, decltype(aux::declval<TConfig*>()->policies(aux::declval<concepts::injector<TConfig>*>())), TDeps...>{
-          core::init{}, static_cast<TDeps&&>(args)...});
-}
-namespace policies {
-namespace detail {
-struct type_op {};
-template <class T, class = int>
-struct apply_impl {
-  template <class>
-  struct apply : T {};
-};
-template <template <class...> class T, class... Ts>
-struct apply_impl<T<Ts...>, __BOOST_DI_REQUIRES(!aux::is_base_of<type_op, T<Ts...>>::value)> {
-  template <class TOp, class>
-  struct apply_placeholder_impl {
-    using type = TOp;
-  };
-  template <class TOp>
-  struct apply_placeholder_impl<_, TOp> {
-    using type = TOp;
-  };
-  template <template <class...> class TExpr, class TOp, class... TArgs>
-  struct apply_placeholder {
-    using type = TExpr<typename apply_placeholder_impl<TArgs, TOp>::type...>;
-  };
-  template <class TArg>
-  struct apply : apply_placeholder<T, typename TArg::type, Ts...>::type {};
-};
-template <class T>
-struct apply_impl<T, __BOOST_DI_REQUIRES(aux::is_base_of<type_op, T>::value)> {
-  template <class TArg>
-  struct apply : T::template apply<TArg>::type {};
-};
-template <class T>
-struct not_ : detail::type_op {
-  template <class TArg>
-  struct apply : aux::integral_constant<bool, !detail::apply_impl<T>::template apply<TArg>::value> {};
-};
-template <class... Ts>
-struct and_ : detail::type_op {
-  template <class TArg>
-  struct apply : aux::is_same<aux::bool_list<detail::apply_impl<Ts>::template apply<TArg>::value...>,
-                              aux::bool_list<aux::always<Ts>::value...>> {};
-};
-template <class... Ts>
-struct or_ : detail::type_op {
-  template <class TArg>
-  struct apply
-      : aux::integral_constant<bool, !aux::is_same<aux::bool_list<detail::apply_impl<Ts>::template apply<TArg>::value...>,
-                                                   aux::bool_list<aux::never<Ts>::value...>>::value> {};
-};
-}
-template <class T>
-struct type {
-  template <class TPolicy>
-  struct not_allowed_by {
-    operator aux::false_type() const {
-      using constraint_not_satisfied = not_allowed_by;
-      return constraint_not_satisfied{}.error();
-    }
-    // clang-format off
-    static inline aux::false_type
- error(_ = "type disabled by constructible policy, added by BOOST_DI_CFG or make_injector<CONFIG>!");
-    // clang-format on
-  };
-};
-template <class>
-struct is_root : detail::type_op {
-  template <class TArg>
-  struct apply : TArg::is_root {};
-};
-template <class T>
-struct is_bound : detail::type_op {
-  struct not_resolved {};
-  template <class TArg>
-  struct apply
-      : aux::integral_constant<
-            bool,
-            !aux::is_same<typename TArg::template resolve<aux::conditional_t<aux::is_same<T, _>::value, typename TArg::type, T>,
-                                                          typename TArg::name, not_resolved>,
-                          not_resolved>::value> {};
-};
-template <class T>
-struct is_injected : detail::type_op {
-  template <class TArg, class U = aux::decay_t<aux::conditional_t<aux::is_same<T, _>::value, typename TArg::type, T>>>
-  struct apply : aux::conditional_t<aux::is_class<U>::value, typename type_traits::is_injectable<U>::type, aux::true_type> {};
-};
-static constexpr auto include_root = true;
-namespace operators {
-template <class X, class Y>
-inline auto operator||(const X&, const Y&) {
-  return detail::or_<X, Y>{};
-}
-template <class X, class Y>
-inline auto operator&&(const X&, const Y&) {
-  return detail::and_<X, Y>{};
-}
-template <class T>
-inline auto operator!(const T&) {
-  return detail::not_<T>{};
-}
-}
-template <bool, class T>
-struct constructible_impl {
-  template <class TArg, __BOOST_DI_REQUIRES(TArg::is_root::value || T::template apply<TArg>::value) = 0>
-  aux::true_type operator()(const TArg&) const {
-    return {};
-  }
-  template <class TArg, __BOOST_DI_REQUIRES(!TArg::is_root::value && !T::template apply<TArg>::value) = 0>
-  aux::false_type operator()(const TArg&) const {
-    return typename type<typename TArg::type>::template not_allowed_by<T>{};
-  }
-};
-template <class T>
-struct constructible_impl<true, T> {
-  template <class TArg, __BOOST_DI_REQUIRES(T::template apply<TArg>::value) = 0>
-  aux::true_type operator()(const TArg&) const {
-    return {};
-  }
-  template <class TArg, __BOOST_DI_REQUIRES(!T::template apply<TArg>::value) = 0>
-  aux::false_type operator()(const TArg&) const {
-    return typename type<typename TArg::type>::template not_allowed_by<T>{};
-  }
-};
-template <bool IncludeRoot = false, class T = aux::never<_>,
-          __BOOST_DI_REQUIRES(aux::is_base_of<detail::type_op, T>::value) = 0>
-inline auto constructible(const T& = {}) {
-  return constructible_impl<IncludeRoot, T>{};
-}
-template <bool IncludeRoot = false, class T = aux::never<_>,
-          __BOOST_DI_REQUIRES(!aux::is_base_of<detail::type_op, T>::value) = 0>
-inline auto constructible(const T& = {}) {
-  return constructible_impl<IncludeRoot, detail::or_<T>>{};
-}
-}
-#define __BOOST_DI_IF(cond, t, f) __BOOST_DI_IF_I(cond, t, f)
-#define __BOOST_DI_REPEAT(i, m, ...) __BOOST_DI_REPEAT_N(i, m, __VA_ARGS__)
-#define __BOOST_DI_CAT(a, ...) __BOOST_DI_PRIMITIVE_CAT(a, __VA_ARGS__)
-#define __BOOST_DI_EMPTY()
-#define __BOOST_DI_COMMA() ,
-#define __BOOST_DI_EAT(...)
-#define __BOOST_DI_EXPAND(...) __VA_ARGS__
-#define __BOOST_DI_SIZE(...) __BOOST_DI_CAT(__BOOST_DI_VARIADIC_SIZE_I(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ), )
-#define __BOOST_DI_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
-#define __BOOST_DI_ELEM(n, ...) __BOOST_DI_ELEM_I(n, __VA_ARGS__)
-#define __BOOST_DI_IS_EMPTY(...)                              \
-  __BOOST_DI_DETAIL_IS_EMPTY_IIF(__BOOST_DI_IBP(__VA_ARGS__)) \
-  (__BOOST_DI_DETAIL_IS_EMPTY_GEN_ZERO, __BOOST_DI_DETAIL_IS_EMPTY_PROCESS)(__VA_ARGS__)
-#define __BOOST_DI_DETAIL_IS_EMPTY_PRIMITIVE_CAT(a, b) a##b
-#define __BOOST_DI_DETAIL_IS_EMPTY_IIF(bit) __BOOST_DI_DETAIL_IS_EMPTY_PRIMITIVE_CAT(__BOOST_DI_DETAIL_IS_EMPTY_IIF_, bit)
-#define __BOOST_DI_DETAIL_IS_EMPTY_NON_FUNCTION_C(...) ()
-#define __BOOST_DI_DETAIL_IS_EMPTY_GEN_ZERO(...) 0
-#define __BOOST_DI_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, size, ...) size
-#define __BOOST_DI_IF_I(cond, t, f) __BOOST_DI_IIF(cond, t, f)
-#define __BOOST_DI_IIF_0(t, f) f
-#define __BOOST_DI_IIF_1(t, f) t
-#define __BOOST_DI_IIF_2(t, f) t
-#define __BOOST_DI_IIF_3(t, f) t
-#define __BOOST_DI_IIF_4(t, f) t
-#define __BOOST_DI_IIF_5(t, f) t
-#define __BOOST_DI_IIF_6(t, f) t
-#define __BOOST_DI_IIF_7(t, f) t
-#define __BOOST_DI_IIF_8(t, f) t
-#define __BOOST_DI_IIF_9(t, f) t
-#define __BOOST_DI_ELEM_I(n, ...) __BOOST_DI_CAT(__BOOST_DI_CAT(__BOOST_DI_ELEM, n)(__VA_ARGS__, ), )
-#define __BOOST_DI_ELEM0(p1, ...) p1
-#define __BOOST_DI_ELEM1(p1, p2, ...) p2
-#define __BOOST_DI_ELEM2(p1, p2, p3, ...) p3
-#define __BOOST_DI_ELEM3(p1, p2, p3, p4, ...) p4
-#define __BOOST_DI_ELEM4(p1, p2, p3, p4, p5, ...) p5
-#define __BOOST_DI_ELEM5(p1, p2, p3, p4, p5, p6, ...) p6
-#define __BOOST_DI_ELEM6(p1, p2, p3, p4, p5, p6, p7, ...) p7
-#define __BOOST_DI_ELEM7(p1, p2, p3, p4, p5, p6, p7, p8, ...) p8
-#define __BOOST_DI_ELEM8(p1, p2, p3, p4, p5, p6, p7, p8, p9, ...) p9
-#define __BOOST_DI_ELEM9(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, ...) p10
-#define __BOOST_DI_REPEAT_N(i, m, ...) __BOOST_DI_REPEAT_##i(m, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_1(m, ...) m(0, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_2(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_3(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_4(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_5(m, ...) m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_6(m, ...) \
-  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_7(m, ...) \
-  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) m(6, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_8(m, ...)                                                                           \
-  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) \
-      m(6, __VA_ARGS__) m(7, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_9(m, ...)                                                                           \
-  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) \
-      m(6, __VA_ARGS__) m(7, __VA_ARGS__) m(8, __VA_ARGS__)
-#define __BOOST_DI_REPEAT_10(m, ...)                                                                          \
-  m(0, __VA_ARGS__) m(1, __VA_ARGS__) m(2, __VA_ARGS__) m(3, __VA_ARGS__) m(4, __VA_ARGS__) m(5, __VA_ARGS__) \
-      m(6, __VA_ARGS__) m(7, __VA_ARGS__) m(8, __VA_ARGS__) m(9, __VA_ARGS__)
-#if defined(__MSVC__)
-#define __BOOST_DI_VD_IBP_CAT(a, b) __BOOST_DI_VD_IBP_CAT_I(a, b)
-#define __BOOST_DI_VD_IBP_CAT_I(a, b) __BOOST_DI_VD_IBP_CAT_II(a##b)
-#define __BOOST_DI_VD_IBP_CAT_II(res) res
-#define __BOOST_DI_IBP_SPLIT(i, ...) \
-  __BOOST_DI_VD_IBP_CAT(__BOOST_DI_IBP_PRIMITIVE_CAT(__BOOST_DI_IBP_SPLIT_, i)(__VA_ARGS__), __BOOST_DI_EMPTY())
-#define __BOOST_DI_IBP_IS_VARIADIC_C(...) 1 1
-#define __BOOST_DI_IBP_SPLIT_0(a, ...) a
-#define __BOOST_DI_IBP_SPLIT_1(a, ...) __VA_ARGS__
-#define __BOOST_DI_IBP_CAT(a, ...) __BOOST_DI_IBP_PRIMITIVE_CAT(a, __VA_ARGS__)
-#define __BOOST_DI_IBP_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
-#define __BOOST_DI_IBP_IS_VARIADIC_R_1 1,
-#define __BOOST_DI_IBP_IS_VARIADIC_R___BOOST_DI_IBP_IS_VARIADIC_C 0,
-#define __BOOST_DI_IBP(...) \
-  __BOOST_DI_IBP_SPLIT(0, __BOOST_DI_IBP_CAT(__BOOST_DI_IBP_IS_VARIADIC_R_, __BOOST_DI_IBP_IS_VARIADIC_C __VA_ARGS__))
-#define __BOOST_DI_IIF(bit, t, f) __BOOST_DI_IIF_OO((bit, t, f))
-#define __BOOST_DI_IIF_OO(par) __BOOST_DI_IIF_I##par
-#define __BOOST_DI_IIF_I(bit, t, f) __BOOST_DI_IIF_##bit(t, f)
-#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_0(t, b) b
-#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_1(t, b) t
-#define __BOOST_DI_DETAIL_IS_EMPTY_PROCESS(...) __BOOST_DI_IBP(__BOOST_DI_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__())
-#else
-#define __BOOST_DI_IBP_SPLIT(i, ...) __BOOST_DI_PRIMITIVE_CAT(__BOOST_DI_IBP_SPLIT_, i)(__VA_ARGS__)
-#define __BOOST_DI_IBP_SPLIT_0(a, ...) a
-#define __BOOST_DI_IBP_SPLIT_1(a, ...) __VA_ARGS__
-#define __BOOST_DI_IBP_IS_VARIADIC_C(...) 1
-#define __BOOST_DI_IBP_IS_VARIADIC_R_1 1,
-#define __BOOST_DI_IBP_IS_VARIADIC_R___BOOST_DI_IBP_IS_VARIADIC_C 0,
-#define __BOOST_DI_IBP(...) \
-  __BOOST_DI_IBP_SPLIT(0, __BOOST_DI_CAT(__BOOST_DI_IBP_IS_VARIADIC_R_, __BOOST_DI_IBP_IS_VARIADIC_C __VA_ARGS__))
-#define __BOOST_DI_IIF(bit, t, f) __BOOST_DI_IIF_I(bit, t, f)
-#define __BOOST_DI_IIF_I(bit, t, f) __BOOST_DI_IIF_II(__BOOST_DI_IIF_##bit(t, f))
-#define __BOOST_DI_IIF_II(id) id
-#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_0(t, ...) __VA_ARGS__
-#define __BOOST_DI_DETAIL_IS_EMPTY_IIF_1(t, ...) t
-#define __BOOST_DI_DETAIL_IS_EMPTY_PROCESS(...) __BOOST_DI_IBP(__BOOST_DI_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__())
-#endif
-template <class, class>
-struct named;
-namespace detail {
-struct named_impl {
-  template <class T>
-  T operator=(const T&) const;
-};
-static constexpr __BOOST_DI_UNUSED named_impl named{};
-template <class T, class TName>
-struct combine_impl {
-  using type = ::boost::ext::di::v1_3_0::named<TName, T>;
-};
-template <class T>
-struct combine_impl<T, aux::none_type> {
-  using type = T;
-};
-template <class, class>
-struct combine;
-template <class... T1, class... T2>
-struct combine<aux::type_list<T1...>, aux::type_list<T2...>> {
-  using type = aux::type_list<typename combine_impl<T1, T2>::type...>;
-};
-template <class T1, class T2>
-using combine_t = typename combine<T1, T2>::type;
-}
-template <class... Ts>
-using inject = aux::type_list<Ts...>;
-#define __BOOST_DI_HAS_NAME(i, ...) __BOOST_DI_IF(__BOOST_DI_IBP(__BOOST_DI_ELEM(i, __VA_ARGS__, )), 1, )
-#define __BOOST_DI_HAS_NAMES(...) \
-  __BOOST_DI_IF(__BOOST_DI_IS_EMPTY(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_HAS_NAME, __VA_ARGS__)), 0, 1)
-#define __BOOST_DI_GEN_CTOR_IMPL(p, i) \
-  __BOOST_DI_IF(i, __BOOST_DI_COMMA, __BOOST_DI_EAT)() __BOOST_DI_IF(__BOOST_DI_IBP(p), __BOOST_DI_EAT p, p)
-#define __BOOST_DI_GEN_CTOR(i, ...) __BOOST_DI_GEN_CTOR_IMPL(__BOOST_DI_ELEM(i, __VA_ARGS__, ), i)
-#define __BOOST_DI_GEN_ARG_NAME(p) __BOOST_DI_GEN_ARG_NAME_IMPL p )
-#define __BOOST_DI_GEN_NONE_TYPE(p) ::boost::ext::di::v1_3_0::aux::none_type
-#define __BOOST_DI_GEN_ARG_NAME_IMPL(p) decltype(::boost::ext::di::v1_3_0::detail::p) __BOOST_DI_EAT(
-#define __BOOST_DI_GEN_NAME_IMPL(p, i)               \
-  __BOOST_DI_IF(i, __BOOST_DI_COMMA, __BOOST_DI_EAT) \
-  () __BOOST_DI_IF(__BOOST_DI_IBP(p), __BOOST_DI_GEN_ARG_NAME, __BOOST_DI_GEN_NONE_TYPE)(p)
-#define __BOOST_DI_GEN_NAME(i, ...) __BOOST_DI_GEN_NAME_IMPL(__BOOST_DI_ELEM(i, __VA_ARGS__, ), i)
-#define __BOOST_DI_INJECT_TRAITS_IMPL_0(...)                                                           \
-  static void ctor(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_CTOR, __VA_ARGS__)); \
-  using type __BOOST_DI_UNUSED = ::boost::ext::di::v1_3_0::aux::function_traits_t<decltype(ctor)>;
-#define __BOOST_DI_INJECT_TRAITS_IMPL_1(...)                                                                        \
-  static void ctor(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_CTOR, __VA_ARGS__));              \
-  static void name(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_NAME, __VA_ARGS__));              \
-  using type __BOOST_DI_UNUSED =                                                                                    \
-      ::boost::ext::di::v1_3_0::detail::combine_t<::boost::ext::di::v1_3_0::aux::function_traits_t<decltype(ctor)>, \
-                                                  ::boost::ext::di::v1_3_0::aux::function_traits_t<decltype(name)>>;
-#define __BOOST_DI_INJECT_TRAITS_EMPTY_IMPL(...) \
-  using boost_di_inject__ __BOOST_DI_UNUSED = ::boost::ext::di::v1_3_0::aux::type_list<>
-#define __BOOST_DI_INJECT_TRAITS_IMPL(...)                                                                             \
-  struct boost_di_inject__ {                                                                                           \
-    __BOOST_DI_CAT(__BOOST_DI_INJECT_TRAITS_IMPL_, __BOOST_DI_HAS_NAMES(__VA_ARGS__))                                  \
-    (__VA_ARGS__) static_assert(__BOOST_DI_SIZE(__VA_ARGS__) <= BOOST_DI_CFG_CTOR_LIMIT_SIZE,                          \
-                                "Number of constructor arguments is out of range - see BOOST_DI_CFG_CTOR_LIMIT_SIZE"); \
-  }
-#define BOOST_DI_INJECT_TRAITS(...)                                                                                   \
-  __BOOST_DI_IF(__BOOST_DI_IS_EMPTY(__VA_ARGS__), __BOOST_DI_INJECT_TRAITS_EMPTY_IMPL, __BOOST_DI_INJECT_TRAITS_IMPL) \
-  (__VA_ARGS__)
-#define BOOST_DI_INJECT(T, ...)        \
-  BOOST_DI_INJECT_TRAITS(__VA_ARGS__); \
-  T(__BOOST_DI_REPEAT(__BOOST_DI_SIZE(__VA_ARGS__), __BOOST_DI_GEN_CTOR, __VA_ARGS__))
-BOOST_DI_NAMESPACE_END
-#endif
-#if defined(__CLANG__)
-#pragma clang diagnostic pop
-#elif defined(__GCC__)
-#pragma GCC diagnostic pop
-#endif

From b153e6b8793d0da78c0fa9d0f95884b188c6b554 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Mon, 2 Oct 2023 19:36:00 +0300
Subject: [PATCH 06/13] add game map, bullets, shot, atlas preloading

---
 battle_tanks/client/battle_tanks.cpp          | 148 +++++++++--------
 .../game_data/atlases/map_forest_tileset.png  | Bin 0 -> 6678 bytes
 .../headers/game/game_objects/bullet.hpp      |  36 ----
 .../game/game_objects/bullet_game_object.hpp  |  38 +++++
 .../game_objects/forest_map_game_object.hpp   |  80 +++++++++
 .../headers/game/game_objects/game_object.hpp |   7 +-
 .../game/game_objects/player_game_object.hpp  |  50 +++---
 .../client/headers/game/sfml_game.hpp         |   6 +-
 .../client/headers/renderer/sprite.hpp        |   8 +-
 .../client/headers/renderer/textures.hpp      | 154 +++++++++++++++++-
 .../sources/game/game_objects/bullet.cpp      |  42 -----
 .../game/game_objects/bullet_game_object.cpp  |  48 ++++++
 .../game/entity/bullet_game_object_entity.hpp | 103 ++++++++++++
 .../game/entity/game_entity_constants.hpp     |   2 +
 .../headers/game/entity/game_map_entity.hpp   |  97 +++++++++++
 .../game/entity/game_object_entity.hpp        |   6 +-
 .../headers/game/entity/game_object_type.hpp  |   2 +-
 .../game/entity/phy_game_object_entity.hpp    |  12 +-
 .../game/entity/player_game_object_entity.hpp |  41 +++--
 .../headers/game/player_action_controller.hpp |  29 +++-
 .../common_logic/headers/network/commands.hpp |  34 +++-
 battle_tanks/server/battle_tanks_server.cpp   |  16 +-
 battle_tanks/server/headers/game_server.hpp   |  16 +-
 battle_tanks/server/headers/game_session.hpp  |  66 ++++++--
 24 files changed, 797 insertions(+), 244 deletions(-)
 create mode 100644 battle_tanks/client/game_data/atlases/map_forest_tileset.png
 delete mode 100644 battle_tanks/client/headers/game/game_objects/bullet.hpp
 create mode 100644 battle_tanks/client/headers/game/game_objects/bullet_game_object.hpp
 create mode 100644 battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
 delete mode 100644 battle_tanks/client/sources/game/game_objects/bullet.cpp
 create mode 100644 battle_tanks/client/sources/game/game_objects/bullet_game_object.cpp
 create mode 100644 battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp
 create mode 100644 battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index d33f683..0232e92 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -2,6 +2,7 @@
 #include <cmath>
 #include <numbers>
 #include <chrono>
+#include <memory>
 #include <functional>
 
 #include "SFML/System/Clock.hpp"
@@ -14,12 +15,14 @@
 #include "renderer/renderer.hpp"
 #include "game/game_objects/player_game_object.hpp"
 #include "game/sfml_game.hpp"
-#include "game/game_objects/bullet.hpp"
+#include "game/game_objects/bullet_game_object.hpp"
 #include "physics/collision_listener.hpp"
 #include "network/client_connection.hpp"
 #include "network/connection_service.hpp"
 #include "network/player_actions.hpp"
-#include <game/game_objects/game_object_frame_restorer_packet.hpp>
+#include "game/entity/game_map_entity.hpp"
+#include "game/game_objects/forest_map_game_object.hpp"
+#include "game/game_objects/game_object_frame_restorer_packet.hpp"
 
 enum class player_game_state : unsigned int
 {
@@ -41,7 +44,7 @@ void create_test_rock(const std::unique_ptr<bt::sfml_game>& game, sf::Vector2f p
     b2BodyDef rock_body_def;
     rock_body_def.type = b2_staticBody;
     rock_body_def.position.Set(position.x / game->get_pixels_per_meters(), position.y / game->get_pixels_per_meters());
-    const auto rock_body = game->get_physics_body_factory().create_body(rock_body_def);
+    const auto rock_body = game->get_physics_body_factory().lock()->create_body(rock_body_def);
     b2PolygonShape rock_shape;
     rock_shape.SetAsBox(
         static_cast<float>(texture_data->get_size().x) / game->get_pixels_per_meters() / 2,
@@ -77,7 +80,7 @@ int main()
 
 
     constexpr float pixels_per_meters{ 10.0f }; // 1 meter = 10 pixels
-    const sf::Vector2u game_field_size{ 800, 600 };
+    const sf::Vector2u game_field_size{ 1024, 768 };
 
     auto window = std::make_shared<sf::RenderWindow>(sf::VideoMode(game_field_size.x, game_field_size.y), "Battle Tanks");
     //window->setFramerateLimit(20);
@@ -86,17 +89,51 @@ int main()
 
     std::unique_ptr<bt::sfml_game> game = std::make_unique<bt::sfml_game>(game_field_size, window, pixels_per_meters);
 
-    // <TEXTURES>
-    auto tank_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/tank.png");
-    auto tower_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/tower.png");
-    auto bullet_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/bullet_1.png");
-    // </TEXTURES>
+    bt::texture_warehouse texture_warehouse{};
 
+    auto map_atlas = bt::atlas_data{
+        bt::atlas_id::map_forest_tile_set,
+        "game_data/atlases/map_forest_tileset.png",
+        {
+            { bt::texture_id::grass_light_tl, sf::IntRect{1,1,16,16} },
+            { bt::texture_id::grass_light_tm, sf::IntRect{18,1,16,16} },
+            { bt::texture_id::grass_light_tr, sf::IntRect{35,1,16,16} },
 
-    auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
-    create_test_rock(game, {200.f, 200.f}, rock_texture_render_data);
+            { bt::texture_id::grass_light_lm, sf::IntRect{1,18,16,16} },
+            { bt::texture_id::grass_light_m, sf::IntRect{18,18,16,16} },
+            { bt::texture_id::grass_light_rm, sf::IntRect{35,18,16,16} },
 
-    bt::texture_warehouse texture_warehouse{};
+            { bt::texture_id::grass_light_bl, sf::IntRect{1,35,16,16} },
+            { bt::texture_id::grass_light_bm, sf::IntRect{18,35,16,16} },
+            { bt::texture_id::grass_light_br, sf::IntRect{35,35,16,16} },
+
+            { bt::texture_id::grass_light_dec_1, sf::IntRect{52,1,16,16} },
+            { bt::texture_id::grass_light_dec_2, sf::IntRect{69,1,16,16} },
+            { bt::texture_id::grass_light_dec_3, sf::IntRect{86,1,16,16} },
+
+            { bt::texture_id::grass_light_dec_4, sf::IntRect{52,18,16,16} },
+            { bt::texture_id::grass_light_dec_5, sf::IntRect{69,18,16,16} },
+            { bt::texture_id::grass_light_dec_6, sf::IntRect{86,18,16,16} },
+
+            { bt::texture_id::grass_light_dec_7, sf::IntRect{52,35,16,16} },
+            { bt::texture_id::grass_light_dec_8, sf::IntRect{69,35,16,16} },
+            { bt::texture_id::grass_light_dec_9, sf::IntRect{86,35,16,16} },
+
+            { bt::texture_id::grass_dark_tl, sf::IntRect{1,52,16,16} },
+            { bt::texture_id::grass_dark_tm, sf::IntRect{18,52,16,16} },
+            { bt::texture_id::grass_dark_tr, sf::IntRect{35,52,16,16} },
+
+            { bt::texture_id::grass_dark_lm, sf::IntRect{1,69,16,16} },
+            { bt::texture_id::grass_dark_m, sf::IntRect{18,69,16,16} },
+            { bt::texture_id::grass_dark_rm, sf::IntRect{35,69,16,16} },
+
+            { bt::texture_id::grass_dark_bl, sf::IntRect{1,86,16,16} },
+            { bt::texture_id::grass_dark_bm, sf::IntRect{18,86,16,16} },
+            { bt::texture_id::grass_dark_br, sf::IntRect{35,86,16,16} },
+        }
+    };
+
+    texture_warehouse.pre_load_atlas(map_atlas);
 
     bool tank_fire{ false };
     //TODO:: start move object immediately after key pressed. don't wait server to move 
@@ -104,39 +141,17 @@ int main()
     player_action tank_rotate_action{};
     player_action tower_rotate_action{};
 
-    // <EDGES>
-    b2Vec2 bottom_right_point = b2Vec2{
-            static_cast<float>(game_field_size.x) / pixels_per_meters,
-            static_cast<float>(game_field_size.y) / pixels_per_meters
-    };
-    b2BodyDef edge_body_def;
-    edge_body_def.type = b2_staticBody;
-    auto* edges_body = game->get_physics_body_factory().create_body(edge_body_def);
-
-    b2Filter edge_filter;
-    edge_filter.categoryBits = 0x8000;
-    edge_filter.maskBits = 0x0007;
-
-    b2EdgeShape top_edge_shape;
-    top_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(bottom_right_point.x, 0.0f));
-    auto* edge_fixture = edges_body->CreateFixture(&top_edge_shape, 1.0f);
-    edge_fixture->SetFilterData(edge_filter);
-
-    b2EdgeShape bottom_edge_shape;
-    bottom_edge_shape.SetTwoSided(b2Vec2(0.0f, bottom_right_point.y), bottom_right_point);
-    edge_fixture = edges_body->CreateFixture(&bottom_edge_shape, 1.0f);
-    edge_fixture->SetFilterData(edge_filter);
-
-    b2EdgeShape left_edge_shape;
-    left_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(0.0f, bottom_right_point.y));
-    edge_fixture = edges_body->CreateFixture(&left_edge_shape, 1.0f);
-    edge_fixture->SetFilterData(edge_filter);
-
-    b2EdgeShape right_edge_shape;
-    right_edge_shape.SetTwoSided(b2Vec2(bottom_right_point.x, 0.0f), bottom_right_point);
-    edge_fixture = edges_body->CreateFixture(&right_edge_shape, 1.0f);
-    edge_fixture->SetFilterData(edge_filter);
-    // </EDGES>
+    auto forest_game_map = std::make_shared<bt::forest_map_game_object>(
+        0,
+        texture_warehouse.load_pack(bt::textures_pack_id::map_forest),
+        sf::Vector2u{ 1024, 768 },
+        game->get_physics_body_factory()
+    );
+    forest_game_map->initialize();
+    game->add_game_object(forest_game_map);
+
+    auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
+    create_test_rock(game, { 200.f, 200.f }, rock_texture_render_data);
 
     auto bullet_creation_time = std::chrono::high_resolution_clock::now();
     while (window->isOpen())
@@ -223,30 +238,32 @@ int main()
                     {
                         bt::uuid game_object_id;
                         *packet_ref >> game_object_id;
-                        //sf::Uint32 game_object_type;
-                        //*packet_ref >> game_object_type;
 
                         bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
                         game->get_game_scene()->get_game_object(game_object_id)->restore_from_frame(restorer_packet);
-
-                        //if (game_object_type == static_cast<sf::Uint32>(bt::game_object_type::tank))
-                        //{
-                        //    bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
-                        //    player->restore_from_frame(restorer_packet);
-                        //}
-                        //else if (game_object_type == static_cast<sf::Uint32>(bt::game_object_type::bullet))
-                        //{
-                        //    sf::Uint32 bullet_id;
-                        //    *packet_ref >> bullet_id;
-                        //    sf::Vector2f bullet_position;
-                        //    *packet_ref >> bullet_position.x >> bullet_position.y;
-                        //    float bullet_rotation;
-                        //    *packet_ref >> bullet_rotation;
-                        //    std::cout << "bullet: " << bullet_id << " position: " << bullet_position.x << ", " << bullet_position.y
-                        //        << " rotation: " << bullet_rotation << std::endl;
-                        //}
                     }
                 }
+                break;
+            }
+            case command_id_server::player_shoot:
+            {
+                if (player_state == player_game_state::game_session)
+                {
+                    bt::uuid player_id;
+                    *packet_ref >> player_id;
+                    bt::uuid bullet_id;
+                    *packet_ref >> bullet_id;
+                    bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
+                    auto bullet = std::make_shared<bt::bullet_game_object>(
+                        bullet_id,
+                        game->get_physics_body_factory(),
+                        texture_warehouse.load_texture(bt::texture_id::bullet)
+                    );
+                    bullet->initialize();
+                    bullet->restore_from_frame(restorer_packet);
+                    game->add_game_object(bullet);
+                }
+                break;
             }
 
             }
@@ -355,6 +372,7 @@ int main()
 
             if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time).count() >= 1000)
             {
+                connection_service->send(player_action_command{ player_action::turret_fire });
                 /*bullet_creation_time = bullet_current_time;
                 const float bullet_rotation_rad = bt::deg_to_rad(tank_tower_sprite->getRotation() + tank_container->getRotation());
                 const b2Vec2 bullet_pos{
@@ -401,7 +419,5 @@ int main()
         game->update(delta_time);
     }
 
-    game->get_physics_body_factory().destroy_body(edges_body);
-
     return 0;
 }
diff --git a/battle_tanks/client/game_data/atlases/map_forest_tileset.png b/battle_tanks/client/game_data/atlases/map_forest_tileset.png
new file mode 100644
index 0000000000000000000000000000000000000000..5618770fe885c781290aa55137e367f23eb29214
GIT binary patch
literal 6678
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

literal 0
HcmV?d00001

diff --git a/battle_tanks/client/headers/game/game_objects/bullet.hpp b/battle_tanks/client/headers/game/game_objects/bullet.hpp
deleted file mode 100644
index 57ea3ae..0000000
--- a/battle_tanks/client/headers/game/game_objects/bullet.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include <SFML/System/Vector2.hpp>
-#include <box2d/b2_body.h>
-
-#include "game/game_objects/game_object.hpp"
-#include "renderer/textures.hpp"
-#include "utils/uuid.hpp"
-
-
-namespace bt
-{
-    //TODO:: create object poll for such objects
-    class bullet : public bt::game_object
-    {
-    public:
-        bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_holder>& render_data, b2Body* body);
-
-        virtual ~bullet() override = default;
-
-    public:
-
-        virtual void update(float delta_time) override;
-
-        virtual void free() override;
-
-    private:
-        float velocity_{ 0.0f };
-        sf::Vector2f position_{};
-        sf::Vector2u field_size_{};
-
-        std::shared_ptr<bt::texture_holder> render_data_{ nullptr };
-    };
-}
diff --git a/battle_tanks/client/headers/game/game_objects/bullet_game_object.hpp b/battle_tanks/client/headers/game/game_objects/bullet_game_object.hpp
new file mode 100644
index 0000000..f674603
--- /dev/null
+++ b/battle_tanks/client/headers/game/game_objects/bullet_game_object.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+
+#include "game/game_objects/game_object.hpp"
+#include "physics/physics_body_factory.hpp"
+#include "renderer/textures.hpp"
+#include "utils/uuid.hpp"
+
+
+namespace bt
+{
+    //TODO:: create object poll for such objects
+    class bullet_game_object : public bt::game_object
+    {
+    public:
+        bullet_game_object(
+            const bt::uuid id,
+            const std::weak_ptr<physics_body_factory>& ph_body_factory,
+            const std::shared_ptr<bt::texture_holder>& render_data
+            );
+
+        virtual ~bullet_game_object() override = default;
+
+    public:
+        virtual void restore_from_frame(const bt::game_object_frame_restorer& restorer) override;
+        virtual void update(float delta_time) override;
+
+    protected:
+        virtual void create_render_object() override;
+        virtual void create_game_object_entity() override;
+
+    private:
+
+        std::shared_ptr<bt::texture_holder> render_data_{ nullptr };
+        const std::weak_ptr<physics_body_factory> ph_body_factory_;
+    };
+}
diff --git a/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp b/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
new file mode 100644
index 0000000..1278402
--- /dev/null
+++ b/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "renderer/textures.hpp"
+
+
+namespace bt
+{
+    class forest_map_game_object : public bt::game_object
+    {
+    public:
+        explicit forest_map_game_object(
+            const bt::uuid id,
+            const std::shared_ptr<textures_pack>& map_textures_pack,
+            const sf::Vector2u& game_field_size,
+            const std::weak_ptr<bt::physics_body_factory>& ph_body_factory
+        )
+            : game_object(id), map_textures_pack_(map_textures_pack), field_size_{ game_field_size },
+            ph_body_factory_(ph_body_factory)
+        {
+        }
+
+        virtual ~forest_map_game_object() override = default;
+    public:
+        void restore_from_frame(const bt::game_object_frame_restorer& restorer) override
+        {
+        }
+
+        void update(float delta_time) override
+        {
+        }
+
+    protected:
+        void create_render_object() override
+        {
+            auto main_cont = std::make_shared<bt::container>();
+
+            auto bg_texture = map_textures_pack_->get_texture(texture_id::grass_dark_m);
+            bg_texture->get_texture()->setRepeated(true);
+
+            //TODO:: build tiles map from config file
+            //auto tile_size = sf::Vector2i{ bg_texture->get_texture_rect().width, bg_texture->get_texture_rect().height };
+            //const int tiles_count_x = field_size_.x / bg_texture->get_texture_rect().width + 1;
+            //const int tiles_count_y = field_size_.y / bg_texture->get_texture_rect().height + 1;
+
+            //for (int i = 0; i < tiles_count_x; ++i)
+            //{
+            //    for (int j = 0; j < tiles_count_y; ++j)
+            //    {
+            //        auto bg_tile = std::make_shared<bt::sprite>(bg_texture);
+            //        bg_tile->setPosition
+            //        (sf::Vector2f{ static_cast<float>(i * bg_texture->get_texture_rect().width),
+            //            static_cast<float>(j * bg_texture->get_texture_rect().height) }
+            //        );
+            //        main_cont->add_child(bg_tile);
+            //    }
+            //}
+
+            render_object_ = main_cont;
+        }
+
+        void create_game_object_entity() override
+        {
+            auto map_entity = std::make_unique<game_map_entity>(
+                0,
+                b2Vec2{
+                    static_cast<float>(field_size_.x) / physics_consts::pixels_per_meters,
+                    static_cast<float>(field_size_.y) / physics_consts::pixels_per_meters
+                },
+                ph_body_factory_
+            );
+            map_entity->build_map();
+            game_object_entity_ = std::move(map_entity);
+        }
+
+    private:
+        std::shared_ptr<textures_pack> map_textures_pack_;
+        sf::Vector2u field_size_;
+        std::weak_ptr<bt::physics_body_factory> ph_body_factory_;
+    };
+}
diff --git a/battle_tanks/client/headers/game/game_objects/game_object.hpp b/battle_tanks/client/headers/game/game_objects/game_object.hpp
index 59de7d4..8359ba1 100644
--- a/battle_tanks/client/headers/game/game_objects/game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/game_object.hpp
@@ -21,10 +21,7 @@ namespace bt
 
     public:
         virtual void restore_from_frame(const bt::game_object_frame_restorer& restorer) = 0;
-        virtual void create_render_object() = 0;
-        virtual void create_game_object_entity() = 0;
         virtual void update(float delta_time) = 0;
-        virtual void free() = 0;
 
     public:
         bt::uuid get_id() const
@@ -43,6 +40,10 @@ namespace bt
             create_render_object();
         }
 
+    protected:
+        virtual void create_render_object() = 0;
+        virtual void create_game_object_entity() = 0;
+
     protected:
         bt::uuid id_;
         std::shared_ptr<bt::render_object> render_object_{ nullptr };
diff --git a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
index 9b1114e..ef8bc93 100644
--- a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
@@ -3,7 +3,6 @@
 #include <memory>
 
 #include <SFML/System/Vector2.hpp>
-#include <box2d/b2_body.h>
 
 #include "game/entity/player_game_object_entity.hpp"
 #include "game/game_objects/game_object.hpp"
@@ -16,10 +15,11 @@ namespace bt
     class player_game_object : public bt::game_object
     {
     public:
-        player_game_object(const bt::uuid id,
+        player_game_object(
+            const bt::uuid id,
             const std::shared_ptr<bt::textures_pack>& textures_pack,
-            const physics_body_factory& ph_body_factory)
-            : game_object(id), textures_pack_{ textures_pack }, ph_body_factory_(ph_body_factory)
+            const std::weak_ptr<physics_body_factory>& ph_body_factory)
+            : game_object(id), textures_pack_{ textures_pack }, ph_body_factory_{ ph_body_factory }
         {
         }
 
@@ -31,6 +31,23 @@ namespace bt
             game_object_entity_->restore_frame(restorer);
         }
 
+        virtual void update(float delta_time) override
+        {
+            const auto frame = std::make_shared<player_game_object_frame>();
+            game_object_entity_->write_to_frame(frame);
+            const auto& ph_body_pos = frame->position;
+            const float ph_body_rot = frame->rotation;
+
+            render_object_->setPosition({ph_body_pos.x * physics_consts::pixels_per_meters, ph_body_pos.y * physics_consts::pixels_per_meters});
+            render_object_->setRotation(std::fmod(bt::rad_to_deg(ph_body_rot), 360.0f));
+
+            if (!turret_render_object_.expired())
+            {
+	            turret_render_object_.lock()->setRotation(frame->turret_rotation);
+            }
+        }
+
+    protected:
         virtual void create_render_object() override
         {
             auto tank_texture = textures_pack_->get_texture(texture_id::tank_base);
@@ -55,39 +72,18 @@ namespace bt
 
         virtual void create_game_object_entity() override
         {
-            auto player_entity = std::make_unique<bt::player_game_object_entity>(get_id(), ph_body_factory_);
+            auto player_entity = std::make_unique<bt::player_game_object_entity>(id_, ph_body_factory_);
             player_entity->create_phy_body();
             game_object_entity_ = std::move(player_entity);
         }
 
-        virtual void update(float delta_time) override
-        {
-            const auto frame = std::make_shared<player_game_object_frame>();
-            game_object_entity_->write_to_frame(frame);
-            const auto& ph_body_pos = frame->position;
-            const float ph_body_rot = frame->rotation;
-
-            render_object_->setPosition({ph_body_pos.x * physics_consts::pixels_per_meters, ph_body_pos.y * physics_consts::pixels_per_meters});
-            render_object_->setRotation(std::fmod(bt::rad_to_deg(ph_body_rot), 360.0f));
-
-            if (!turret_render_object_.expired())
-            {
-	            turret_render_object_.lock()->setRotation(frame->turret_rotation);
-            }
-        }
-
-        virtual void free() override
-        {
-            
-        }
-
     private:
         float velocity_{ 0.0f };
         sf::Vector2f position_{};
         sf::Vector2u field_size_{};
 
         std::shared_ptr<bt::textures_pack> textures_pack_;
-        const physics_body_factory& ph_body_factory_;
+        std::weak_ptr<physics_body_factory> ph_body_factory_;
 
         std::weak_ptr<bt::sprite> turret_render_object_{};
     };
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index 2812cce..e9a0424 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -40,6 +40,8 @@ namespace bt
                         objects_to_delete_.insert(game_object_b.id);
                     }
                 });
+
+            physics_body_factory_ = std::make_shared<physics_body_factory>(&physics_world_);
         }
 
         ~sfml_game()
@@ -64,7 +66,7 @@ namespace bt
             return render_scene_;
         }
 
-        const bt::physics_body_factory& get_physics_body_factory() const
+        std::weak_ptr<bt::physics_body_factory> get_physics_body_factory() const
         {
             return physics_body_factory_;
         }
@@ -108,7 +110,7 @@ namespace bt
         std::unique_ptr<bt::game_scene> game_world_{ nullptr };
         std::unique_ptr<bt::render_scene> render_scene_{ nullptr };
         b2World physics_world_{ b2Vec2{ 0.0f, 0.0f } };
-        bt::physics_body_factory physics_body_factory_{ &physics_world_ };
+        std::shared_ptr<bt::physics_body_factory> physics_body_factory_{ nullptr};
         SFMLDebugDraw* debug_draw_{ nullptr };
         std::unique_ptr<bt::collision_listener> contact_listener_{ nullptr };
 
diff --git a/battle_tanks/client/headers/renderer/sprite.hpp b/battle_tanks/client/headers/renderer/sprite.hpp
index 5ceb67a..3ec8b95 100644
--- a/battle_tanks/client/headers/renderer/sprite.hpp
+++ b/battle_tanks/client/headers/renderer/sprite.hpp
@@ -10,20 +10,16 @@ namespace bt
     class sprite : public bt::render_object
     {
     public:
-        explicit sprite(const std::string& path)
-        {
-            texture_render_data_ = std::make_shared<texture_holder>(path);
-            sprite_.setTexture(*texture_render_data_->get_texture());
-        }
-
         explicit sprite(const std::shared_ptr<texture_holder>& texture_render_data)
         {
             texture_render_data_ = texture_render_data;
             sprite_.setTexture(*texture_render_data_->get_texture());
+            sprite_.setTextureRect(texture_render_data_->get_texture_rect());
         }
 
         virtual ~sprite() override = default;
 
+
     protected:
         void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
         {
diff --git a/battle_tanks/client/headers/renderer/textures.hpp b/battle_tanks/client/headers/renderer/textures.hpp
index 9615733..8432b1c 100644
--- a/battle_tanks/client/headers/renderer/textures.hpp
+++ b/battle_tanks/client/headers/renderer/textures.hpp
@@ -14,23 +14,72 @@ namespace bt
         tank_base = 1,
         tank_turret = 2,
         bullet = 3,
+
+        //atlas 
+        grass_light_m,
+        grass_light_tl,
+        grass_light_tm,
+        grass_light_tr,
+        grass_light_bl,
+        grass_light_bm,
+        grass_light_br,
+        grass_light_lm,
+        grass_light_rm,
+
+        grass_light_dec_1,
+        grass_light_dec_2,
+        grass_light_dec_3,
+        grass_light_dec_4,
+        grass_light_dec_5,
+        grass_light_dec_6,
+        grass_light_dec_7,
+        grass_light_dec_8,
+        grass_light_dec_9,
+
+        grass_dark_m,
+        grass_dark_tl,
+        grass_dark_tm,
+        grass_dark_tr,
+        grass_dark_bl,
+        grass_dark_bm,
+        grass_dark_br,
+        grass_dark_lm,
+        grass_dark_rm,
     };
 
     enum class textures_pack_id
     {
         unknown = 0,
-        tank = 1,
+        tank,
+        map_forest,
+    };
+
+    enum class atlas_id
+    {
+        unknown = 0,
+        map_forest_tile_set,
     };
 
     class texture_holder
     {
     public:
+        explicit texture_holder(const std::shared_ptr<sf::Texture>& atlas_texture, const sf::IntRect& texture_rect)
+        {
+            texture_ = atlas_texture;
+            texture_size_ = texture_->getSize();
+            texture_rect_ = texture_rect;
+        }
+
         explicit texture_holder(const std::string& path)
         {
             texture_ = std::make_shared<sf::Texture>();
             texture_->loadFromFile(path);
             texture_->setSmooth(true);
             texture_size_ = texture_->getSize();
+            texture_rect_ = { 0,0,
+                static_cast<int>(texture_size_.x),
+                static_cast<int>(texture_size_.y)
+            };
         }
 
     public:
@@ -44,9 +93,15 @@ namespace bt
             return texture_size_;
         }
 
+        sf::IntRect get_texture_rect() const
+        {
+            return texture_rect_;
+        }
+
     private:
         std::shared_ptr<sf::Texture> texture_{ nullptr };
         sf::Vector2u texture_size_{};
+        sf::IntRect texture_rect_;
     };
 
     class texture_loader
@@ -60,13 +115,17 @@ namespace bt
     class textures_pack
     {
     public:
-        textures_pack(const bt::textures_pack_id id, const std::vector<texture_id>& textures_ids, const std::shared_ptr<texture_loader>& loader)
+        textures_pack(const bt::textures_pack_id id, const std::vector<texture_id>& textures_ids, texture_loader* loader)
             : id_{ id }, textures_ids_{ textures_ids }, loader_{ loader }
         {
         }
 
         void load_pack()
         {
+            if (loader_ == nullptr)
+            {
+	            return;
+            }
             for (const auto& texture_id : textures_ids_)
             {
                 loaded_textures_.emplace(texture_id, loader_->load_texture(texture_id));
@@ -96,10 +155,46 @@ namespace bt
     private:
         bt::textures_pack_id id_{ bt::textures_pack_id::unknown };
         std::vector<texture_id> textures_ids_{};
-        std::shared_ptr<texture_loader> loader_{ nullptr };
+        texture_loader* loader_{ nullptr };
         std::unordered_map<texture_id, std::shared_ptr<texture_holder>> loaded_textures_{};
     };
 
+    class atlas_data
+    {
+    public:
+        //TODO:: move atlas data to config file and create atlas_data from it
+        atlas_data(
+            const atlas_id id,
+            const std::string& atlas_path,
+            const std::unordered_map<texture_id, sf::IntRect>& textures_rect)
+            : id_(id), textures_rect_(textures_rect), atlas_path_(atlas_path)
+        {
+        }
+
+        ~atlas_data() = default;
+
+    public:
+        const std::string& get_atlas_path() const
+        {
+            return atlas_path_;
+        }
+
+        const std::unordered_map<texture_id, sf::IntRect>& get_textures_rect() const
+        {
+            return textures_rect_;
+        }
+
+        atlas_id get_id() const
+        {
+            return id_;
+        }
+
+    private:
+        atlas_id id_;
+        std::unordered_map<texture_id, sf::IntRect> textures_rect_;
+        std::string atlas_path_;
+    };
+
     class texture_warehouse : public texture_loader
     {
     public:
@@ -117,19 +212,34 @@ namespace bt
         }
 
     public:
+        void pre_load_atlas(const atlas_data& atlas_data)
+        {
+            const auto& textures_rect = atlas_data.get_textures_rect();
+            const auto atlas_texture = std::make_shared<sf::Texture>();
+            atlas_texture->loadFromFile(atlas_data.get_atlas_path());
+
+            for (const auto& [texture_id, texture_rect] : textures_rect)
+            {
+                if (!loaded_textures_.contains(texture_id))
+                {
+                    loaded_textures_.emplace(texture_id, std::make_shared<texture_holder>(atlas_texture, texture_rect));
+                }
+            }
+        }
+
         std::shared_ptr<textures_pack> load_pack(const textures_pack_id id)
         {
             if (!textures_packs_.contains(id))
             {
                 const std::vector<texture_id>& textures_ids = get_textures_ids(id);
-                textures_packs_.emplace(id, std::make_shared<textures_pack>(id, textures_ids, std::make_shared<texture_warehouse>()));
+                textures_packs_.emplace(id, std::make_shared<textures_pack>(id, textures_ids, this));
                 textures_packs_.at(id)->load_pack();
             }
             
             return textures_packs_.at(id);
         }
 
-        std::shared_ptr<texture_holder> get_texture(const textures_pack_id pack_id, const texture_id texture_id)
+        std::shared_ptr<texture_holder> get_texture(const textures_pack_id pack_id, const texture_id texture_id) const
         {
             if (!textures_packs_.contains(pack_id))
             {
@@ -153,11 +263,44 @@ namespace bt
         {
             static std::vector tank_textures_ids{ texture_id::tank_base, texture_id::tank_turret };
             static std::vector bullet_textures_ids{ texture_id::bullet };
+            static std::vector map_forest_texture_ids{
+                texture_id::grass_light_m,
+                texture_id::grass_light_tl,
+                texture_id::grass_light_tm,
+                texture_id::grass_light_tr,
+                texture_id::grass_light_bl,
+                texture_id::grass_light_bm,
+                texture_id::grass_light_br,
+                texture_id::grass_light_lm,
+                texture_id::grass_light_rm,
+
+                texture_id::grass_light_dec_1,
+                texture_id::grass_light_dec_2,
+                texture_id::grass_light_dec_3,
+                texture_id::grass_light_dec_4,
+                texture_id::grass_light_dec_5,
+                texture_id::grass_light_dec_6,
+                texture_id::grass_light_dec_7,
+                texture_id::grass_light_dec_8,
+                texture_id::grass_light_dec_9,
+
+                texture_id::grass_dark_m,
+                texture_id::grass_dark_tl,
+                texture_id::grass_dark_tm,
+                texture_id::grass_dark_tr,
+                texture_id::grass_dark_bl,
+                texture_id::grass_dark_bm,
+                texture_id::grass_dark_br,
+                texture_id::grass_dark_lm,
+                texture_id::grass_dark_rm,
+            };
             static std::vector unknown_textures_ids{ texture_id::unknown };
             switch (id)
             {
             case textures_pack_id::tank:
                 return tank_textures_ids;
+            case textures_pack_id::map_forest:
+                return map_forest_texture_ids;
             case textures_pack_id::unknown:
                 return unknown_textures_ids;
             default:
@@ -184,5 +327,6 @@ namespace bt
     private:
         std::unordered_map<textures_pack_id, std::shared_ptr<textures_pack>> textures_packs_{};
         std::unordered_map<texture_id, std::shared_ptr<texture_holder>> loaded_textures_{};
+        std::weak_ptr<texture_loader> loader_;
     };
 }
diff --git a/battle_tanks/client/sources/game/game_objects/bullet.cpp b/battle_tanks/client/sources/game/game_objects/bullet.cpp
deleted file mode 100644
index 7711560..0000000
--- a/battle_tanks/client/sources/game/game_objects/bullet.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <box2d/b2_math.h>
-
-#include "game/game_objects//bullet.hpp"
-#include "renderer/sprite.hpp"
-
-#include "utils/math.hpp"
-
-bt::bullet::bullet(const bt::uuid id, float velocity, const std::shared_ptr<bt::texture_holder>& render_data, b2Body* body) :
-    bt::game_object(id), velocity_{ velocity }, render_data_{ render_data }
-{
-
-}
-
-//void bt::bullet::initialize()
-//{
-//    render_object_ = std::make_shared<bt::sprite>(render_data_);
-//}
-
-void bt::bullet::update(float delta_time)
-{
-    //if (render_object_ == nullptr || velocity_ == 0.0f)
-    //{
-    //    return;
-    //}
-
-    //auto& ph_body_pos = physics_body_->GetPosition();
-    //const float ph_body_rot = physics_body_->GetAngle();
-
-    ////TODO 10.0f move to constants
-    //render_object_->setPosition({ ph_body_pos.x * 10.0f, ph_body_pos.y * 10.0f });
-    //render_object_->setRotation(rad_to_deg_360(ph_body_rot));
-}
-
-void bt::bullet::free()
-{
-    /*if (render_object_ != nullptr)
-    {
-        const auto render_object = render_object_;
-        render_object_ = nullptr;
-        render_object->free();
-    }*/
-}
diff --git a/battle_tanks/client/sources/game/game_objects/bullet_game_object.cpp b/battle_tanks/client/sources/game/game_objects/bullet_game_object.cpp
new file mode 100644
index 0000000..efbd11d
--- /dev/null
+++ b/battle_tanks/client/sources/game/game_objects/bullet_game_object.cpp
@@ -0,0 +1,48 @@
+#include "game/game_objects//bullet_game_object.hpp"
+
+#include "game/entity/bullet_game_object_entity.hpp"
+#include "game/entity/game_entity_constants.hpp"
+#include "renderer/sprite.hpp"
+
+#include "utils/math.hpp"
+
+
+bt::bullet_game_object::bullet_game_object(
+    const bt::uuid id,
+    const std::weak_ptr<physics_body_factory>& ph_body_factory,
+    const std::shared_ptr<bt::texture_holder>& render_data)
+    : bt::game_object(id), render_data_{ render_data }, ph_body_factory_(ph_body_factory)
+{
+}
+
+void bt::bullet_game_object::restore_from_frame(const bt::game_object_frame_restorer& restorer)
+{
+    game_object_entity_->restore_frame(restorer);
+}
+
+void bt::bullet_game_object::create_render_object()
+{
+    render_object_ = std::make_shared<bt::sprite>(render_data_);
+    render_object_->setOrigin(
+        game_entity_consts::bullet_size.x / 2.0f,
+        game_entity_consts::bullet_size.y / 2.0f
+    );
+}
+
+void bt::bullet_game_object::create_game_object_entity()
+{
+    auto bullet_entity = std::make_unique<bt::bullet_game_object_entity>(id_, ph_body_factory_/*, velocity_, rotation_rad_, tank_position_*/);
+    bullet_entity->create_phy_body();
+    game_object_entity_ = std::move(bullet_entity);
+}
+
+void bt::bullet_game_object::update(float delta_time)
+{
+    const auto frame = std::make_shared<player_game_object_frame>();
+    game_object_entity_->write_to_frame(frame);
+    const auto& ph_body_pos = frame->position;
+    const float ph_body_rot = frame->rotation;
+
+    render_object_->setPosition({ ph_body_pos.x * physics_consts::pixels_per_meters, ph_body_pos.y * physics_consts::pixels_per_meters });
+    render_object_->setRotation(std::fmod(bt::rad_to_deg(ph_body_rot), 360.0f));
+}
diff --git a/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp
new file mode 100644
index 0000000..ef9a42b
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "box2d/b2_fixture.h"
+#include "box2d/b2_polygon_shape.h"
+#include "SFML/Config.hpp"
+
+#include "game/entity/phy_game_object_entity.hpp"
+#include "game/entity/game_entity_constants.hpp"
+#include "physics/physics_body_factory.hpp"
+#include "game/player_action_controller.hpp"
+#include "game/game_objects/game_object_frame_restorer.hpp"
+#include "physics/game_object_b2d_link.hpp"
+
+namespace bt
+{
+    class bullet_game_object_entity : public bt::phy_game_object_entity
+    {
+        public:
+            bullet_game_object_entity(const sf::Uint32 id, const std::weak_ptr<physics_body_factory>& ph_body_factory)
+                : bt::phy_game_object_entity(id, game_object_type::bullet, ph_body_factory)
+            {
+            }
+
+            virtual ~bullet_game_object_entity() override = default;
+
+        public:
+            virtual void create_phy_body() override
+            {
+                if (ph_body_factory_.expired())
+                {
+                    return;
+                }
+                b2BodyDef bullet_body_def;
+                bullet_body_def.type = b2_dynamicBody;
+                phy_body_ = ph_body_factory_.lock()->create_body(bullet_body_def);
+                b2PolygonShape bullet_shape;
+                bullet_shape.SetAsBox(
+                    game_entity_consts::bullet_size.x / physics_consts::pixels_per_meters / 2,
+                    game_entity_consts::bullet_size.y / physics_consts::pixels_per_meters / 2
+                );
+                auto* fixture = phy_body_->CreateFixture(&bullet_shape, 1.0f);
+
+                auto* bullet_link = new bt::game_object_b2d_link{ bt::game_object_type::bullet, id_ };
+                phy_body_->GetUserData().pointer = reinterpret_cast<uintptr_t>(bullet_link);
+
+                b2Filter filter;
+                filter.categoryBits = 0x0001;
+                filter.maskBits = 0x8001;
+                fixture->SetFilterData(filter);
+            }
+
+            virtual void update(const float dt) override
+            {
+            }
+
+            virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const override
+            {
+                game_object_frame frame{};
+                restorer.restore_frame(frame);
+
+                phy_body_->SetTransform(
+                    b2Vec2(
+                        frame.position.x,
+                        frame.position.y
+                    ),
+                    frame.rotation
+                );
+                phy_body_->SetLinearVelocity(
+                    b2Vec2(
+                        frame.velocity.x,
+                        frame.velocity.y
+                    )
+                );
+                //phy_body_->SetAngularVelocity(frame.velocity_angle);
+                phy_body_->SetAwake(true);
+            }
+    public:
+        void create_physics_body(const b2Vec2& player_position, const float rotation_rad, const float velocity)
+        {
+            create_phy_body();
+            const b2Vec2 bullet_pos{
+               (player_position.x + game_entity_consts::turret_length * std::sin(rotation_rad)),
+               (player_position.y - game_entity_consts::turret_length * std::cos(rotation_rad))
+            };
+
+            const auto force = b2Vec2{
+                   std::sin(rotation_rad) * velocity,
+                   -std::cos(rotation_rad) * velocity
+            };
+            phy_body_->SetTransform(bullet_pos, rotation_rad);
+            phy_body_->SetLinearVelocity(force);
+        }
+
+    protected:
+        [[nodiscard]]
+        virtual std::shared_ptr<game_object_frame> create_frame() const override
+        {
+            auto go_frame = std::make_unique<game_object_frame>();
+            return go_frame;
+        }
+
+    };
+}
diff --git a/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp b/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
index 26097ff..628ae40 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
@@ -8,6 +8,8 @@ namespace bt
 	namespace game_entity_consts
 	{
 		static sf::Vector2f tank_size{33.0f, 54.0f};
+		static sf::Vector2f bullet_size{ 6.0f, 24.0f };
+		static float turret_length = 8.0f;//meters
 	}
 
 	namespace physics_consts
diff --git a/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp b/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
new file mode 100644
index 0000000..83ee26b
--- /dev/null
+++ b/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
@@ -0,0 +1,97 @@
+#pragma once
+
+#include <box2d/box2d.h>
+
+#include "game_object_type.hpp"
+
+
+class game_map_entity : public bt::game_object_entity
+{
+public:
+    explicit game_map_entity(const sf::Uint32 id, const b2Vec2& game_field_size, const std::weak_ptr<bt::physics_body_factory>& ph_body_factory)
+        : game_object_entity(id, bt::game_object_type::map_forest), game_field_size_{game_field_size}, ph_body_factory_{ph_body_factory}
+    {
+    }
+
+    virtual ~game_map_entity() override
+    {
+        if (!ph_body_factory_.expired())
+        {
+            const auto factory = ph_body_factory_.lock();
+            for (auto* phy_body : phy_bodies_)
+            {
+                factory->destroy_body(phy_body);
+            }
+
+            phy_bodies_.clear();
+        }
+    }
+
+public:
+    void build_map()
+    {
+        if (ph_body_factory_.expired())
+        {
+            return;
+        }
+
+        const auto phy_body_factory = ph_body_factory_.lock();
+        build_edges(phy_body_factory);
+    }
+
+    void restore_frame(const bt::game_object_frame_restorer& restorer) const override
+    {
+    }
+
+    void update(const float delta_time) override
+    {
+    }
+
+protected:
+
+    //TODO:: create map from server configuration
+    [[nodiscard]] std::shared_ptr<game_object_frame> create_frame() const override
+    {
+        return nullptr;
+    }
+    void fill_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const override
+	{}
+
+private:
+    void build_edges(const std::shared_ptr<bt::physics_body_factory>& factory)
+    {
+        b2BodyDef edge_body_def;
+        edge_body_def.type = b2_staticBody;
+        b2Body* edges_body = factory->create_body(edge_body_def);
+        phy_bodies_.push_back(edges_body);
+
+        b2Filter edge_filter;
+        edge_filter.categoryBits = 0x8000;
+        edge_filter.maskBits = 0x0007;
+
+        b2EdgeShape top_edge_shape;
+        top_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(game_field_size_.x, 0.0f));
+        auto* edge_fixture = edges_body->CreateFixture(&top_edge_shape, 1.0f);
+        edge_fixture->SetFilterData(edge_filter);
+
+        b2EdgeShape bottom_edge_shape;
+        bottom_edge_shape.SetTwoSided(b2Vec2(0.0f, game_field_size_.y), game_field_size_);
+        edge_fixture = edges_body->CreateFixture(&bottom_edge_shape, 1.0f);
+        edge_fixture->SetFilterData(edge_filter);
+
+        b2EdgeShape left_edge_shape;
+        left_edge_shape.SetTwoSided(b2Vec2(0.0f, 0.0f), b2Vec2(0.0f, game_field_size_.y));
+        edge_fixture = edges_body->CreateFixture(&left_edge_shape, 1.0f);
+        edge_fixture->SetFilterData(edge_filter);
+
+        b2EdgeShape right_edge_shape;
+        right_edge_shape.SetTwoSided(b2Vec2(game_field_size_.x, 0.0f), game_field_size_);
+        edge_fixture = edges_body->CreateFixture(&right_edge_shape, 1.0f);
+        edge_fixture->SetFilterData(edge_filter);
+    }
+
+private:
+    b2Vec2 game_field_size_;
+    std::weak_ptr<bt::physics_body_factory> ph_body_factory_;
+    std::vector<b2Body*> phy_bodies_{};
+};
diff --git a/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
index 257075e..8bd32c8 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
@@ -37,20 +37,20 @@ namespace bt
         std::shared_ptr<game_object_frame> get_frame() const
         {
             auto object_frame = create_frame();
-            set_frame_data(object_frame);
+            fill_frame_data(object_frame);
             return object_frame;
         }
 
         void write_to_frame(const std::shared_ptr<game_object_frame>& object_frame) const
         {
-            set_frame_data(object_frame);
+            fill_frame_data(object_frame);
         }
 
     protected:
         [[nodiscard]]
         virtual std::shared_ptr<game_object_frame> create_frame() const = 0;
 
-        virtual void set_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const
+        virtual void fill_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const
         {
             object_frame->game_object_id = id_;
             object_frame->game_object_type = type_;
diff --git a/battle_tanks/common_logic/headers/game/entity/game_object_type.hpp b/battle_tanks/common_logic/headers/game/entity/game_object_type.hpp
index e2b96b1..bd45cda 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_object_type.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_object_type.hpp
@@ -8,7 +8,7 @@ namespace bt
         tank,
         bullet,
         wall,
-        brick
+        map_forest,
     };
 
 }
\ No newline at end of file
diff --git a/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
index 2d2cb11..004616b 100644
--- a/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
@@ -11,16 +11,16 @@ namespace bt
     class phy_game_object_entity : public bt::game_object_entity
     {
     public:
-        phy_game_object_entity(const sf::Uint32 id, const bt::game_object_type type, const physics_body_factory& ph_body_factory)
+        phy_game_object_entity(const sf::Uint32 id, const bt::game_object_type type, const std::weak_ptr<physics_body_factory>& ph_body_factory)
             : bt::game_object_entity(id, type), ph_body_factory_{ ph_body_factory }
         {
         }
 
         virtual ~phy_game_object_entity() override
         {
-            if (phy_body_ != nullptr)
+            if (phy_body_ != nullptr && !ph_body_factory_.expired())
             {
-                ph_body_factory_.destroy_body(phy_body_);
+                ph_body_factory_.lock()->destroy_body(phy_body_);
                 phy_body_ = nullptr;
             }
         }
@@ -29,9 +29,9 @@ namespace bt
         virtual void create_phy_body() = 0;
 
     protected:
-        virtual void set_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
+        virtual void fill_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
         {
-            bt::game_object_entity::set_frame_data(object_frame);
+            bt::game_object_entity::fill_frame_data(object_frame);
             object_frame->position = { phy_body_->GetPosition().x, phy_body_->GetPosition().y };
             object_frame->rotation = phy_body_->GetAngle();
             object_frame->velocity = { phy_body_->GetLinearVelocity().x, phy_body_->GetLinearVelocity().y };
@@ -40,6 +40,6 @@ namespace bt
 
     protected:
         b2Body* phy_body_{ nullptr };
-        const physics_body_factory& ph_body_factory_;
+        std::weak_ptr<physics_body_factory> ph_body_factory_;
     };
 }
diff --git a/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
index 37674a3..a72c4ab 100644
--- a/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
@@ -13,12 +13,10 @@
 
 namespace bt
 {
-    class game_object_frame_restorer;
-
     class player_game_object_entity : public bt::phy_game_object_entity
     {
     public:
-        player_game_object_entity(const sf::Uint32 id, const physics_body_factory& ph_body_factory)
+        player_game_object_entity(const sf::Uint32 id, const std::weak_ptr<physics_body_factory>& ph_body_factory)
             : bt::phy_game_object_entity(id, game_object_type::tank, ph_body_factory)
         {
         }
@@ -28,13 +26,14 @@ namespace bt
     public:
         virtual void create_phy_body() override
         {
+            if (ph_body_factory_.expired())
+            {
+                return;
+            }
+
             b2BodyDef tank_body_def;
             tank_body_def.type = b2_dynamicBody;
-            //tank_body_def.position.Set(
-            //    100.0f / bt::physics_consts::pixels_per_meters,
-            //    100.0f / bt::physics_consts::pixels_per_meters
-            //);
-            phy_body_ = ph_body_factory_.create_body(tank_body_def);
+            phy_body_ = ph_body_factory_.lock()->create_body(tank_body_def);
             b2PolygonShape tank_shape;
             tank_shape.SetAsBox(
                 bt::game_entity_consts::tank_size.x / bt::physics_consts::pixels_per_meters / 2,
@@ -59,14 +58,6 @@ namespace bt
             action_controller_->update(dt);
         }
 
-    public:
-
-        [[nodiscard]]
-        std::weak_ptr<bt::player_action_controller> get_action_controller() const
-        {
-            return action_controller_;
-        }
-
         virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const override
         {
             player_game_object_frame frame{};
@@ -91,6 +82,20 @@ namespace bt
             action_controller_->set_turret_rotation(frame.turret_rotation);
         }
 
+    public:
+
+        [[nodiscard]]
+        std::weak_ptr<bt::player_action_controller> get_action_controller() const
+        {
+            return action_controller_;
+        }
+
+        void create_physics_body(const b2Vec2 position, const float rotation = 0.0f)
+        {
+            create_phy_body();
+            phy_body_->SetTransform(position, rotation);
+        }
+
     protected:
         [[nodiscard]]
         virtual std::shared_ptr<game_object_frame> create_frame() const override
@@ -104,9 +109,9 @@ namespace bt
             return go_frame;
         }
 
-        virtual void set_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
+        virtual void fill_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
         {
-            bt::phy_game_object_entity::set_frame_data(object_frame);
+            bt::phy_game_object_entity::fill_frame_data(object_frame);
             auto* go_frame = dynamic_cast<player_game_object_frame*>(object_frame.get());
             go_frame->turret_rotation = action_controller_->get_turret_rotation();
         }
diff --git a/battle_tanks/common_logic/headers/game/player_action_controller.hpp b/battle_tanks/common_logic/headers/game/player_action_controller.hpp
index 374ee45..e2f6844 100644
--- a/battle_tanks/common_logic/headers/game/player_action_controller.hpp
+++ b/battle_tanks/common_logic/headers/game/player_action_controller.hpp
@@ -1,8 +1,11 @@
 #pragma once
 
 #include <numbers>
+#include <chrono>
 
 #include "network/player_actions.hpp"
+#include "utils/math.hpp"
+
 
 namespace bt
 {
@@ -86,9 +89,21 @@ namespace bt
             turret_rotation_ = rotation;
         }
 
-        bool turret_fire()
+        bool set_fire_action(const player_action action)
         {
-            
+            if (action == player_action::turret_stop_fire)
+            {
+                return false;
+            }
+
+            const auto current_time = std::chrono::high_resolution_clock::now();
+            if (std::chrono::duration_cast<std::chrono::milliseconds>(current_time - turret_last_fire_time_).count() < 1000)
+            {
+                return false;
+            }
+
+            turret_last_fire_time_ = current_time;
+            return true;
         }
 
         void update(const float delta_time)
@@ -104,6 +119,15 @@ namespace bt
             }
         }
 
+        b2Vec2 get_position() const
+        {
+            return phy_body_->GetPosition();
+        }
+
+        float get_absolute_turret_rotation() const
+        {
+            return phy_body_->GetAngle() + bt::deg_to_rad(turret_rotation_);
+        }
 
     private:
         player_action move_action_{player_action::stop_move};
@@ -112,6 +136,7 @@ namespace bt
         player_action turret_fire_{player_action::turret_stop_fire};
 
         float turret_rotation_{0.0f};
+        std::chrono::time_point<std::chrono::steady_clock> turret_last_fire_time_{};
 
         b2Body* phy_body_{ nullptr };
     };
diff --git a/battle_tanks/common_logic/headers/network/commands.hpp b/battle_tanks/common_logic/headers/network/commands.hpp
index 974e5cc..d7383e8 100644
--- a/battle_tanks/common_logic/headers/network/commands.hpp
+++ b/battle_tanks/common_logic/headers/network/commands.hpp
@@ -35,6 +35,8 @@ enum class command_id_server : sf::Uint32
     update_game_frame = 10007,
 
     delete_game_object = 10008,
+
+    player_shoot = 10009,
 };
 
 template <class T>
@@ -52,6 +54,11 @@ struct simple_command
     {
         packet << static_cast<sf::Uint32>(command_id);
     }
+
+    virtual void read_from_packet(sf::Packet& packet)
+    {
+        packet >> reinterpret_cast<sf::Uint32&>(command_id);
+    }
 };
 
 ////// TODO:: move from common to CLIENT
@@ -99,7 +106,7 @@ struct player_action_command : client_command
 };
 
 
-////// TODO:: move from common to SERVER
+////// TODO:: move to server_commands
 struct server_command : simple_command<command_id_server>
 {
     explicit server_command(const command_id_server id) : simple_command{ id }
@@ -265,6 +272,31 @@ struct session_started_command : server_command
     }
 };
 
+struct player_shoot final : server_command
+{
+    player_shoot() : server_command(command_id_server::player_shoot)
+    {
+    }
+    virtual ~player_shoot() override = default;
+
+    sf::Uint32 player_id{};
+    game_object_frame game_object{};
+
+    void write_to_packet(sf::Packet& packet) const override
+    {
+        simple_command::write_to_packet(packet);
+        packet << player_id;
+		game_object.write_to_packet(packet);
+    }
+
+    virtual void read_from_packet(sf::Packet& packet) override
+    {
+        //simple_command::read_from_packet(packet);
+        packet >> player_id;
+		game_object.read_from_packet(packet);
+    }
+};
+
 ///////////////////////////////////
 struct connection_command_in
 {
diff --git a/battle_tanks/server/battle_tanks_server.cpp b/battle_tanks/server/battle_tanks_server.cpp
index cdd4787..96ddca7 100644
--- a/battle_tanks/server/battle_tanks_server.cpp
+++ b/battle_tanks/server/battle_tanks_server.cpp
@@ -1,11 +1,23 @@
+#include <cstdlib>
+#include <cstring>
+
 #include "game_server.hpp"
 
-int main()
+int main(int argc, char* argv[])
 {
+    unsigned int port = 52000;
+
+    if (argc > 1) {
+        if (strcmp(argv[1], "-port") == 0 && argc > 2) {
+            port = atoi(argv[2]);
+        }
+    }
+
     game_server server{};
 
-    if (server.start(52000))
+    if (server.start(port))
     {
+        std::cout << "Server started on port " << port << std::endl;
         server.run_infinity_loop(100, 100, true);
     }
 
diff --git a/battle_tanks/server/headers/game_server.hpp b/battle_tanks/server/headers/game_server.hpp
index 84e03d2..4d28ac0 100644
--- a/battle_tanks/server/headers/game_server.hpp
+++ b/battle_tanks/server/headers/game_server.hpp
@@ -28,7 +28,7 @@ class game_server
     }
 
 public:
-    bool start(const unsigned short port);
+    bool start(const unsigned int port);
     [[noreturn]] void run_infinity_loop(const size_t max_messages_in, const size_t max_messages_out, const bool wait_in);
 
 private:
@@ -48,7 +48,7 @@ class game_server
     std::unordered_map<sf::Uint32, sf::Uint32> connection_to_session_link_{};
 };
 
-bool game_server::start(const unsigned short port)
+bool game_server::start(const unsigned int port)
 {
     network_server_ = std::make_unique<network_server>(port);
 
@@ -95,25 +95,25 @@ bool game_server::start(const unsigned short port)
                 case player_action::move_backward:
                 case player_action::stop_move:
                     session->second->move_player(connection_id, action);
-	                break;
+                    break;
                 case player_action::turn_left:
                 case player_action::turn_right:
                 case player_action::stop_turn:
                     session->second->rotate_player(connection_id, action);
-	                break;
+                    break;
                 case player_action::turn_turret_left:
                 case player_action::turn_turret_right:
                 case player_action::stop_turn_turret:
                     session->second->rotate_player_turret(connection_id, action);
-	                break;
+                    break;
                 case player_action::turret_fire:
                 case player_action::turret_stop_fire:
-
-	                break;
+                	session->second->player_turret_fire(connection_id, action);
+                    break;
                 case player_action::unknown:
                 default:
                     //TODO:: send error to client
-                	;
+                    ;
                 }
             }
 
diff --git a/battle_tanks/server/headers/game_session.hpp b/battle_tanks/server/headers/game_session.hpp
index 11a14c4..53ec121 100644
--- a/battle_tanks/server/headers/game_session.hpp
+++ b/battle_tanks/server/headers/game_session.hpp
@@ -6,8 +6,9 @@
 #include "box2d/b2_world.h"
 
 #include "game/entity/game_object_entity.hpp"
+#include "game/entity/bullet_game_object_entity.hpp"
 #include "game/entity/player_game_object_entity.hpp"
-#include "game/game_objects/game_object_frame_restorer_packet.hpp"
+#include "game/entity/game_map_entity.hpp"
 
 #include "network/commands.hpp"
 #include "physics/collision_listener.hpp"
@@ -18,7 +19,7 @@ enum class game_session_type : sf::Uint32
     unknown = 0,
     pvp_1x1,
     team_2x2,
-    deathmatch_4,
+    death_match_4,
 };
 
 enum class game_session_state : unsigned
@@ -54,6 +55,8 @@ class game_session
             });
 
         state_ = game_session_state::waiting_for_players;
+
+        physics_body_factory_ = std::make_shared<bt::physics_body_factory>(&physics_world_);
     }
 
     ~game_session()
@@ -109,6 +112,40 @@ class game_session
         }
     }
 
+    void player_turret_fire(const sf::Uint32 player_id, const player_action action)
+    {
+        std::lock_guard lock{ mutex_game_loop_ };
+        if (const auto controller = get_player_action_controller(player_id))
+        {
+            if (controller->set_fire_action(action))
+            {
+                const auto& player_controller = players_action_controllers_.at(player_id);
+
+                if (player_controller.expired())
+                {
+                    return;
+                }
+                const auto controller_ptr = player_controller.lock();
+
+                auto bullet_id = bt::generate_uuid();
+                auto bullet = std::make_unique<bt::bullet_game_object_entity>(bullet_id, physics_body_factory_);
+
+                bullet->create_physics_body(
+                    controller_ptr->get_position(),
+                    controller_ptr->get_absolute_turret_rotation(),
+                    50.0f // m/s
+                );
+
+                auto shot_command = std::make_unique<player_shoot>();
+                shot_command->player_id = player_id;
+                shot_command->game_object = *bullet->get_frame();
+
+                game_objects_.emplace(bullet_id, std::move(bullet));
+                commands_out_->push_back({ players_ids_,std::move(shot_command) });
+            }
+        }
+    }
+
 private:
     void update();
 
@@ -144,7 +181,9 @@ class game_session
 
     b2World physics_world_ = b2World{ b2Vec2{ 0.0f, 0.0f } };
     bt::collision_listener contact_listener_{};
-    bt::physics_body_factory physics_body_factory_{ &physics_world_ };
+    std::shared_ptr<bt::physics_body_factory> physics_body_factory_{ nullptr };
+
+    std::unique_ptr<game_map_entity> game_map_{ nullptr };
 
     std::unordered_set<bt::uuid> objects_to_delete_{};
     std::unordered_map<sf::Uint32, std::unique_ptr<bt::game_object_entity>> game_objects_{};
@@ -165,6 +204,11 @@ void game_session::update()
             current_count_down_time -= clock.restart().asMilliseconds();
             if (current_count_down_time <= 0)
             {
+                std::weak_ptr<bt::physics_body_factory> physics_body_factory_weak = physics_body_factory_;
+                auto size = b2Vec2 { 102.4f, 76.8f };
+                game_map_ = std::make_unique<game_map_entity>(0, size, physics_body_factory_weak);
+                game_map_->build_map();
+
                 state_ = game_session_state::game_play_progress;
 
                 auto command = std::make_unique<session_started_command>();
@@ -228,26 +272,16 @@ bool game_session::join_player(sf::Uint32 player_id)
     std::lock_guard lock{ mutex_game_loop_ };
 
     auto player_entity = std::make_unique<bt::player_game_object_entity>(player_id, physics_body_factory_);
-    player_entity->create_phy_body();
-
 
     //TODO:: new player state configuration
-    const auto packet = std::make_shared<sf::Packet>();
-    player_game_object_frame frame{};
     if (players_ids_.empty())
     {
-        frame.position = { 10.0f, 10.f };
+        player_entity->create_physics_body({ 10.0f, 10.0f });
     }
     else
     {
-        frame.position = { 40.0f, 40.f };
+        player_entity->create_physics_body({ 40.0f, 40.0f });
     }
-    frame.write_to_packet(*packet);
-    sf::Uint32 id;
-    *packet >> id;
-    const bt::game_object_frame_restorer_packet restorer{ packet };
-    player_entity->restore_frame(restorer);
-    /////////////////////////////////////////
 
     players_action_controllers_.emplace(player_id, player_entity->get_action_controller());
     game_objects_.emplace(player_id, std::move(player_entity));
@@ -258,7 +292,7 @@ bool game_session::join_player(sf::Uint32 player_id)
     joined_command->player_id = player_id;
     commands_out_->push_back({ players_ids_, std::move(joined_command) });
 
-    if (players_ids_.size() == 2)
+    if (players_ids_.size() == 1)
     {
         state_ = game_session_state::starting;
         thread_game_loop_ = std::thread{ &game_session::update, this };

From fc87628fbc27b0ad45bced0defeccd24b42208ae Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Mon, 2 Oct 2023 23:10:56 +0300
Subject: [PATCH 07/13] add static game object "rock_1"

---
 battle_tanks/client/battle_tanks.cpp          | 41 +------------------
 .../game_objects/forest_map_game_object.hpp   | 23 +++++++++++
 .../headers/game/game_objects/game_scene.hpp  |  1 +
 .../game/game_objects/player_game_object.hpp  |  2 +
 .../client/headers/game/sfml_game.hpp         |  1 +
 .../headers/game/entity/game_map_entity.hpp   | 25 +++++++++++
 .../headers/game/player_action_controller.hpp | 10 +++++
 battle_tanks/server/headers/game_server.hpp   |  1 +
 battle_tanks/server/headers/game_session.hpp  |  4 +-
 9 files changed, 66 insertions(+), 42 deletions(-)

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 0232e92..42be136 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -1,9 +1,6 @@
 #include <iostream>
-#include <cmath>
-#include <numbers>
 #include <chrono>
 #include <memory>
-#include <functional>
 
 #include "SFML/System/Clock.hpp"
 #include "SFML/Graphics.hpp"
@@ -11,8 +8,6 @@
 #include <box2d/box2d.h>
 
 #include "utils/uuid.hpp"
-#include "utils/math.hpp"
-#include "renderer/renderer.hpp"
 #include "game/game_objects/player_game_object.hpp"
 #include "game/sfml_game.hpp"
 #include "game/game_objects/bullet_game_object.hpp"
@@ -20,7 +15,6 @@
 #include "network/client_connection.hpp"
 #include "network/connection_service.hpp"
 #include "network/player_actions.hpp"
-#include "game/entity/game_map_entity.hpp"
 #include "game/game_objects/forest_map_game_object.hpp"
 #include "game/game_objects/game_object_frame_restorer_packet.hpp"
 
@@ -34,39 +28,6 @@ enum class player_game_state : unsigned int
     game_session,
 };
 
-void create_test_rock(const std::unique_ptr<bt::sfml_game>& game, sf::Vector2f position, const std::shared_ptr<bt::texture_holder>& texture_data)
-{
-    const auto rock_sprite = std::make_shared<bt::sprite>(texture_data);
-    rock_sprite->setPosition(position);
-    rock_sprite->setOrigin(static_cast<float>(texture_data->get_size().x) / 2.0f, static_cast<float>(texture_data->get_size().y) / 2.0f);
-    game->get_render_scene()->add_child(rock_sprite);
-
-    b2BodyDef rock_body_def;
-    rock_body_def.type = b2_staticBody;
-    rock_body_def.position.Set(position.x / game->get_pixels_per_meters(), position.y / game->get_pixels_per_meters());
-    const auto rock_body = game->get_physics_body_factory().lock()->create_body(rock_body_def);
-    b2PolygonShape rock_shape;
-    rock_shape.SetAsBox(
-        static_cast<float>(texture_data->get_size().x) / game->get_pixels_per_meters() / 2,
-        static_cast<float>(texture_data->get_size().y) / game->get_pixels_per_meters() / 2
-    );
-    auto* fixture = rock_body->CreateFixture(&rock_shape, 1.0f);
-    b2Filter filter;
-    filter.categoryBits = 0x0002;
-    filter.maskBits = 0x8006;
-
-    fixture->SetFilterData(filter);
-
-    //bt::uuid rock_id = bt::generate_uuid();
-    //auto* rock_link = new bt::game_object_b2d_link{ bt::game_object_type::rock, rock_id };
-    //rock_body->GetUserData().pointer = reinterpret_cast<uintptr_t>(rock_link);
-
-    //const auto rock = std::make_shared<bt::rock>(rock_id, texture_data, rock_body);
-    //rock->initialize();
-    //game->get_game_scene()->add_game_object(rock);
-    //game->get_render_scene()->add_child(rock->get_render_object());
-}
-
 int main()
 {
     auto player_state = player_game_state::disconnected;
@@ -151,7 +112,7 @@ int main()
     game->add_game_object(forest_game_map);
 
     auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
-    create_test_rock(game, { 200.f, 200.f }, rock_texture_render_data);
+    forest_game_map->create_rock({ 200, 200 }, rock_texture_render_data);
 
     auto bullet_creation_time = std::chrono::high_resolution_clock::now();
     while (window->isOpen())
diff --git a/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp b/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
index 1278402..ac325fc 100644
--- a/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "game/entity/game_map_entity.hpp"
 #include "renderer/textures.hpp"
 
 
@@ -28,6 +29,28 @@ namespace bt
         void update(float delta_time) override
         {
         }
+    public:
+        void create_rock(const sf::Vector2f position, const std::shared_ptr<bt::texture_holder>& texture_data) const
+        {
+	        const auto main_cont = dynamic_cast<bt::container*>(render_object_.get());
+            const auto rock_sprite = std::make_shared<bt::sprite>(texture_data);
+            rock_sprite->setPosition(position);
+            const auto size = texture_data->get_size();
+            rock_sprite->setOrigin(static_cast<float>(size.x) / 2.0f, static_cast<float>(size.y) / 2.0f);
+            main_cont->add_child(rock_sprite);
+
+            const auto entity = dynamic_cast<game_map_entity*>(game_object_entity_.get());
+            entity->create_rock(
+                {
+                    position.x / physics_consts::pixels_per_meters,
+                    position.y / physics_consts::pixels_per_meters
+                },
+                {
+                    size.x / physics_consts::pixels_per_meters,
+                    size.y / physics_consts::pixels_per_meters,
+                }
+                );
+        }
 
     protected:
         void create_render_object() override
diff --git a/battle_tanks/client/headers/game/game_objects/game_scene.hpp b/battle_tanks/client/headers/game/game_objects/game_scene.hpp
index 3ee874d..8277424 100644
--- a/battle_tanks/client/headers/game/game_objects/game_scene.hpp
+++ b/battle_tanks/client/headers/game/game_objects/game_scene.hpp
@@ -3,6 +3,7 @@
 #include <memory>
 #include <ranges>
 
+
 namespace bt
 {
     class game_scene
diff --git a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
index ef8bc93..907216e 100644
--- a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
@@ -6,6 +6,8 @@
 
 #include "game/entity/player_game_object_entity.hpp"
 #include "game/game_objects/game_object.hpp"
+#include "renderer/container.hpp"
+#include "renderer/sprite.hpp"
 #include "renderer/textures.hpp"
 #include "utils/uuid.hpp"
 
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index e9a0424..25c5932 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -8,6 +8,7 @@
 #include "physics/collision_listener.hpp"
 #include "game_objects/game_scene.hpp"
 #include "physics/physics_body_factory.hpp"
+#include "renderer/render_scene.hpp"
 
 
 namespace bt
diff --git a/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp b/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
index 83ee26b..9dc91b9 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
@@ -39,6 +39,31 @@ class game_map_entity : public bt::game_object_entity
         build_edges(phy_body_factory);
     }
 
+    void create_rock(const b2Vec2 position, const b2Vec2 size)
+    {
+        if (ph_body_factory_.expired())
+        {
+            return;
+        }
+        const auto phy_body_factory = ph_body_factory_.lock();
+
+        b2BodyDef rock_body_def;
+        rock_body_def.type = b2_staticBody;
+        rock_body_def.position.Set(position.x, position.y);
+        const auto rock_body = phy_body_factory->create_body(rock_body_def);
+        phy_bodies_.push_back(rock_body);
+
+        b2PolygonShape rock_shape;
+        rock_shape.SetAsBox(size.x /2.0f, size.y / 2.0f);
+        auto* fixture = rock_body->CreateFixture(&rock_shape, 1.0f);
+        b2Filter filter;
+        filter.categoryBits = 0x0002;
+        filter.maskBits = 0x8006;
+
+        fixture->SetFilterData(filter);
+    }
+
+public:
     void restore_frame(const bt::game_object_frame_restorer& restorer) const override
     {
     }
diff --git a/battle_tanks/common_logic/headers/game/player_action_controller.hpp b/battle_tanks/common_logic/headers/game/player_action_controller.hpp
index e2f6844..f74744b 100644
--- a/battle_tanks/common_logic/headers/game/player_action_controller.hpp
+++ b/battle_tanks/common_logic/headers/game/player_action_controller.hpp
@@ -117,6 +117,16 @@ namespace bt
             {
                 turret_rotation_ += rotate_speed * delta_time;
             }
+
+            if (move_action_ == player_action::stop_move)
+            {
+                phy_body_->SetLinearVelocity({ 0.0f, 0.0f });
+            }
+
+            if (rotate_action_ == player_action::stop_turn)
+            {
+                phy_body_->SetAngularVelocity(0.0f);
+            }
         }
 
         b2Vec2 get_position() const
diff --git a/battle_tanks/server/headers/game_server.hpp b/battle_tanks/server/headers/game_server.hpp
index 4d28ac0..129218a 100644
--- a/battle_tanks/server/headers/game_server.hpp
+++ b/battle_tanks/server/headers/game_server.hpp
@@ -142,6 +142,7 @@ bool game_server::start(const unsigned int port)
 
 void game_server::send_commands()
 {
+    //TODO::check sessions state and delete finished or broken
     while (is_running_)
     {
         commands_out_->wait();
diff --git a/battle_tanks/server/headers/game_session.hpp b/battle_tanks/server/headers/game_session.hpp
index 53ec121..42a1c44 100644
--- a/battle_tanks/server/headers/game_session.hpp
+++ b/battle_tanks/server/headers/game_session.hpp
@@ -204,10 +204,10 @@ void game_session::update()
             current_count_down_time -= clock.restart().asMilliseconds();
             if (current_count_down_time <= 0)
             {
-                std::weak_ptr<bt::physics_body_factory> physics_body_factory_weak = physics_body_factory_;
                 auto size = b2Vec2 { 102.4f, 76.8f };
-                game_map_ = std::make_unique<game_map_entity>(0, size, physics_body_factory_weak);
+                game_map_ = std::make_unique<game_map_entity>(0, size, physics_body_factory_);
                 game_map_->build_map();
+                game_map_->create_rock({ 20.0f, 20.0f }, { 5.7f, 4.2f });
 
                 state_ = game_session_state::game_play_progress;
 

From d5f186a7c6919fad317c018f4cb3c2eba417f7ec Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Tue, 3 Oct 2023 00:00:39 +0300
Subject: [PATCH 08/13] delete empty game session on server. delete bullets
 when contact with edges

---
 battle_tanks/client/battle_tanks.cpp          | 51 ++++---------------
 .../client/headers/game/sfml_game.hpp         | 16 +++---
 battle_tanks/server/headers/game_server.hpp   | 20 ++++++--
 battle_tanks/server/headers/game_session.hpp  | 18 ++++++-
 4 files changed, 53 insertions(+), 52 deletions(-)

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 42be136..2f8927e 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -226,7 +226,16 @@ int main()
                 }
                 break;
             }
-
+            case command_id_server::delete_game_object:
+            {
+                if (player_state == player_game_state::game_session)
+                {
+                    bt::uuid game_object_id;
+                    *packet_ref >> game_object_id;
+                    game->delete_game_object(game_object_id);
+                }
+                break;
+            }
             }
         }
         sf::Event event;
@@ -334,46 +343,6 @@ int main()
             if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time).count() >= 1000)
             {
                 connection_service->send(player_action_command{ player_action::turret_fire });
-                /*bullet_creation_time = bullet_current_time;
-                const float bullet_rotation_rad = bt::deg_to_rad(tank_tower_sprite->getRotation() + tank_container->getRotation());
-                const b2Vec2 bullet_pos{
-                (tank_container->getPosition().x + 80 * std::sin(bullet_rotation_rad)) / pixels_per_meters,
-                (tank_container->getPosition().y - 80 * std::cos(bullet_rotation_rad)) / pixels_per_meters
-                };
-                b2BodyDef bullet_body_def;
-                bullet_body_def.type = b2_dynamicBody;
-                bullet_body_def.position.Set(bullet_pos.x, bullet_pos.y);
-                auto* bullet_body = game->get_physics_world()->CreateBody(&bullet_body_def);
-                b2PolygonShape bullet_shape;
-                bullet_shape.SetAsBox(
-                    static_cast<float>(bullet_texture_render_data->get_size().x) / pixels_per_meters / 2,
-                    static_cast<float>(bullet_texture_render_data->get_size().y) / pixels_per_meters / 2
-                );
-                auto* fixture = bullet_body->CreateFixture(&bullet_shape, 1.0f);
-                bt::uuid bullet_id = bt::generate_uuid();
-                auto* bullet_link = new bt::game_object_b2d_link{ bt::game_object_type::bullet, bullet_id };
-                bullet_body->GetUserData().pointer = reinterpret_cast<uintptr_t>(bullet_link);
-
-                b2Filter filter;
-                filter.categoryBits = 0x0001;
-                filter.maskBits = 0x8001;
-                fixture->SetFilterData(filter);
-
-                auto force = b2Vec2{
-                    std::sin(bullet_rotation_rad) * 500.0f / pixels_per_meters,
-                    -std::cos(bullet_rotation_rad) * 500.0f / pixels_per_meters
-                };
-                bullet_body->SetTransform(bullet_pos, bullet_rotation_rad);
-                bullet_body->SetLinearVelocity(force);
-
-                const auto bt = std::make_shared<bt::bullet>(bullet_id, 500.0f, bullet_texture_render_data, bullet_body);
-                bt->initialize();
-                bt->get_render_object()->setOrigin(
-                    static_cast<float>(bullet_texture_render_data->get_size().x) / 2.0f,
-                    static_cast<float>(bullet_texture_render_data->get_size().y) / 2.0f
-                );
-                game->get_game_scene()->add_game_object(bt);
-                game->get_render_scene()->add_child(bt->get_render_object());*/
             }
         }
 
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index 25c5932..cb58877 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -34,11 +34,11 @@ namespace bt
                 {
                     if (game_object_a.type == bt::game_object_type::bullet)
                     {
-                        objects_to_delete_.insert(game_object_a.id);
+                        //objects_to_delete_.insert(game_object_a.id);
                     }
                     else if (game_object_b.type == bt::game_object_type::bullet)
                     {
-                        objects_to_delete_.insert(game_object_b.id);
+                        //objects_to_delete_.insert(game_object_b.id);
                     }
                 });
 
@@ -57,6 +57,11 @@ namespace bt
             render_scene_->add_child(game_object->get_render_object());
         }
 
+        void delete_game_object(const bt::uuid game_object_id)
+        {
+            objects_to_delete_.insert(game_object_id);
+        }
+
         const std::unique_ptr<bt::game_scene>& get_game_scene() const
         {
             return game_world_;
@@ -94,14 +99,13 @@ namespace bt
     private:
         void delete_game_objects()
         {
-            /*for (const auto& game_object_id : objects_to_delete_)
+            for (const auto& game_object_id : objects_to_delete_)
             {
                 auto game_object = game_world_->get_game_object(game_object_id);
-                physics_world_->DestroyBody(game_object->get_physics_body());
-                game_object->free();
+                render_scene_->remove_child(game_object->get_render_object());
                 game_world_->remove_game_object(game_object);
             }
-            objects_to_delete_.clear();*/
+            objects_to_delete_.clear();
         }
 
     private:
diff --git a/battle_tanks/server/headers/game_server.hpp b/battle_tanks/server/headers/game_server.hpp
index 129218a..c4a2048 100644
--- a/battle_tanks/server/headers/game_server.hpp
+++ b/battle_tanks/server/headers/game_server.hpp
@@ -89,7 +89,7 @@ bool game_server::start(const unsigned int port)
 
             if (const auto session = sessions_.find(session_id); session != sessions_.end())
             {
-                switch(action)
+                switch (action)
                 {
                 case player_action::move_forward:
                 case player_action::move_backward:
@@ -108,7 +108,7 @@ bool game_server::start(const unsigned int port)
                     break;
                 case player_action::turret_fire:
                 case player_action::turret_stop_fire:
-                	session->second->player_turret_fire(connection_id, action);
+                    session->second->player_turret_fire(connection_id, action);
                     break;
                 case player_action::unknown:
                 default:
@@ -122,8 +122,20 @@ bool game_server::start(const unsigned int port)
     network_server_->register_client_command_handler(command_id_client::lost_connection,
         [this](const sf::Uint32 connection_id, sf::Packet& packet)
         {
-            //TODO:: remove player from session and remove session if it has one or less players
-            connection_to_session_link_.erase(connection_id);
+            if (connection_to_session_link_.contains(connection_id))
+            {
+                const auto session_id = connection_to_session_link_.at(connection_id);
+                if (sessions_.contains(session_id))
+                {
+                    const auto& session = sessions_.at(session_id);
+                    session->player_lost_connection(connection_id);
+                    if (session->get_state() == game_session_state::finished)
+                    {
+                        sessions_.erase(session_id);
+                    }
+                }
+                connection_to_session_link_.erase(connection_id);
+            }
         });
 
     return network_server_->start();
diff --git a/battle_tanks/server/headers/game_session.hpp b/battle_tanks/server/headers/game_session.hpp
index 42a1c44..18a9cf8 100644
--- a/battle_tanks/server/headers/game_session.hpp
+++ b/battle_tanks/server/headers/game_session.hpp
@@ -42,7 +42,8 @@ class game_session
         //physics_world.SetContinuousPhysics(true);;
         physics_world_.SetContactListener(&contact_listener_);
 
-        contact_listener_.add_collision_handler([this](bt::game_object_b2d_link game_object_a, bt::game_object_b2d_link game_object_b)
+        contact_listener_.add_collision_handler(
+            [this](const bt::game_object_b2d_link game_object_a, const bt::game_object_b2d_link game_object_b)
             {
                 if (game_object_a.type == bt::game_object_type::bullet)
                 {
@@ -146,6 +147,21 @@ class game_session
         }
     }
 
+    void player_lost_connection(const bt::uuid player_id)
+    {
+        std::lock_guard lock{ mutex_game_loop_ };
+        if (players_action_controllers_.contains(player_id))
+        {
+            players_action_controllers_.erase(player_id);
+            game_objects_.erase(player_id);
+            std::erase(players_ids_, player_id);
+        }
+        if (players_ids_.empty())
+        {
+            state_ = game_session_state::finished;
+        }
+    }
+
 private:
     void update();
 

From 7fa1092f01a2db96895a52a0aba574354419e5ef Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Tue, 3 Oct 2023 03:41:15 +0300
Subject: [PATCH 09/13] add rough damage logic, ui for displaying health

---
 battle_tanks/client/battle_tanks.cpp          |  82 ++++++++++++++++--
 .../game_data/fonts/wheaton capitals.otf      | Bin 0 -> 36920 bytes
 .../game_objects/forest_map_game_object.hpp   |   6 +-
 .../game/game_objects/player_game_object.hpp  |   8 +-
 .../client/headers/game/sfml_game.hpp         |  32 ++-----
 .../game/entity/bullet_game_object_entity.hpp |   5 +-
 .../game/entity/game_entity_constants.hpp     |  11 ++-
 .../headers/game/entity/game_map_entity.hpp   |   7 +-
 .../game/entity/game_object_entity.hpp        |   4 +-
 .../game/entity/phy_game_object_entity.hpp    |  10 +++
 .../game/entity/player_game_object_entity.hpp |  51 ++++++++---
 .../common_logic/headers/network/commands.hpp |   2 +-
 battle_tanks/server/headers/game_session.hpp  |  37 ++++++--
 13 files changed, 195 insertions(+), 60 deletions(-)
 create mode 100644 battle_tanks/client/game_data/fonts/wheaton capitals.otf

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 2f8927e..1a2c50f 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -28,6 +28,22 @@ enum class player_game_state : unsigned int
     game_session,
 };
 
+void set_text_color(sf::Text& text, const sf::Int32 current_hp)
+{
+    if (current_hp > 50)
+    {
+        text.setFillColor(sf::Color::Green);
+    }
+    else if (current_hp > 25)
+    {
+        text.setFillColor(sf::Color::Yellow);
+    }
+    else
+    {
+        text.setFillColor(sf::Color::Red);
+    }
+}
+
 int main()
 {
     auto player_state = player_game_state::disconnected;
@@ -39,19 +55,44 @@ int main()
     player_state = player_game_state::connecting;
     std::cout << "connecting..." << std::endl;
 
+    auto window = std::make_shared<sf::RenderWindow>(
+        sf::VideoMode(
+            bt::game_entity_consts::game_field_size.x,
+            bt::game_entity_consts::game_field_size.y
+        ),
+        "Battle Tanks"
+    );
+    //window->setFramerateLimit(60);
 
-    constexpr float pixels_per_meters{ 10.0f }; // 1 meter = 10 pixels
-    const sf::Vector2u game_field_size{ 1024, 768 };
-
-    auto window = std::make_shared<sf::RenderWindow>(sf::VideoMode(game_field_size.x, game_field_size.y), "Battle Tanks");
-    //window->setFramerateLimit(20);
+    bt::uuid player_id{};
+    std::unordered_map<bt::uuid, std::shared_ptr<bt::player_game_object>> players {};
 
     sf::Clock clock;
 
-    std::unique_ptr<bt::sfml_game> game = std::make_unique<bt::sfml_game>(game_field_size, window, pixels_per_meters);
+    std::unique_ptr<bt::sfml_game> game = std::make_unique<bt::sfml_game>(
+        window,
+        bt::physics_consts::pixels_per_meters
+    );
 
     bt::texture_warehouse texture_warehouse{};
 
+    sf::Font font;
+    font.loadFromFile("game_data/fonts/wheaton capitals.otf");
+    sf::Text player_hp;
+    player_hp.setPosition(10, 10);
+    player_hp.setFont(font);
+    player_hp.setString("100");
+    player_hp.setCharacterSize(24);
+    player_hp.setFillColor(sf::Color::Green);
+    player_hp.setStyle(sf::Text::Bold);
+
+    sf::Text enemy_hp;
+    enemy_hp.setFont(font);
+    enemy_hp.setString("100");
+    enemy_hp.setCharacterSize(24);
+    enemy_hp.setFillColor(sf::Color::Green);
+    enemy_hp.setStyle(sf::Text::Bold);
+
     auto map_atlas = bt::atlas_data{
         bt::atlas_id::map_forest_tile_set,
         "game_data/atlases/map_forest_tileset.png",
@@ -105,7 +146,7 @@ int main()
     auto forest_game_map = std::make_shared<bt::forest_map_game_object>(
         0,
         texture_warehouse.load_pack(bt::textures_pack_id::map_forest),
-        sf::Vector2u{ 1024, 768 },
+        bt::game_entity_consts::game_field_size,
         game->get_physics_body_factory()
     );
     forest_game_map->initialize();
@@ -138,6 +179,7 @@ int main()
                 if (player_state == player_game_state::connecting)
                 {
                     player_state = player_game_state::main_lobby;
+                    *packet_ref >> player_id;
                     std::cout << "connected" << std::endl;
                 }
                 break;
@@ -185,6 +227,7 @@ int main()
                         player->initialize();
                         player->restore_from_frame(restorer_packet);
                         game->add_game_object(player);
+                        players.emplace(game_object_id, player);
                     }
                 }
                 break;
@@ -233,6 +276,11 @@ int main()
                     bt::uuid game_object_id;
                     *packet_ref >> game_object_id;
                     game->delete_game_object(game_object_id);
+
+                    if (players.contains(game_object_id))
+                    {
+                        players.erase(game_object_id);
+                    }
                 }
                 break;
             }
@@ -347,6 +395,26 @@ int main()
         }
 
         game->update(delta_time);
+
+        for (const auto& player : players | std::views::values)
+        {
+            if (player->get_id() == player_id)
+            {
+                player_hp.setString(std::to_string(player->get_health()));
+                set_text_color(player_hp, player->get_health());
+            }
+            else
+            {
+                enemy_hp.setString(std::to_string(player->get_health()));
+                set_text_color(enemy_hp, player->get_health());
+            }
+        }
+
+        enemy_hp.setPosition(static_cast<float>(bt::game_entity_consts::game_field_size.x) - enemy_hp.getLocalBounds().width - 15, 10);
+        window->draw(player_hp);
+        window->draw(enemy_hp);
+
+        window->display();
     }
 
     return 0;
diff --git a/battle_tanks/client/game_data/fonts/wheaton capitals.otf b/battle_tanks/client/game_data/fonts/wheaton capitals.otf
new file mode 100644
index 0000000000000000000000000000000000000000..b32c8bcad3623ce79159d65f937c6c1c78fc7c37
GIT binary patch
literal 36920
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%0Ac@c)ML{~OBp8p?;D)9rc{o6QkEI9xaphm~HV
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
P)BQ3QAt;=L^{W2^T;6vD

literal 0
HcmV?d00001

diff --git a/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp b/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
index ac325fc..1620b1c 100644
--- a/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/forest_map_game_object.hpp
@@ -32,7 +32,7 @@ namespace bt
     public:
         void create_rock(const sf::Vector2f position, const std::shared_ptr<bt::texture_holder>& texture_data) const
         {
-	        const auto main_cont = dynamic_cast<bt::container*>(render_object_.get());
+            const auto main_cont = dynamic_cast<bt::container*>(render_object_.get());
             const auto rock_sprite = std::make_shared<bt::sprite>(texture_data);
             rock_sprite->setPosition(position);
             const auto size = texture_data->get_size();
@@ -46,8 +46,8 @@ namespace bt
                     position.y / physics_consts::pixels_per_meters
                 },
                 {
-                    size.x / physics_consts::pixels_per_meters,
-                    size.y / physics_consts::pixels_per_meters,
+                    static_cast<float>(size.x) / physics_consts::pixels_per_meters,
+                    static_cast<float>(size.y) / physics_consts::pixels_per_meters,
                 }
                 );
         }
diff --git a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
index 907216e..9a42ca2 100644
--- a/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
+++ b/battle_tanks/client/headers/game/game_objects/player_game_object.hpp
@@ -45,10 +45,16 @@ namespace bt
 
             if (!turret_render_object_.expired())
             {
-	            turret_render_object_.lock()->setRotation(frame->turret_rotation);
+                turret_render_object_.lock()->setRotation(frame->turret_rotation);
             }
         }
 
+    public:
+        sf::Int32 get_health() const
+        {
+            return dynamic_cast<player_game_object_entity*>(game_object_entity_.get())->get_health();
+        }
+
     protected:
         virtual void create_render_object() override
         {
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index cb58877..976b7b5 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -16,19 +16,17 @@ namespace bt
     class sfml_game
     {
     public:
-        sfml_game(sf::Vector2u field_size, const std::shared_ptr<sf::RenderWindow>& render_target, const float pixels_per_meters)
-            : pixels_per_meters_{ pixels_per_meters }, window_{ render_target }
+        sfml_game(const std::shared_ptr<sf::RenderWindow>& render_target, const float pixels_per_meters)
+            : pixels_per_meters_{ pixels_per_meters }, debug_draw_{ render_target, pixels_per_meters_ }, window_{ render_target }
         {
             game_world_ = std::make_unique<bt::game_scene>();
             render_scene_ = std::make_unique<bt::render_scene>(render_target);
-            //physics_world_ = std::make_unique<b2World>(b2Vec2{ 0.0f, 0.0f });
             physics_world_.SetAllowSleeping(true);
             //physics_world.SetContinuousPhysics(true);
             contact_listener_ = std::make_unique<bt::collision_listener>();
             physics_world_.SetContactListener(contact_listener_.get());
-            debug_draw_ = new SFMLDebugDraw(render_target, pixels_per_meters_);
-            debug_draw_->AppendFlags(b2Draw::e_shapeBit);
-            physics_world_.SetDebugDraw(debug_draw_);
+            debug_draw_.AppendFlags(b2Draw::e_shapeBit);
+            physics_world_.SetDebugDraw(&debug_draw_);
 
             contact_listener_->add_collision_handler([this](bt::game_object_b2d_link game_object_a, bt::game_object_b2d_link game_object_b)
                 {
@@ -47,11 +45,10 @@ namespace bt
 
         ~sfml_game()
         {
-            delete debug_draw_;
         }
 
     public:
-        void add_game_object(const std::shared_ptr<bt::game_object>& game_object)
+        void add_game_object(const std::shared_ptr<bt::game_object>& game_object) const
         {
             game_world_->add_game_object(game_object);
             render_scene_->add_child(game_object->get_render_object());
@@ -67,21 +64,11 @@ namespace bt
             return game_world_;
         }
 
-        const std::unique_ptr<bt::render_scene>& get_render_scene() const
-        {
-            return render_scene_;
-        }
-
         std::weak_ptr<bt::physics_body_factory> get_physics_body_factory() const
         {
             return physics_body_factory_;
         }
 
-        float get_pixels_per_meters() const
-        {
-            return pixels_per_meters_;
-        }
-
         void update(const float delta_time)
         {
             window_->clear(sf::Color::Black);
@@ -93,7 +80,7 @@ namespace bt
             render_scene_->draw_scene();
             physics_world_.DebugDraw();
 
-            window_->display();
+            //window_->display();
         }
 
     private:
@@ -110,16 +97,15 @@ namespace bt
 
     private:
         float pixels_per_meters_{};
+        b2World physics_world_{ b2Vec2{ 0.0f, 0.0f } };
+        std::unordered_set<bt::uuid> objects_to_delete_{};
+        SFMLDebugDraw debug_draw_;
 
         std::shared_ptr<sf::RenderWindow> window_{ nullptr };
         std::unique_ptr<bt::game_scene> game_world_{ nullptr };
         std::unique_ptr<bt::render_scene> render_scene_{ nullptr };
-        b2World physics_world_{ b2Vec2{ 0.0f, 0.0f } };
         std::shared_ptr<bt::physics_body_factory> physics_body_factory_{ nullptr};
-        SFMLDebugDraw* debug_draw_{ nullptr };
         std::unique_ptr<bt::collision_listener> contact_listener_{ nullptr };
-
-        std::unordered_set<bt::uuid> objects_to_delete_{};
     };
 
 }
diff --git a/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp
index ef9a42b..89a6765 100644
--- a/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/bullet_game_object_entity.hpp
@@ -45,7 +45,7 @@ namespace bt
 
                 b2Filter filter;
                 filter.categoryBits = 0x0001;
-                filter.maskBits = 0x8001;
+                filter.maskBits = 0x8005;//4-player, 1-bullet
                 fixture->SetFilterData(filter);
             }
 
@@ -53,7 +53,7 @@ namespace bt
             {
             }
 
-            virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const override
+            virtual void restore_frame(const bt::game_object_frame_restorer& restorer) override
             {
                 game_object_frame frame{};
                 restorer.restore_frame(frame);
@@ -72,7 +72,6 @@ namespace bt
                     )
                 );
                 //phy_body_->SetAngularVelocity(frame.velocity_angle);
-                phy_body_->SetAwake(true);
             }
     public:
         void create_physics_body(const b2Vec2& player_position, const float rotation_rad, const float velocity)
diff --git a/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp b/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
index 628ae40..fdb28e5 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_entity_constants.hpp
@@ -3,6 +3,7 @@
 #include "SFML/System/Vector2.hpp"
 
 
+//TOD::move to config, configuration for tanks types and weapons types/damage
 namespace bt
 {
 	namespace game_entity_consts
@@ -10,10 +11,18 @@ namespace bt
 		static sf::Vector2f tank_size{33.0f, 54.0f};
 		static sf::Vector2f bullet_size{ 6.0f, 24.0f };
 		static float turret_length = 8.0f;//meters
+		static sf::Vector2u game_field_size = sf::Vector2u{ 1024, 768 };
+
+		static sf::Int32 tank_hp = 100;
+		static sf::Int32 bullet_damage = 15;
 	}
 
 	namespace physics_consts
 	{
-		static float pixels_per_meters = 10.0f;
+		static float pixels_per_meters = 10.0f; // 1 meter = 10 pixels
+		static b2Vec2 game_field_size = b2Vec2{ 102.4f, 76.8f };
+
+		static float tank_speed = 50.0f; //meters per second
+		static float bullet_speed = 500.0f; //meters per second
 	}
 }
diff --git a/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp b/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
index 9dc91b9..2fcf7e9 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_map_entity.hpp
@@ -64,7 +64,7 @@ class game_map_entity : public bt::game_object_entity
     }
 
 public:
-    void restore_frame(const bt::game_object_frame_restorer& restorer) const override
+    void restore_frame(const bt::game_object_frame_restorer& restorer) override
     {
     }
 
@@ -72,6 +72,11 @@ class game_map_entity : public bt::game_object_entity
     {
     }
 
+    virtual bool is_out_of_edges(const b2Vec2& size) const override
+    {
+        return false;
+    }
+
 protected:
 
     //TODO:: create map from server configuration
diff --git a/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
index 8bd32c8..21ed278 100644
--- a/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/game_object_entity.hpp
@@ -2,6 +2,7 @@
 
 #include <SFML/Config.hpp>
 
+#include "box2d/b2_math.h"
 #include "game/entity/game_object_type.hpp"
 #include "game/game_objects/game_object_frame_restorer.hpp"
 #include "network/commands.hpp"
@@ -19,8 +20,9 @@ namespace bt
         virtual ~game_object_entity() = default;
 
     public:
-        virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const = 0;
+        virtual void restore_frame(const bt::game_object_frame_restorer& restorer) = 0;
         virtual void update(const float delta_time) = 0;
+        virtual bool is_out_of_edges(const b2Vec2& size) const = 0;
 
     public:
         sf::Uint32 get_id() const
diff --git a/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
index 004616b..8e1d861 100644
--- a/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/phy_game_object_entity.hpp
@@ -28,6 +28,16 @@ namespace bt
     public:
         virtual void create_phy_body() = 0;
 
+        virtual bool is_out_of_edges(const b2Vec2& size) const override
+        {
+            if (phy_body_ == nullptr)
+            {
+                return false;
+            }
+            const auto pos = phy_body_->GetPosition();
+            return pos.x < 0.0f || pos.x > size.x || pos.y < 0.0f || pos.y > size.y;
+        }
+
     protected:
         virtual void fill_frame_data(const std::shared_ptr<game_object_frame>& object_frame) const  override
         {
diff --git a/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp b/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
index a72c4ab..60f20b1 100644
--- a/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
+++ b/battle_tanks/common_logic/headers/game/entity/player_game_object_entity.hpp
@@ -9,6 +9,7 @@
 #include "physics/physics_body_factory.hpp"
 #include "game/player_action_controller.hpp"
 #include "game/game_objects/game_object_frame_restorer.hpp"
+#include "physics/game_object_b2d_link.hpp"
 
 
 namespace bt
@@ -41,9 +42,12 @@ namespace bt
             );
             auto* tank_fixture = phy_body_->CreateFixture(&tank_shape, 1.0f);
 
+            auto* bullet_link = new bt::game_object_b2d_link{ bt::game_object_type::tank, id_ };
+            phy_body_->GetUserData().pointer = reinterpret_cast<uintptr_t>(bullet_link);
+
             b2Filter tank_filter;
             tank_filter.categoryBits = 0x0004;
-            tank_filter.maskBits = 0x8002;
+            tank_filter.maskBits = 0x8007;//4-player, 2-rock, 1-bullet
             tank_fixture->SetFilterData(tank_filter);
 
             action_controller_ = std::make_shared<bt::player_action_controller>(
@@ -58,10 +62,11 @@ namespace bt
             action_controller_->update(dt);
         }
 
-        virtual void restore_frame(const bt::game_object_frame_restorer& restorer) const override
+        virtual void restore_frame(const bt::game_object_frame_restorer& restorer) override
         {
             player_game_object_frame frame{};
             restorer.restore_frame(frame);
+            health_ = frame.health;
 
             phy_body_->SetTransform(
                 b2Vec2(
@@ -70,19 +75,39 @@ namespace bt
                 ),
                 frame.rotation
             );
-            //phy_body_->SetLinearVelocity(
-            //    b2Vec2(
-            //        frame.velocity.x,
-            //        frame.velocity.y
-            //    )
-            //);
-            //phy_body_->SetAngularVelocity(frame.velocity_angle);
-            phy_body_->SetAwake(true);
+
+            if (frame.velocity.x == 0.0f && frame.velocity.y == 0.0f)
+            {
+                phy_body_->SetLinearVelocity(
+                    b2Vec2(
+                        frame.velocity.x,
+                        frame.velocity.y
+                    )
+                );
+            }
+
+            if (frame.velocity_angle == 0.0f)
+            {
+                phy_body_->SetAngularVelocity(frame.velocity_angle);
+            }
 
             action_controller_->set_turret_rotation(frame.turret_rotation);
         }
 
     public:
+        sf::Int32 get_health() const
+        {
+            return health_;
+        }
+
+        void take_damage(const sf::Int32 damage)
+        {
+	        health_ -= damage;
+	        if (health_ < 0)
+	        {
+                health_ = 0;
+	        }
+        }
 
         [[nodiscard]]
         std::weak_ptr<bt::player_action_controller> get_action_controller() const
@@ -102,7 +127,7 @@ namespace bt
         {
             auto go_frame = std::make_unique<player_game_object_frame>();
 
-            go_frame->health = 100;
+            go_frame->health = health_;
             go_frame->player_score = 0;
             go_frame->turret_rotation = action_controller_->get_turret_rotation();
 
@@ -117,9 +142,7 @@ namespace bt
         }
 
     private:
-        //TODO:: move to config
-        float move_speed_ = 100.0f;
-        float rotate_speed_ = 90.0f;
+        sf::Int32 health_{ game_entity_consts::tank_hp };
 
         std::shared_ptr<bt::player_action_controller> action_controller_{ nullptr };
 
diff --git a/battle_tanks/common_logic/headers/network/commands.hpp b/battle_tanks/common_logic/headers/network/commands.hpp
index d7383e8..83f1501 100644
--- a/battle_tanks/common_logic/headers/network/commands.hpp
+++ b/battle_tanks/common_logic/headers/network/commands.hpp
@@ -159,7 +159,7 @@ struct player_game_object_frame : game_object_frame
     virtual ~player_game_object_frame() override = default;
 
     float turret_rotation;
-    sf::Uint32 health;
+    sf::Int32 health;
     sf::Uint32 player_score;
 
     virtual void write_to_packet(sf::Packet& packet) const override
diff --git a/battle_tanks/server/headers/game_session.hpp b/battle_tanks/server/headers/game_session.hpp
index 18a9cf8..b12d783 100644
--- a/battle_tanks/server/headers/game_session.hpp
+++ b/battle_tanks/server/headers/game_session.hpp
@@ -39,7 +39,7 @@ class game_session
     {
         game_objects_ = std::unordered_map<sf::Uint32, std::unique_ptr<bt::game_object_entity>>{};
         physics_world_.SetAllowSleeping(true);
-        //physics_world.SetContinuousPhysics(true);;
+        //physics_world.SetContinuousPhysics(true);
         physics_world_.SetContactListener(&contact_listener_);
 
         contact_listener_.add_collision_handler(
@@ -53,6 +53,17 @@ class game_session
                 {
                     objects_to_delete_.insert(game_object_b.id);
                 }
+
+                //TODO:: check if it is bullet and read damage from bullet, depending on weapon type when shot was made
+                if (game_object_a.type == bt::game_object_type::tank)
+                {
+                    players_took_damage_.emplace(game_object_a.id, bt::game_entity_consts::bullet_damage);
+                }
+                if (game_object_b.type == bt::game_object_type::tank)
+                {
+                    players_took_damage_.emplace(game_object_b.id, bt::game_entity_consts::bullet_damage);
+                }
+
             });
 
         state_ = game_session_state::waiting_for_players;
@@ -206,6 +217,7 @@ class game_session
     std::unordered_map<sf::Uint32, std::weak_ptr<bt::player_action_controller>> players_action_controllers_{};
 
     std::vector<sf::Uint32> players_ids_{};
+    std::unordered_map<sf::Uint32, sf::Int32> players_took_damage_{};
 };
 
 void game_session::update()
@@ -220,8 +232,7 @@ void game_session::update()
             current_count_down_time -= clock.restart().asMilliseconds();
             if (current_count_down_time <= 0)
             {
-                auto size = b2Vec2 { 102.4f, 76.8f };
-                game_map_ = std::make_unique<game_map_entity>(0, size, physics_body_factory_);
+                game_map_ = std::make_unique<game_map_entity>(0, bt::physics_consts::game_field_size, physics_body_factory_);
                 game_map_->build_map();
                 game_map_->create_rock({ 20.0f, 20.0f }, { 5.7f, 4.2f });
 
@@ -271,10 +282,27 @@ void game_session::send_game_session_frame(const float delta_time)
     auto command = std::make_unique<game_frame_command>();
     for (const auto& game_object : game_objects_ | std::views::values)
     {
+        auto game_object_id = game_object->get_id();
+        if (players_took_damage_.contains(game_object_id))
+        {
+	        auto* player_ptr = dynamic_cast<bt::player_game_object_entity*>(game_objects_.at(game_object_id).get());
+            player_ptr->take_damage(players_took_damage_.at(game_object_id));
+            if (player_ptr->get_health() <= 0)
+            {
+	            objects_to_delete_.insert(game_object_id);
+            }
+        }
+        
         game_object->update(delta_time);
+
         command->game_objects.push_back(game_object->get_frame());
+        if (game_object->is_out_of_edges(bt::physics_consts::game_field_size))
+        {
+            objects_to_delete_.insert(game_object->get_id());
+        }
     }
     commands_out_->push_back({ players_ids_, std::move(command) });
+    players_took_damage_.clear();
 }
 
 bool game_session::join_player(sf::Uint32 player_id)
@@ -284,7 +312,6 @@ bool game_session::join_player(sf::Uint32 player_id)
         return false;
     }
 
-
     std::lock_guard lock{ mutex_game_loop_ };
 
     auto player_entity = std::make_unique<bt::player_game_object_entity>(player_id, physics_body_factory_);
@@ -308,7 +335,7 @@ bool game_session::join_player(sf::Uint32 player_id)
     joined_command->player_id = player_id;
     commands_out_->push_back({ players_ids_, std::move(joined_command) });
 
-    if (players_ids_.size() == 1)
+    if (players_ids_.size() == 2)
     {
         state_ = game_session_state::starting;
         thread_game_loop_ = std::thread{ &game_session::update, this };

From 0d51639af58a23d1edd0bb336718c16876de86f0 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Wed, 11 Oct 2023 14:38:12 +0300
Subject: [PATCH 10/13] add game connection states, review fixes

---
 battle_tanks/client/battle_tanks.cpp          | 289 ++--------
 .../client/headers/game/game_session.hpp      |  31 +
 .../game_states/game_connection_states.hpp    | 542 ++++++++++++++++++
 .../network/client_connection.hpp             |   0
 .../network/connection_service.hpp            |   0
 .../common_logic/headers/network/commands.hpp |   2 +-
 .../headers/network/connection_base.hpp       |   2 +-
 .../common_logic/headers/utils/uuid.hpp       |   2 +-
 .../headers/network/server_connection.hpp     |   2 +-
 9 files changed, 617 insertions(+), 253 deletions(-)
 create mode 100644 battle_tanks/client/headers/game/game_session.hpp
 create mode 100644 battle_tanks/client/headers/game/game_states/game_connection_states.hpp
 rename battle_tanks/client/{ => headers}/network/client_connection.hpp (100%)
 rename battle_tanks/client/{ => headers}/network/connection_service.hpp (100%)

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 1a2c50f..099e499 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -5,7 +5,6 @@
 #include "SFML/System/Clock.hpp"
 #include "SFML/Graphics.hpp"
 #include <SFML/Network.hpp>
-#include <box2d/box2d.h>
 
 #include "utils/uuid.hpp"
 #include "game/game_objects/player_game_object.hpp"
@@ -17,16 +16,8 @@
 #include "network/player_actions.hpp"
 #include "game/game_objects/forest_map_game_object.hpp"
 #include "game/game_objects/game_object_frame_restorer_packet.hpp"
+#include "game/game_states/game_connection_states.hpp"
 
-enum class player_game_state : unsigned int
-{
-    unknown = 0,
-    disconnected,
-    connecting,
-    main_lobby,
-    session_lobby,
-    game_session,
-};
 
 void set_text_color(sf::Text& text, const sf::Int32 current_hp)
 {
@@ -46,15 +37,6 @@ void set_text_color(sf::Text& text, const sf::Int32 current_hp)
 
 int main()
 {
-    auto player_state = player_game_state::disconnected;
-
-    auto commands_in = std::make_shared<ts_deque<connection_command_in>>();
-    auto connection_service = std::make_unique<bt::connection_service>(commands_in);
-    connection_service->get_connection().connect({ "localhost" }, 52000);
-
-    player_state = player_game_state::connecting;
-    std::cout << "connecting..." << std::endl;
-
     auto window = std::make_shared<sf::RenderWindow>(
         sf::VideoMode(
             bt::game_entity_consts::game_field_size.x,
@@ -64,17 +46,46 @@ int main()
     );
     //window->setFramerateLimit(60);
 
-    bt::uuid player_id{};
     std::unordered_map<bt::uuid, std::shared_ptr<bt::player_game_object>> players {};
 
     sf::Clock clock;
 
-    std::unique_ptr<bt::sfml_game> game = std::make_unique<bt::sfml_game>(
+    auto game = std::make_unique<bt::sfml_game>(
         window,
         bt::physics_consts::pixels_per_meters
     );
 
-    bt::texture_warehouse texture_warehouse{};
+    auto texture_warehouse = std::make_shared<bt::texture_warehouse>();
+
+    auto game_session = std::make_shared<bt::game_session>();
+
+    bt::connection_state_manager connection_state_manager{
+        game_session,
+        texture_warehouse,
+        game->get_physics_body_factory(),
+        [&game, &players](const std::shared_ptr<bt::player_game_object>& player_game_object)
+        {
+            game->add_game_object(player_game_object);
+            players.emplace(player_game_object->get_id(), player_game_object);
+        },
+        [&game](const std::shared_ptr<bt::game_object>& game_object)
+        {
+            game->add_game_object(game_object);
+        },
+        [&game, &players](const bt::uuid& game_object_id)
+        {
+            game->delete_game_object(game_object_id);
+            if (players.contains(game_object_id))
+            {
+                players.erase(game_object_id);
+            }
+        },
+        [&game](const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)
+        {
+            game->get_game_scene()->get_game_object(game_object_id)->restore_from_frame(restorer_packet);
+        }
+    };
+    connection_state_manager.start();
 
     sf::Font font;
     font.loadFromFile("game_data/fonts/wheaton capitals.otf");
@@ -135,17 +146,18 @@ int main()
         }
     };
 
-    texture_warehouse.pre_load_atlas(map_atlas);
+    texture_warehouse->pre_load_atlas(map_atlas);
 
-    bool tank_fire{ false };
     //TODO:: start move object immediately after key pressed. don't wait server to move 
     player_action tank_move_action{};
     player_action tank_rotate_action{};
     player_action tower_rotate_action{};
+    bool tank_fire{ false };
+    // ///////////////////////////
 
     auto forest_game_map = std::make_shared<bt::forest_map_game_object>(
         0,
-        texture_warehouse.load_pack(bt::textures_pack_id::map_forest),
+        texture_warehouse->load_pack(bt::textures_pack_id::map_forest),
         bt::game_entity_consts::game_field_size,
         game->get_physics_body_factory()
     );
@@ -155,137 +167,12 @@ int main()
     auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
     forest_game_map->create_rock({ 200, 200 }, rock_texture_render_data);
 
-    auto bullet_creation_time = std::chrono::high_resolution_clock::now();
     while (window->isOpen())
     {
         float delta_time = clock.restart().asSeconds();
 
-        sf::Uint32 current_session{};
-
-        //<poll server commands>
-        connection_service->get_connection().update();
-        if (!commands_in->empty())
-        {
-            auto [connection_id, session_id, packet_ref] = commands_in->pop_front();
-            sf::Uint32 command_id;
-            *packet_ref >> command_id;
-
-            auto server_command_id = static_cast<command_id_server>(command_id);
+        connection_state_manager.update(delta_time);
 
-            switch (server_command_id)
-            {
-            case command_id_server::connected_to_game:
-            {
-                if (player_state == player_game_state::connecting)
-                {
-                    player_state = player_game_state::main_lobby;
-                    *packet_ref >> player_id;
-                    std::cout << "connected" << std::endl;
-                }
-                break;
-            }
-            case command_id_server::session_created:
-            {
-                if (player_state == player_game_state::main_lobby)
-                {
-                    player_state = player_game_state::session_lobby;
-                    *packet_ref >> current_session;
-                    std::cout << "session created, id: " << current_session << std::endl;
-
-                    //TODO:: parse session_id and connection_id in connection layer
-                    connection_service->get_connection().set_session_id(current_session);
-                    std::cout << "joining to session... id: " << current_session << std::endl;
-                    connection_service->send(join_session_command{ current_session });
-                }
-                break;
-            }
-            case command_id_server::player_joined_to_session:
-            {
-                if (player_state == player_game_state::session_lobby)
-                {
-                    std::cout << "joined to session, id: " << session_id << std::endl;
-                    //TODO:: add player to game session and display in session lobby connected players
-                }
-                break;
-            }
-            case command_id_server::session_started:
-            {
-                if (player_state == player_game_state::session_lobby)
-                {
-                    player_state = player_game_state::game_session;
-                    std::cout << "game session started, id: " << session_id << std::endl;
-                    *packet_ref >> session_id;
-                    //TODO:: start game world rendering and physics simulation
-                    sf::Uint32 game_objects_count;
-                    *packet_ref >> game_objects_count;
-                    for (sf::Uint32 i = 0; i < game_objects_count; ++i)
-                    {
-                        bt::uuid game_object_id;
-                        *packet_ref >> game_object_id;
-                        bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
-                        auto player = std::make_shared<bt::player_game_object>(game_object_id, texture_warehouse.load_pack(bt::textures_pack_id::tank), game->get_physics_body_factory());
-                        player->initialize();
-                        player->restore_from_frame(restorer_packet);
-                        game->add_game_object(player);
-                        players.emplace(game_object_id, player);
-                    }
-                }
-                break;
-            }
-            case command_id_server::update_game_frame:
-            {
-                if (player_state == player_game_state::game_session)
-                {
-                    sf::Uint32 game_objects_count;
-                    *packet_ref >> game_objects_count;
-                    for (sf::Uint32 i = 0; i < game_objects_count; ++i)
-                    {
-                        bt::uuid game_object_id;
-                        *packet_ref >> game_object_id;
-
-                        bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
-                        game->get_game_scene()->get_game_object(game_object_id)->restore_from_frame(restorer_packet);
-                    }
-                }
-                break;
-            }
-            case command_id_server::player_shoot:
-            {
-                if (player_state == player_game_state::game_session)
-                {
-                    bt::uuid player_id;
-                    *packet_ref >> player_id;
-                    bt::uuid bullet_id;
-                    *packet_ref >> bullet_id;
-                    bt::game_object_frame_restorer_packet restorer_packet{ packet_ref };
-                    auto bullet = std::make_shared<bt::bullet_game_object>(
-                        bullet_id,
-                        game->get_physics_body_factory(),
-                        texture_warehouse.load_texture(bt::texture_id::bullet)
-                    );
-                    bullet->initialize();
-                    bullet->restore_from_frame(restorer_packet);
-                    game->add_game_object(bullet);
-                }
-                break;
-            }
-            case command_id_server::delete_game_object:
-            {
-                if (player_state == player_game_state::game_session)
-                {
-                    bt::uuid game_object_id;
-                    *packet_ref >> game_object_id;
-                    game->delete_game_object(game_object_id);
-
-                    if (players.contains(game_object_id))
-                    {
-                        players.erase(game_object_id);
-                    }
-                }
-                break;
-            }
-            }
-        }
         sf::Event event;
         while (window->pollEvent(event))
         {
@@ -295,110 +182,14 @@ int main()
                 window->close();
             }
 
-            if (player_state == player_game_state::main_lobby)
-            {
-                //TODO:: don't allow to repeat it until server response
-                if (event.type == sf::Event::KeyReleased)
-                {
-                    if (event.key.code == sf::Keyboard::C)
-                    {
-                        std::cout << "creating session... " << std::endl;
-                        connection_service->send(client_command{ command_id_client::create_session });
-                    }
-                    else if (event.key.code == sf::Keyboard::J)
-                    {
-                        std::cout << "joining to session... id: " << 2 << std::endl;
-                        player_state = player_game_state::session_lobby;
-                        connection_service->send(join_session_command{ 2 });
-                    }
-                }
-            }
-
-            if (player_state == player_game_state::game_session)
-            {
-                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W))
-                {
-                    tank_move_action = player_action::move_forward;
-                    connection_service->send(player_action_command{ player_action::move_forward });
-                }
-                else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::S))
-                {
-                    tank_move_action = player_action::move_backward;
-                    connection_service->send(player_action_command{ player_action::move_backward });
-                }
-
-                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A))
-                {
-                    tank_rotate_action = player_action::turn_left;
-                    connection_service->send(player_action_command{ player_action::turn_left });
-                }
-                else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D))
-                {
-                    tank_rotate_action = player_action::turn_right;
-                    connection_service->send(player_action_command{ player_action::turn_right });
-                }
-
-                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left))
-                {
-                    tower_rotate_action = player_action::turn_turret_left;
-                    connection_service->send(player_action_command{ player_action::turn_turret_left });
-                }
-                else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right))
-                {
-                    tower_rotate_action = player_action::turn_turret_right;
-                    connection_service->send(player_action_command{ player_action::turn_turret_right });
-                }
-
-                if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Space))
-                {
-                    tank_fire = true;
-                    connection_service->send(player_action_command{ player_action::turret_fire });
-                }
-
-                if (event.type == sf::Event::KeyReleased)
-                {
-                    if (event.key.code == sf::Keyboard::W || event.key.code == sf::Keyboard::S)
-                    {
-                        tank_move_action = player_action::stop_move;
-                        connection_service->send(player_action_command{ player_action::stop_move });
-                    }
-
-                    if (event.key.code == sf::Keyboard::A || event.key.code == sf::Keyboard::D)
-                    {
-                        tank_rotate_action = player_action::stop_turn;
-                        connection_service->send(player_action_command{ player_action::stop_turn });
-                    }
-
-                    if (event.key.code == sf::Keyboard::Left || event.key.code == sf::Keyboard::Right)
-                    {
-                        tower_rotate_action = player_action::stop_turn_turret;
-                        connection_service->send(player_action_command{ player_action::stop_turn_turret });
-                    }
-
-                    if (event.key.code == sf::Keyboard::Space)
-                    {
-                        tank_fire = false;
-                        connection_service->send(player_action_command{ player_action::turret_stop_fire });
-                    }
-                }
-            }
-        }
-
-        if (tank_fire)
-        {
-            auto bullet_current_time = std::chrono::high_resolution_clock::now();
-
-            if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time).count() >= 1000)
-            {
-                connection_service->send(player_action_command{ player_action::turret_fire });
-            }
+            connection_state_manager.handle_event(event);
         }
 
         game->update(delta_time);
 
         for (const auto& player : players | std::views::values)
         {
-            if (player->get_id() == player_id)
+            if (player->get_id() == game_session->get_player_id())
             {
                 player_hp.setString(std::to_string(player->get_health()));
                 set_text_color(player_hp, player->get_health());
diff --git a/battle_tanks/client/headers/game/game_session.hpp b/battle_tanks/client/headers/game/game_session.hpp
new file mode 100644
index 0000000..746ecd9
--- /dev/null
+++ b/battle_tanks/client/headers/game/game_session.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+
+namespace bt
+{
+    class player_connecting_state;
+
+    class game_session
+    {
+        friend class bt::player_connecting_state;
+    public:
+        game_session() = default;
+
+        ~game_session() = default;
+
+    public:
+        bt::uuid get_player_id() const
+        {
+            return player_id_;
+        }
+
+        sf::Uint32 get_session_id() const
+        {
+            return session_id_;
+        }
+
+    private:
+        bt::uuid player_id_{};
+        sf::Uint32 session_id_{};
+    };
+}
diff --git a/battle_tanks/client/headers/game/game_states/game_connection_states.hpp b/battle_tanks/client/headers/game/game_states/game_connection_states.hpp
new file mode 100644
index 0000000..2843eb4
--- /dev/null
+++ b/battle_tanks/client/headers/game/game_states/game_connection_states.hpp
@@ -0,0 +1,542 @@
+#pragma once
+
+#include <iostream>
+
+#include "game/game_session.hpp"
+
+
+namespace bt
+{
+    enum class player_connection_state : unsigned int
+    {
+        unknown = 0,
+        disconnected,
+        connecting,
+        main_lobby,
+        session_lobby,
+        game_session,
+    };
+
+    class connection_state
+    {
+    public:
+        explicit connection_state(const player_connection_state connection_state)
+            : connection_state_(connection_state)
+        {
+        }
+
+        virtual ~connection_state() = default;
+
+    public:
+        virtual void start() = 0;
+        virtual player_connection_state handle_event(const sf::Event& event) = 0;
+        virtual player_connection_state process_packet(
+            command_id_server command_id,
+            sf::Uint32 connection_id,
+            sf::Uint32 session_id,
+            const std::shared_ptr<sf::Packet>& packet) = 0;
+
+    public:
+        player_connection_state get_connection_state() const { return connection_state_; }
+
+    private:
+        player_connection_state connection_state_;
+    };
+
+
+    //TODO:: handle lost connection and reconnect to session if exists
+    class player_disconnected_state final : public connection_state
+    {
+    public:
+        player_disconnected_state()
+            : connection_state(player_connection_state::disconnected)
+        {
+        }
+
+        virtual ~player_disconnected_state() override = default;
+
+    public:
+        virtual void start() override
+        {
+        }
+
+        virtual player_connection_state handle_event(const sf::Event& event) override
+        {
+            return get_connection_state();
+        }
+
+        virtual player_connection_state process_packet(
+            const command_id_server command_id,
+            const sf::Uint32 connection_id,
+            const sf::Uint32 session_id,
+            const std::shared_ptr<sf::Packet>& packet) override
+        {
+            return get_connection_state();
+        }
+    };
+
+    class player_connecting_state final : public connection_state
+    {
+    public:
+        explicit player_connecting_state(const std::shared_ptr<game_session>& game_session)
+            : connection_state(player_connection_state::connecting), game_session_{ game_session }
+        {
+        }
+
+        virtual ~player_connecting_state() override = default;
+    public:
+        virtual void start() override
+        {
+            std::cout << "connecting..." << std::endl;
+        }
+
+        virtual player_connection_state handle_event(const sf::Event& event) override
+        {
+            return get_connection_state();
+        }
+
+        virtual player_connection_state process_packet(
+            const command_id_server command_id,
+            const sf::Uint32 connection_id,
+            const sf::Uint32 session_id,
+            const std::shared_ptr<sf::Packet>& packet) override
+        {
+            if (command_id == command_id_server::connection_established)
+            {
+
+                bt::uuid player_id;
+                *packet >> player_id;
+                game_session_->player_id_ = player_id;
+                std::cout << "connected" << std::endl;
+                return player_connection_state::main_lobby;
+            }
+
+            return get_connection_state();
+        }
+
+    private:
+        std::shared_ptr<game_session> game_session_{ nullptr };
+    };
+
+    class main_lobby_state final : public connection_state
+    {
+    public:
+        explicit main_lobby_state(std::shared_ptr<bt::connection_service> connection_service)
+            : connection_state(player_connection_state::main_lobby), connection_service_(std::move(connection_service))
+        {
+        }
+
+        virtual ~main_lobby_state() override = default;
+
+    public:
+        virtual void start() override
+        {
+        }
+
+        virtual player_connection_state handle_event(const sf::Event& event) override
+        {
+            //TODO:: don't allow to repeat it until server response
+            if (event.type == sf::Event::KeyReleased)
+            {
+                if (event.key.code == sf::Keyboard::C)
+                {
+                    std::cout << "creating session... " << std::endl;
+                    connection_service_->send(client_command{ command_id_client::create_session });
+                }
+                else if (event.key.code == sf::Keyboard::J)
+                {
+                    std::cout << "joining to session... id: " << 2 << std::endl;
+                    connection_service_->send(join_session_command{ 2 });
+
+                    return bt::player_connection_state::session_lobby;
+                }
+            }
+
+            return get_connection_state();
+        }
+
+        virtual player_connection_state process_packet(
+            const command_id_server command_id,
+            const sf::Uint32 connection_id,
+            const sf::Uint32 session_id,
+            const std::shared_ptr<sf::Packet>& packet) override
+        {
+            if (command_id == command_id_server::session_created)
+            {
+                sf::Uint32 current_session;
+                *packet >> current_session;
+                std::cout << "session created, id: " << current_session << std::endl;
+
+                //TODO:: parse session_id and connection_id in connection layer
+                connection_service_->get_connection().set_session_id(current_session);
+                std::cout << "joining to session... id: " << current_session << std::endl;
+                connection_service_->send(join_session_command{ current_session });
+
+                return bt::player_connection_state::session_lobby;
+            }
+
+            return get_connection_state();
+        }
+
+    private:
+        std::shared_ptr<bt::connection_service> connection_service_{ nullptr };
+    };
+
+    class session_lobby_state final : public connection_state
+    {
+    public:
+        session_lobby_state(
+            std::shared_ptr<bt::texture_warehouse> texture_warehouse,
+            std::weak_ptr<bt::physics_body_factory> physics_body_factory,
+            std::function<void(const std::shared_ptr<bt::player_game_object>& player)> player_created_callback
+        )
+            : connection_state(player_connection_state::session_lobby), texture_warehouse_(std::move(texture_warehouse)),
+              physics_body_factory_(std::move(physics_body_factory)),
+              player_created_callback_(std::move(player_created_callback))
+        {
+        }
+
+        virtual ~session_lobby_state() override = default;
+
+    public:
+        virtual void start() override
+        {
+        }
+
+        virtual player_connection_state handle_event(const sf::Event& event) override
+        {
+            return get_connection_state();
+        }
+
+        virtual player_connection_state process_packet(
+            const command_id_server command_id,
+            const sf::Uint32 connection_id,
+            const sf::Uint32 session_id,
+            const std::shared_ptr<sf::Packet>& packet) override
+        {
+            if (command_id == command_id_server::player_joined_to_session)
+            {
+                std::cout << "joined to session, id: " << session_id << std::endl;
+                //TODO:: add player to game session and display in session lobby connected players
+            }
+            else if (command_id == command_id_server::session_started)
+            {
+                sf::Uint32 started_session_id;
+                *packet >> started_session_id;
+                std::cout << "game session started, id: " << session_id << std::endl;
+                //TODO:: start game world rendering and physics simulation
+                sf::Uint32 game_objects_count;
+                *packet >> game_objects_count;
+                for (sf::Uint32 i = 0; i < game_objects_count; ++i)
+                {
+                    bt::uuid game_object_id;
+                    *packet >> game_object_id;
+                    bt::game_object_frame_restorer_packet restorer_packet{ packet };
+                    auto player = std::make_shared<bt::player_game_object>(
+                        game_object_id,
+                        texture_warehouse_->load_pack(bt::textures_pack_id::tank),
+                        physics_body_factory_
+                    );
+                    player->initialize();
+                    player->restore_from_frame(restorer_packet);
+                    player_created_callback_(player);
+                }
+
+                return bt::player_connection_state::game_session;
+            }
+            return get_connection_state();
+        }
+
+    private:
+        std::shared_ptr<bt::texture_warehouse> texture_warehouse_;
+        std::weak_ptr<bt::physics_body_factory> physics_body_factory_;
+        std::function<void(const std::shared_ptr<bt::player_game_object>& player)> player_created_callback_;
+    };
+
+    class game_session_state final : public connection_state
+    {
+    public:
+        game_session_state(
+            std::shared_ptr<bt::connection_service> connection_service,
+            std::shared_ptr<bt::texture_warehouse> texture_warehouse,
+            std::weak_ptr<bt::physics_body_factory> physics_body_factory,
+            std::function<void(const std::shared_ptr<bt::game_object>& game_object)> game_object_created_callback,
+            std::function<void(const bt::uuid game_object_id)> game_object_deleted_callback,
+            std::function<void(const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)> restore_game_object_callback
+        )
+            : connection_state(player_connection_state::game_session),
+              physics_body_factory_(std::move(physics_body_factory)), texture_warehouse_(std::move(texture_warehouse)),
+              game_object_created_callback_(std::move(game_object_created_callback)),
+              game_object_deleted_callback_(std::move(game_object_deleted_callback)),
+              restore_game_object_callback_(std::move(restore_game_object_callback)),
+              connection_service_(std::move(connection_service))
+        {
+        }
+        virtual ~game_session_state() override = default;
+
+    public:
+        virtual void start() override
+        {
+            bullet_creation_time_ = std::chrono::high_resolution_clock::now();
+        }
+
+        virtual player_connection_state handle_event(const sf::Event& event) override
+        {
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W))
+            {
+                connection_service_->send(player_action_command{ player_action::move_forward });
+            }
+            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::S))
+            {
+                connection_service_->send(player_action_command{ player_action::move_backward });
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::A))
+            {
+                connection_service_->send(player_action_command{ player_action::turn_left });
+            }
+            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::D))
+            {
+                connection_service_->send(player_action_command{ player_action::turn_right });
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Left))
+            {
+                connection_service_->send(player_action_command{ player_action::turn_turret_left });
+            }
+            else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Right))
+            {
+                connection_service_->send(player_action_command{ player_action::turn_turret_right });
+            }
+
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Space))
+            {
+                const auto bullet_current_time = std::chrono::high_resolution_clock::now();
+                if (std::chrono::duration_cast<std::chrono::milliseconds>(bullet_current_time - bullet_creation_time_).count() >= 1000)
+                {
+                    bullet_creation_time_ = bullet_current_time;
+                    connection_service_->send(player_action_command{ player_action::turret_fire });
+                }
+            }
+
+            if (event.type == sf::Event::KeyReleased)
+            {
+                if (event.key.code == sf::Keyboard::W || event.key.code == sf::Keyboard::S)
+                {
+                    connection_service_->send(player_action_command{ player_action::stop_move });
+                }
+
+                if (event.key.code == sf::Keyboard::A || event.key.code == sf::Keyboard::D)
+                {
+                    connection_service_->send(player_action_command{ player_action::stop_turn });
+                }
+
+                if (event.key.code == sf::Keyboard::Left || event.key.code == sf::Keyboard::Right)
+                {
+                    connection_service_->send(player_action_command{ player_action::stop_turn_turret });
+                }
+
+                if (event.key.code == sf::Keyboard::Space)
+                {
+                    connection_service_->send(player_action_command{ player_action::turret_stop_fire });
+                }
+            }
+
+            return get_connection_state();
+        }
+
+        virtual player_connection_state process_packet(
+            const command_id_server command_id,
+            const sf::Uint32 connection_id,
+            const sf::Uint32 session_id,
+            const std::shared_ptr<sf::Packet>& packet) override
+        {
+            if (command_id == command_id_server::update_game_frame)
+            {
+                sf::Uint32 game_objects_count;
+                *packet >> game_objects_count;
+                for (sf::Uint32 i = 0; i < game_objects_count; ++i)
+                {
+                    bt::uuid game_object_id;
+                    *packet >> game_object_id;
+
+                    bt::game_object_frame_restorer_packet restorer_packet{ packet };
+                    restore_game_object_callback_(game_object_id, restorer_packet);
+                }
+            }
+            else if (command_id == command_id_server::player_shoot)
+            {
+                bt::uuid player_id;
+                *packet >> player_id;
+                bt::uuid bullet_id;
+                *packet >> bullet_id;
+                const bt::game_object_frame_restorer_packet restorer_packet{ packet };
+                const auto bullet = std::make_shared<bt::bullet_game_object>(
+                    bullet_id,
+                    physics_body_factory_,
+                    texture_warehouse_->load_texture(bt::texture_id::bullet)
+                );
+                bullet->initialize();
+                bullet->restore_from_frame(restorer_packet);
+                game_object_created_callback_(bullet);
+                
+            }
+            else if (command_id == command_id_server::delete_game_object)
+            {
+                bt::uuid game_object_id;
+                *packet >> game_object_id;
+                game_object_deleted_callback_(game_object_id);
+            }
+
+            return get_connection_state();
+        }
+
+    private:
+        std::weak_ptr<bt::physics_body_factory> physics_body_factory_;
+        std::shared_ptr<bt::texture_warehouse> texture_warehouse_;
+        std::function<void(const std::shared_ptr<bt::game_object>& game_object)> game_object_created_callback_;
+        std::function<void(const bt::uuid game_object_id)> game_object_deleted_callback_;
+        std::function<void(const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)> restore_game_object_callback_;
+        std::shared_ptr<bt::connection_service> connection_service_;
+
+        std::chrono::time_point<std::chrono::steady_clock> bullet_creation_time_{};
+    };
+
+    class connection_state_manager
+    {
+    public:
+        explicit connection_state_manager(
+            std::shared_ptr<game_session> game_session,
+            std::shared_ptr<bt::texture_warehouse> texture_warehouse,
+            std::weak_ptr<bt::physics_body_factory> physics_body_factory,
+            std::function<void(const std::shared_ptr<bt::player_game_object>& player)> player_created_callback,
+            std::function<void(const std::shared_ptr<bt::game_object>& game_object)> game_object_created_callback,
+            std::function<void(const bt::uuid game_object_id)> game_object_deleted_callback,
+            std::function<void(const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)> restore_game_object_callback
+        )
+        //TODO:: add signals or events library to substitute callbacks
+            : game_session_(std::move(game_session)), texture_warehouse_(std::move(texture_warehouse)),
+              physics_body_factory_(std::move(physics_body_factory)),
+              player_created_callback_(std::move(player_created_callback)),
+              game_object_created_callback_(std::move(game_object_created_callback)),
+              game_object_deleted_callback_(std::move(game_object_deleted_callback)),
+              restore_game_object_callback_(std::move(restore_game_object_callback))
+        {
+        }
+
+        ~connection_state_manager() = default;
+
+    public:
+        player_connection_state get_connection_state() const
+        {
+            if (current_state_ == nullptr)
+            {
+                return player_connection_state::unknown;
+            }
+
+            return current_state_->get_connection_state();
+        }
+
+        void start()
+        {
+            if (current_state_ != nullptr)
+            {
+                return;
+            }
+            commands_in_ = std::make_shared<ts_deque<connection_command_in>>();
+            connection_service_ = std::make_unique<bt::connection_service>(commands_in_);
+
+            current_state_ = std::make_unique<player_connecting_state>(game_session_);
+            current_state_->start();
+            connection_service_->get_connection().connect({ "localhost" }, 52000);
+        }
+
+        void update(const float delta_time)
+        {
+            if (current_state_ == nullptr)
+            {
+                return;
+            }
+
+            connection_service_->get_connection().update();
+
+            if (commands_in_->empty())
+            {
+                return;
+            }
+
+            auto [connection_id, session_id, packet_ref] = commands_in_->pop_front();
+            sf::Uint32 command_id;
+            *packet_ref >> command_id;
+
+            const auto server_command_id = static_cast<command_id_server>(command_id);
+
+            const auto state = current_state_->process_packet(server_command_id, connection_id, session_id, packet_ref);
+            change_state(state);
+        }
+
+        void handle_event(const sf::Event& event)
+        {
+	        const auto state = current_state_->handle_event(event);
+            change_state(state);
+        }
+
+    private:
+        void change_state(const player_connection_state new_state)
+        {
+            if (new_state == current_state_->get_connection_state())
+            {
+                return;
+            }
+            //TODO:: move to factory or DI
+            switch (new_state)
+            {
+            case player_connection_state::disconnected:
+                current_state_ = std::make_unique<player_disconnected_state>();
+                break;
+            case player_connection_state::connecting:
+                current_state_ = std::make_unique<player_connecting_state>(game_session_);
+                break;
+            case player_connection_state::main_lobby:
+                current_state_ = std::make_unique<main_lobby_state>(connection_service_);
+                break;
+            case player_connection_state::session_lobby:
+                current_state_ = std::make_unique<session_lobby_state>(
+                    texture_warehouse_,
+                    physics_body_factory_,
+                    player_created_callback_
+                );
+                break;
+            case player_connection_state::game_session:
+                current_state_ = std::make_unique<game_session_state>(
+                    connection_service_,
+                    texture_warehouse_,
+                    physics_body_factory_,
+                    game_object_created_callback_,
+                    game_object_deleted_callback_,
+                    restore_game_object_callback_
+                );
+                break;
+            case player_connection_state::unknown:
+                //TODO:: handle state switch error
+                break;
+            }
+
+            current_state_->start();
+        }
+
+    private:
+        std::unique_ptr<connection_state> current_state_{ nullptr };
+
+        std::shared_ptr<ts_deque<connection_command_in>> commands_in_{ nullptr };
+        std::shared_ptr<bt::connection_service> connection_service_{ nullptr };
+
+        std::shared_ptr<game_session> game_session_{ nullptr };
+        std::shared_ptr<bt::texture_warehouse> texture_warehouse_;
+        std::weak_ptr<bt::physics_body_factory> physics_body_factory_;
+        std::function<void(const std::shared_ptr<bt::player_game_object>& player)> player_created_callback_;
+        std::function<void(const std::shared_ptr<bt::game_object>& game_object)> game_object_created_callback_;
+        std::function<void(const bt::uuid game_object_id)> game_object_deleted_callback_;
+        std::function<void(const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)> restore_game_object_callback_;
+    };
+}
diff --git a/battle_tanks/client/network/client_connection.hpp b/battle_tanks/client/headers/network/client_connection.hpp
similarity index 100%
rename from battle_tanks/client/network/client_connection.hpp
rename to battle_tanks/client/headers/network/client_connection.hpp
diff --git a/battle_tanks/client/network/connection_service.hpp b/battle_tanks/client/headers/network/connection_service.hpp
similarity index 100%
rename from battle_tanks/client/network/connection_service.hpp
rename to battle_tanks/client/headers/network/connection_service.hpp
diff --git a/battle_tanks/common_logic/headers/network/commands.hpp b/battle_tanks/common_logic/headers/network/commands.hpp
index 83f1501..fc494ca 100644
--- a/battle_tanks/common_logic/headers/network/commands.hpp
+++ b/battle_tanks/common_logic/headers/network/commands.hpp
@@ -25,7 +25,7 @@ enum class command_id_server : sf::Uint32
 {
     unknown = 0,
 
-    connected_to_game = 10001,
+    connection_established = 10001,
 
     session_created = 10002,
     player_joined_to_session = 10003,
diff --git a/battle_tanks/common_logic/headers/network/connection_base.hpp b/battle_tanks/common_logic/headers/network/connection_base.hpp
index 2600617..aaed8eb 100644
--- a/battle_tanks/common_logic/headers/network/connection_base.hpp
+++ b/battle_tanks/common_logic/headers/network/connection_base.hpp
@@ -53,7 +53,7 @@ sf::Uint32 connection_base::get_connection_id() const
 //{
 //    connection_id_ = id;
 //    sf::Packet packet{};
-//    constexpr auto command_id = static_cast<sf::Uint32>(command_id_server::connected_to_game);
+//    constexpr auto command_id = static_cast<sf::Uint32>(command_id_server::connection_established);
 //    packet << command_id << connection_id_;
 //    send(packet);
 //}
diff --git a/battle_tanks/common_logic/headers/utils/uuid.hpp b/battle_tanks/common_logic/headers/utils/uuid.hpp
index 7f3149f..c6b0764 100644
--- a/battle_tanks/common_logic/headers/utils/uuid.hpp
+++ b/battle_tanks/common_logic/headers/utils/uuid.hpp
@@ -3,7 +3,7 @@
 
 namespace bt
 {
-    typedef std::uint32_t uuid;
+    using uuid = std::uint32_t;
 
     uuid generate_uuid();
 
diff --git a/battle_tanks/server/headers/network/server_connection.hpp b/battle_tanks/server/headers/network/server_connection.hpp
index f8f7e31..df6c7c2 100644
--- a/battle_tanks/server/headers/network/server_connection.hpp
+++ b/battle_tanks/server/headers/network/server_connection.hpp
@@ -22,7 +22,7 @@ void server_connection::connect(const sf::Uint32 id)
 {
     connection_id_ = id;
     sf::Packet packet{};
-    constexpr auto command_id = static_cast<sf::Uint32>(command_id_server::connected_to_game);
+    constexpr auto command_id = static_cast<sf::Uint32>(command_id_server::connection_established);
     packet << command_id << connection_id_;
     send(packet);
 }

From 0a88ac3a55ac4fea32796b54b94549836f1904be Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Wed, 11 Oct 2023 19:59:04 +0300
Subject: [PATCH 11/13] create game scene for in game state ui

---
 battle_tanks/client/battle_tanks.cpp          | 169 +-----------------
 .../game_states/game_connection_states.hpp    |  11 +-
 .../client/headers/game/sfml_game.hpp         | 134 ++++++++++++--
 .../client/headers/renderer/render_scene.hpp  |   2 +-
 .../client/headers/renderer/textures.hpp      |   6 +-
 .../client/headers/ui/game_screen.hpp         | 104 +++++++++++
 6 files changed, 243 insertions(+), 183 deletions(-)
 create mode 100644 battle_tanks/client/headers/ui/game_screen.hpp

diff --git a/battle_tanks/client/battle_tanks.cpp b/battle_tanks/client/battle_tanks.cpp
index 099e499..701595a 100644
--- a/battle_tanks/client/battle_tanks.cpp
+++ b/battle_tanks/client/battle_tanks.cpp
@@ -4,37 +4,12 @@
 
 #include "SFML/System/Clock.hpp"
 #include "SFML/Graphics.hpp"
-#include <SFML/Network.hpp>
 
-#include "utils/uuid.hpp"
 #include "game/game_objects/player_game_object.hpp"
 #include "game/sfml_game.hpp"
-#include "game/game_objects/bullet_game_object.hpp"
-#include "physics/collision_listener.hpp"
-#include "network/client_connection.hpp"
-#include "network/connection_service.hpp"
 #include "network/player_actions.hpp"
-#include "game/game_objects/forest_map_game_object.hpp"
-#include "game/game_objects/game_object_frame_restorer_packet.hpp"
-#include "game/game_states/game_connection_states.hpp"
 
 
-void set_text_color(sf::Text& text, const sf::Int32 current_hp)
-{
-    if (current_hp > 50)
-    {
-        text.setFillColor(sf::Color::Green);
-    }
-    else if (current_hp > 25)
-    {
-        text.setFillColor(sf::Color::Yellow);
-    }
-    else
-    {
-        text.setFillColor(sf::Color::Red);
-    }
-}
-
 int main()
 {
     auto window = std::make_shared<sf::RenderWindow>(
@@ -46,133 +21,16 @@ int main()
     );
     //window->setFramerateLimit(60);
 
-    std::unordered_map<bt::uuid, std::shared_ptr<bt::player_game_object>> players {};
-
     sf::Clock clock;
 
-    auto game = std::make_unique<bt::sfml_game>(
+    const auto game = std::make_unique<bt::sfml_game>(
         window,
         bt::physics_consts::pixels_per_meters
     );
 
-    auto texture_warehouse = std::make_shared<bt::texture_warehouse>();
-
-    auto game_session = std::make_shared<bt::game_session>();
-
-    bt::connection_state_manager connection_state_manager{
-        game_session,
-        texture_warehouse,
-        game->get_physics_body_factory(),
-        [&game, &players](const std::shared_ptr<bt::player_game_object>& player_game_object)
-        {
-            game->add_game_object(player_game_object);
-            players.emplace(player_game_object->get_id(), player_game_object);
-        },
-        [&game](const std::shared_ptr<bt::game_object>& game_object)
-        {
-            game->add_game_object(game_object);
-        },
-        [&game, &players](const bt::uuid& game_object_id)
-        {
-            game->delete_game_object(game_object_id);
-            if (players.contains(game_object_id))
-            {
-                players.erase(game_object_id);
-            }
-        },
-        [&game](const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)
-        {
-            game->get_game_scene()->get_game_object(game_object_id)->restore_from_frame(restorer_packet);
-        }
-    };
-    connection_state_manager.start();
-
-    sf::Font font;
-    font.loadFromFile("game_data/fonts/wheaton capitals.otf");
-    sf::Text player_hp;
-    player_hp.setPosition(10, 10);
-    player_hp.setFont(font);
-    player_hp.setString("100");
-    player_hp.setCharacterSize(24);
-    player_hp.setFillColor(sf::Color::Green);
-    player_hp.setStyle(sf::Text::Bold);
-
-    sf::Text enemy_hp;
-    enemy_hp.setFont(font);
-    enemy_hp.setString("100");
-    enemy_hp.setCharacterSize(24);
-    enemy_hp.setFillColor(sf::Color::Green);
-    enemy_hp.setStyle(sf::Text::Bold);
-
-    auto map_atlas = bt::atlas_data{
-        bt::atlas_id::map_forest_tile_set,
-        "game_data/atlases/map_forest_tileset.png",
-        {
-            { bt::texture_id::grass_light_tl, sf::IntRect{1,1,16,16} },
-            { bt::texture_id::grass_light_tm, sf::IntRect{18,1,16,16} },
-            { bt::texture_id::grass_light_tr, sf::IntRect{35,1,16,16} },
-
-            { bt::texture_id::grass_light_lm, sf::IntRect{1,18,16,16} },
-            { bt::texture_id::grass_light_m, sf::IntRect{18,18,16,16} },
-            { bt::texture_id::grass_light_rm, sf::IntRect{35,18,16,16} },
-
-            { bt::texture_id::grass_light_bl, sf::IntRect{1,35,16,16} },
-            { bt::texture_id::grass_light_bm, sf::IntRect{18,35,16,16} },
-            { bt::texture_id::grass_light_br, sf::IntRect{35,35,16,16} },
-
-            { bt::texture_id::grass_light_dec_1, sf::IntRect{52,1,16,16} },
-            { bt::texture_id::grass_light_dec_2, sf::IntRect{69,1,16,16} },
-            { bt::texture_id::grass_light_dec_3, sf::IntRect{86,1,16,16} },
-
-            { bt::texture_id::grass_light_dec_4, sf::IntRect{52,18,16,16} },
-            { bt::texture_id::grass_light_dec_5, sf::IntRect{69,18,16,16} },
-            { bt::texture_id::grass_light_dec_6, sf::IntRect{86,18,16,16} },
-
-            { bt::texture_id::grass_light_dec_7, sf::IntRect{52,35,16,16} },
-            { bt::texture_id::grass_light_dec_8, sf::IntRect{69,35,16,16} },
-            { bt::texture_id::grass_light_dec_9, sf::IntRect{86,35,16,16} },
-
-            { bt::texture_id::grass_dark_tl, sf::IntRect{1,52,16,16} },
-            { bt::texture_id::grass_dark_tm, sf::IntRect{18,52,16,16} },
-            { bt::texture_id::grass_dark_tr, sf::IntRect{35,52,16,16} },
-
-            { bt::texture_id::grass_dark_lm, sf::IntRect{1,69,16,16} },
-            { bt::texture_id::grass_dark_m, sf::IntRect{18,69,16,16} },
-            { bt::texture_id::grass_dark_rm, sf::IntRect{35,69,16,16} },
-
-            { bt::texture_id::grass_dark_bl, sf::IntRect{1,86,16,16} },
-            { bt::texture_id::grass_dark_bm, sf::IntRect{18,86,16,16} },
-            { bt::texture_id::grass_dark_br, sf::IntRect{35,86,16,16} },
-        }
-    };
-
-    texture_warehouse->pre_load_atlas(map_atlas);
-
-    //TODO:: start move object immediately after key pressed. don't wait server to move 
-    player_action tank_move_action{};
-    player_action tank_rotate_action{};
-    player_action tower_rotate_action{};
-    bool tank_fire{ false };
-    // ///////////////////////////
-
-    auto forest_game_map = std::make_shared<bt::forest_map_game_object>(
-        0,
-        texture_warehouse->load_pack(bt::textures_pack_id::map_forest),
-        bt::game_entity_consts::game_field_size,
-        game->get_physics_body_factory()
-    );
-    forest_game_map->initialize();
-    game->add_game_object(forest_game_map);
-
-    auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
-    forest_game_map->create_rock({ 200, 200 }, rock_texture_render_data);
-
     while (window->isOpen())
     {
-        float delta_time = clock.restart().asSeconds();
-
-        connection_state_manager.update(delta_time);
-
+        const float delta_time = clock.restart().asSeconds();
         sf::Event event;
         while (window->pollEvent(event))
         {
@@ -181,31 +39,10 @@ int main()
             {
                 window->close();
             }
-
-            connection_state_manager.handle_event(event);
+            game->handle_event(event);
         }
 
         game->update(delta_time);
-
-        for (const auto& player : players | std::views::values)
-        {
-            if (player->get_id() == game_session->get_player_id())
-            {
-                player_hp.setString(std::to_string(player->get_health()));
-                set_text_color(player_hp, player->get_health());
-            }
-            else
-            {
-                enemy_hp.setString(std::to_string(player->get_health()));
-                set_text_color(enemy_hp, player->get_health());
-            }
-        }
-
-        enemy_hp.setPosition(static_cast<float>(bt::game_entity_consts::game_field_size.x) - enemy_hp.getLocalBounds().width - 15, 10);
-        window->draw(player_hp);
-        window->draw(enemy_hp);
-
-        window->display();
     }
 
     return 0;
diff --git a/battle_tanks/client/headers/game/game_states/game_connection_states.hpp b/battle_tanks/client/headers/game/game_states/game_connection_states.hpp
index 2843eb4..4fc222c 100644
--- a/battle_tanks/client/headers/game/game_states/game_connection_states.hpp
+++ b/battle_tanks/client/headers/game/game_states/game_connection_states.hpp
@@ -3,6 +3,8 @@
 #include <iostream>
 
 #include "game/game_session.hpp"
+#include "game/game_objects/bullet_game_object.hpp"
+#include "network/connection_service.hpp"
 
 
 namespace bt
@@ -282,6 +284,13 @@ namespace bt
 
         virtual player_connection_state handle_event(const sf::Event& event) override
         {
+            //TODO:: start move object immediately after key pressed. don't wait server to move 
+            //player_action tank_move_action{};
+            //player_action tank_rotate_action{};
+            //player_action tower_rotate_action{};
+            //bool tank_fire{ false };
+            // ///////////////////////////
+
             if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::W))
             {
                 connection_service_->send(player_action_command{ player_action::move_forward });
@@ -477,7 +486,7 @@ namespace bt
 
         void handle_event(const sf::Event& event)
         {
-	        const auto state = current_state_->handle_event(event);
+            const auto state = current_state_->handle_event(event);
             change_state(state);
         }
 
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index 976b7b5..4b81a55 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -4,11 +4,15 @@
 
 #include "unordered_set"
 #include "dev/debug_draw.hpp"
+#include "game/game_objects/game_object_frame_restorer_packet.hpp"
+#include "game_objects/forest_map_game_object.hpp"
 
 #include "physics/collision_listener.hpp"
 #include "game_objects/game_scene.hpp"
+#include "game_states/game_connection_states.hpp"
 #include "physics/physics_body_factory.hpp"
 #include "renderer/render_scene.hpp"
+#include "ui/game_screen.hpp"
 
 
 namespace bt
@@ -21,6 +25,7 @@ namespace bt
         {
             game_world_ = std::make_unique<bt::game_scene>();
             render_scene_ = std::make_unique<bt::render_scene>(render_target);
+            game_screen_ = std::make_unique<bt::game_screen>(render_target);
             physics_world_.SetAllowSleeping(true);
             //physics_world.SetContinuousPhysics(true);
             contact_listener_ = std::make_unique<bt::collision_listener>();
@@ -41,6 +46,93 @@ namespace bt
                 });
 
             physics_body_factory_ = std::make_shared<physics_body_factory>(&physics_world_);
+
+            texture_warehouse_ = std::make_shared<bt::texture_warehouse>();
+            const auto map_atlas = bt::atlas_data{
+                bt::atlas_id::map_forest_tile_set,
+        "game_data/atlases/map_forest_tileset.png",
+        {
+                    { bt::texture_id::grass_light_tl, sf::IntRect{1,1,16,16} },
+                    { bt::texture_id::grass_light_tm, sf::IntRect{18,1,16,16} },
+                    { bt::texture_id::grass_light_tr, sf::IntRect{35,1,16,16} },
+
+                    { bt::texture_id::grass_light_lm, sf::IntRect{1,18,16,16} },
+                    { bt::texture_id::grass_light_m, sf::IntRect{18,18,16,16} },
+                    { bt::texture_id::grass_light_rm, sf::IntRect{35,18,16,16} },
+
+                    { bt::texture_id::grass_light_bl, sf::IntRect{1,35,16,16} },
+                    { bt::texture_id::grass_light_bm, sf::IntRect{18,35,16,16} },
+                    { bt::texture_id::grass_light_br, sf::IntRect{35,35,16,16} },
+
+                    { bt::texture_id::grass_light_dec_1, sf::IntRect{52,1,16,16} },
+                    { bt::texture_id::grass_light_dec_2, sf::IntRect{69,1,16,16} },
+                    { bt::texture_id::grass_light_dec_3, sf::IntRect{86,1,16,16} },
+
+                    { bt::texture_id::grass_light_dec_4, sf::IntRect{52,18,16,16} },
+                    { bt::texture_id::grass_light_dec_5, sf::IntRect{69,18,16,16} },
+                    { bt::texture_id::grass_light_dec_6, sf::IntRect{86,18,16,16} },
+
+                    { bt::texture_id::grass_light_dec_7, sf::IntRect{52,35,16,16} },
+                    { bt::texture_id::grass_light_dec_8, sf::IntRect{69,35,16,16} },
+                    { bt::texture_id::grass_light_dec_9, sf::IntRect{86,35,16,16} },
+
+                    { bt::texture_id::grass_dark_tl, sf::IntRect{1,52,16,16} },
+                    { bt::texture_id::grass_dark_tm, sf::IntRect{18,52,16,16} },
+                    { bt::texture_id::grass_dark_tr, sf::IntRect{35,52,16,16} },
+
+                    { bt::texture_id::grass_dark_lm, sf::IntRect{1,69,16,16} },
+                    { bt::texture_id::grass_dark_m, sf::IntRect{18,69,16,16} },
+                    { bt::texture_id::grass_dark_rm, sf::IntRect{35,69,16,16} },
+
+                    { bt::texture_id::grass_dark_bl, sf::IntRect{1,86,16,16} },
+                    { bt::texture_id::grass_dark_bm, sf::IntRect{18,86,16,16} },
+                    { bt::texture_id::grass_dark_br, sf::IntRect{35,86,16,16} },
+                }
+            };
+
+            texture_warehouse_->pre_load_atlas(map_atlas);
+
+            const auto forest_game_map = std::make_shared<bt::forest_map_game_object>(
+                0,
+                texture_warehouse_->load_pack(bt::textures_pack_id::map_forest),
+                bt::game_entity_consts::game_field_size,
+                physics_body_factory_
+            );
+            forest_game_map->initialize();
+            add_game_object(forest_game_map);
+
+            const auto rock_texture_render_data = std::make_shared<bt::texture_holder>("game_data/atlases/rock_1.png");
+            forest_game_map->create_rock({ 200, 200 }, rock_texture_render_data);
+
+            game_session_ = std::make_shared<bt::game_session>();
+
+            connection_state_manager_ = std::make_unique<bt::connection_state_manager>(
+                game_session_,
+                texture_warehouse_,
+                physics_body_factory_,
+                [this](const std::shared_ptr<bt::player_game_object>& player_game_object)
+                {
+                    add_game_object(player_game_object);
+                    players_.emplace(player_game_object->get_id(), player_game_object);
+                },
+                [this](const std::shared_ptr<bt::game_object>& game_object)
+                {
+                    add_game_object(game_object);
+                },
+                [this](const bt::uuid& game_object_id)
+                {
+                    delete_game_object(game_object_id);
+                    if (players_.contains(game_object_id))
+                    {
+                        players_.erase(game_object_id);
+                    }
+                },
+                [this](const bt::uuid game_object_id, const bt::game_object_frame_restorer_packet& restorer_packet)
+                {
+                    game_world_->get_game_object(game_object_id)->restore_from_frame(restorer_packet);
+                }
+            );
+            connection_state_manager_->start();
         }
 
         ~sfml_game()
@@ -59,28 +151,38 @@ namespace bt
             objects_to_delete_.insert(game_object_id);
         }
 
-        const std::unique_ptr<bt::game_scene>& get_game_scene() const
-        {
-            return game_world_;
-        }
-
-        std::weak_ptr<bt::physics_body_factory> get_physics_body_factory() const
-        {
-            return physics_body_factory_;
-        }
-
         void update(const float delta_time)
         {
+            for (const auto& player : players_ | std::views::values)
+            {
+                if (player->get_id() == game_session_->get_player_id())
+                {
+                    game_screen_->set_payer_hp(player->get_health());
+                }
+                else
+                {
+                    game_screen_->set_enemy_hp(player->get_health());
+                }
+            }
+
             window_->clear(sf::Color::Black);
 
             delete_game_objects();
 
+            connection_state_manager_->update(delta_time);
+
             physics_world_.Step(delta_time, 8, 3);
             game_world_->update(delta_time);
             render_scene_->draw_scene();
             physics_world_.DebugDraw();
 
-            //window_->display();
+            game_screen_->draw_scene();
+            window_->display();
+        }
+
+        void handle_event(const sf::Event& event) const
+        {
+            connection_state_manager_->handle_event(event);
         }
 
     private:
@@ -101,11 +203,19 @@ namespace bt
         std::unordered_set<bt::uuid> objects_to_delete_{};
         SFMLDebugDraw debug_draw_;
 
+        //TODO:: add more screens and screen management 
+        std::unique_ptr<game_screen> game_screen_;
+
         std::shared_ptr<sf::RenderWindow> window_{ nullptr };
         std::unique_ptr<bt::game_scene> game_world_{ nullptr };
         std::unique_ptr<bt::render_scene> render_scene_{ nullptr };
-        std::shared_ptr<bt::physics_body_factory> physics_body_factory_{ nullptr};
+        std::shared_ptr<bt::physics_body_factory> physics_body_factory_{ nullptr };
         std::unique_ptr<bt::collision_listener> contact_listener_{ nullptr };
+
+        std::shared_ptr<bt::texture_warehouse> texture_warehouse_{ nullptr };
+        std::shared_ptr<bt::game_session> game_session_{ nullptr };
+        std::unordered_map<bt::uuid, std::shared_ptr<bt::player_game_object>> players_{};
+        std::unique_ptr<bt::connection_state_manager> connection_state_manager_{ nullptr };
     };
 
 }
diff --git a/battle_tanks/client/headers/renderer/render_scene.hpp b/battle_tanks/client/headers/renderer/render_scene.hpp
index 9110a49..bf18405 100644
--- a/battle_tanks/client/headers/renderer/render_scene.hpp
+++ b/battle_tanks/client/headers/renderer/render_scene.hpp
@@ -8,7 +8,7 @@
 
 namespace bt
 {
-    class render_scene final : public bt::container
+    class render_scene : public bt::container
     {
     public:
         explicit render_scene(const std::shared_ptr<sf::RenderTarget>& render_target) : render_target_{ render_target }
diff --git a/battle_tanks/client/headers/renderer/textures.hpp b/battle_tanks/client/headers/renderer/textures.hpp
index 8432b1c..3fc9706 100644
--- a/battle_tanks/client/headers/renderer/textures.hpp
+++ b/battle_tanks/client/headers/renderer/textures.hpp
@@ -8,7 +8,7 @@
 
 namespace bt
 {
-    enum class texture_id
+	enum class texture_id
     {
         unknown = 0,
         tank_base = 1,
@@ -165,9 +165,9 @@ namespace bt
         //TODO:: move atlas data to config file and create atlas_data from it
         atlas_data(
             const atlas_id id,
-            const std::string& atlas_path,
+            std::string&& atlas_path,
             const std::unordered_map<texture_id, sf::IntRect>& textures_rect)
-            : id_(id), textures_rect_(textures_rect), atlas_path_(atlas_path)
+            : id_(id), textures_rect_(textures_rect), atlas_path_(std::move(atlas_path))
         {
         }
 
diff --git a/battle_tanks/client/headers/ui/game_screen.hpp b/battle_tanks/client/headers/ui/game_screen.hpp
new file mode 100644
index 0000000..a31b5c9
--- /dev/null
+++ b/battle_tanks/client/headers/ui/game_screen.hpp
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "renderer/container.hpp"
+
+
+namespace bt
+{
+    class player_hp_text final : public bt::render_object
+    {
+    public:
+        explicit player_hp_text(const sf::Font& font)
+        {
+            hp_text_.setFont(font);
+            hp_text_.setCharacterSize(24);
+            hp_text_.setFillColor(sf::Color::Green);
+            hp_text_.setStyle(sf::Text::Bold);
+        }
+
+        virtual ~player_hp_text() override = default;
+
+    public:
+        void set_hit_point(const sf::Int32 hp)
+        {
+            hp_text_.setString(std::to_string(hp));
+            set_text_color(hp_text_, hp);
+        }
+
+        sf::FloatRect get_local_bounds() const
+        {
+            return hp_text_.getLocalBounds();
+        }
+
+    protected:
+        void draw(const std::shared_ptr<sf::RenderTarget>& render_target, const sf::Transform& parent_transform) const override
+        {
+            render_target->draw(hp_text_, parent_transform * getTransform());
+        }
+
+    private:
+        void set_text_color(sf::Text& text, const sf::Int32 current_hp)
+        {
+            if (current_hp > 50)
+            {
+                text.setFillColor(sf::Color::Green);
+            }
+            else if (current_hp > 25)
+            {
+                text.setFillColor(sf::Color::Yellow);
+            }
+            else
+            {
+                text.setFillColor(sf::Color::Red);
+            }
+        }
+
+    private:
+        sf::Text hp_text_{};
+    };
+
+    class game_screen final : public bt::render_scene
+    {
+    public:
+        explicit game_screen(const std::shared_ptr<sf::RenderTarget>& render_target)
+            : render_scene(render_target)
+        {
+            font_.loadFromFile("game_data/fonts/wheaton capitals.otf");
+
+            player_hp_text_ = std::make_shared<bt::player_hp_text>(font_);
+            enemy_hp_text_ = std::make_shared<bt::player_hp_text>(font_);
+
+            set_payer_hp(100);
+            set_enemy_hp(100);
+
+            player_hp_text_->setPosition(10, 10);
+            enemy_hp_text_->setPosition(
+                static_cast<float>(bt::game_entity_consts::game_field_size.x) - enemy_hp_text_->get_local_bounds().width
+                - 15,
+                10
+            );
+
+            add_child(player_hp_text_);
+            add_child(enemy_hp_text_);
+        }
+
+        virtual ~game_screen() override = default;
+
+    public:
+        void set_payer_hp(const sf::Int32 hp) const
+        {
+            player_hp_text_->set_hit_point(hp);
+        }
+
+        void set_enemy_hp(const sf::Int32 hp) const
+        {
+            enemy_hp_text_->set_hit_point(hp);
+        }
+
+    private:
+        std::shared_ptr<bt::player_hp_text> player_hp_text_{ nullptr };
+        std::shared_ptr<bt::player_hp_text> enemy_hp_text_{ nullptr };
+
+        sf::Font font_{};
+    };
+}

From 6840788e240e8719fc3908a117568e94a67ea2e9 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Wed, 11 Oct 2023 23:51:12 +0300
Subject: [PATCH 12/13] add config for atlas and game screen

---
 battle_tanks/client/CMakeLists.txt            |   1 -
 .../game_data/atlases/map_forest_tileset.json | 196 ++++++++++++++++++
 .../game_data/screens/game_screen_config.json |   6 +
 .../client/headers/game/sfml_game.hpp         |  51 +----
 .../client/headers/renderer/textures.hpp      |  51 ++++-
 .../client/headers/ui/game_screen.hpp         |  47 ++++-
 battle_tanks/common_logic/CMakeLists.txt      |   2 +
 battle_tanks/server/CMakeLists.txt            |   3 -
 8 files changed, 293 insertions(+), 64 deletions(-)
 create mode 100644 battle_tanks/client/game_data/atlases/map_forest_tileset.json
 create mode 100644 battle_tanks/client/game_data/screens/game_screen_config.json

diff --git a/battle_tanks/client/CMakeLists.txt b/battle_tanks/client/CMakeLists.txt
index 80fcd3a..2e19140 100644
--- a/battle_tanks/client/CMakeLists.txt
+++ b/battle_tanks/client/CMakeLists.txt
@@ -5,7 +5,6 @@ file(GLOB_RECURSE SOURCES "./*.cpp")
 include_directories(${PROJECT_SOURCE_DIR}/headers)
 
 find_package(SFML COMPONENTS system window graphics CONFIG REQUIRED)
-find_package(box2d CONFIG REQUIRED)
 
 add_executable (${PROJECT_NAME} ${SOURCES})
 
diff --git a/battle_tanks/client/game_data/atlases/map_forest_tileset.json b/battle_tanks/client/game_data/atlases/map_forest_tileset.json
new file mode 100644
index 0000000..9ada74d
--- /dev/null
+++ b/battle_tanks/client/game_data/atlases/map_forest_tileset.json
@@ -0,0 +1,196 @@
+{
+  "id": 1,
+  "name": "forest tileset",
+  "atlas_path": "game_data/atlases/map_forest_tileset.png",
+  "textures": [
+    {
+      "id": 4,
+      "x": 1,
+      "y": 1,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 5,
+      "x": 18,
+      "y": 1,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 6,
+      "x": 35,
+      "y": 1,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 7,
+      "x": 1,
+      "y": 18,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 8,
+      "x": 18,
+      "y": 18,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 9,
+      "x": 35,
+      "y": 18,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 10,
+      "x": 1,
+      "y": 35,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 11,
+      "x": 18,
+      "y": 35,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 12,
+      "x": 35,
+      "y": 35,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 13,
+      "x": 52,
+      "y": 1,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 14,
+      "x": 69,
+      "y": 1,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 15,
+      "x": 86,
+      "y": 1,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 16,
+      "x": 52,
+      "y": 18,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 17,
+      "x": 69,
+      "y": 18,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 18,
+      "x": 86,
+      "y": 18,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 19,
+      "x": 52,
+      "y": 35,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 20,
+      "x": 69,
+      "y": 35,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 21,
+      "x": 86,
+      "y": 35,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 22,
+      "x": 1,
+      "y": 52,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 23,
+      "x": 18,
+      "y": 52,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 24,
+      "x": 35,
+      "y": 52,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 25,
+      "x": 1,
+      "y": 69,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 26,
+      "x": 18,
+      "y": 69,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 27,
+      "x": 35,
+      "y": 69,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 28,
+      "x": 1,
+      "y": 86,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 29,
+      "x": 18,
+      "y": 86,
+      "w": 16,
+      "h": 16
+    },
+    {
+      "id": 30,
+      "x": 35,
+      "y": 86,
+      "w": 16,
+      "h": 16
+    }
+  ]
+}
\ No newline at end of file
diff --git a/battle_tanks/client/game_data/screens/game_screen_config.json b/battle_tanks/client/game_data/screens/game_screen_config.json
new file mode 100644
index 0000000..9452372
--- /dev/null
+++ b/battle_tanks/client/game_data/screens/game_screen_config.json
@@ -0,0 +1,6 @@
+{
+  "hp_text_color_thresholds": {
+    "wounded": 50,
+    "dying": 25
+  }
+}
\ No newline at end of file
diff --git a/battle_tanks/client/headers/game/sfml_game.hpp b/battle_tanks/client/headers/game/sfml_game.hpp
index 4b81a55..10eb193 100644
--- a/battle_tanks/client/headers/game/sfml_game.hpp
+++ b/battle_tanks/client/headers/game/sfml_game.hpp
@@ -33,7 +33,10 @@ namespace bt
             debug_draw_.AppendFlags(b2Draw::e_shapeBit);
             physics_world_.SetDebugDraw(&debug_draw_);
 
-            contact_listener_->add_collision_handler([this](bt::game_object_b2d_link game_object_a, bt::game_object_b2d_link game_object_b)
+            contact_listener_->add_collision_handler([this](
+                const bt::game_object_b2d_link game_object_a,
+                const bt::game_object_b2d_link game_object_b
+                )
                 {
                     if (game_object_a.type == bt::game_object_type::bullet)
                     {
@@ -48,47 +51,7 @@ namespace bt
             physics_body_factory_ = std::make_shared<physics_body_factory>(&physics_world_);
 
             texture_warehouse_ = std::make_shared<bt::texture_warehouse>();
-            const auto map_atlas = bt::atlas_data{
-                bt::atlas_id::map_forest_tile_set,
-        "game_data/atlases/map_forest_tileset.png",
-        {
-                    { bt::texture_id::grass_light_tl, sf::IntRect{1,1,16,16} },
-                    { bt::texture_id::grass_light_tm, sf::IntRect{18,1,16,16} },
-                    { bt::texture_id::grass_light_tr, sf::IntRect{35,1,16,16} },
-
-                    { bt::texture_id::grass_light_lm, sf::IntRect{1,18,16,16} },
-                    { bt::texture_id::grass_light_m, sf::IntRect{18,18,16,16} },
-                    { bt::texture_id::grass_light_rm, sf::IntRect{35,18,16,16} },
-
-                    { bt::texture_id::grass_light_bl, sf::IntRect{1,35,16,16} },
-                    { bt::texture_id::grass_light_bm, sf::IntRect{18,35,16,16} },
-                    { bt::texture_id::grass_light_br, sf::IntRect{35,35,16,16} },
-
-                    { bt::texture_id::grass_light_dec_1, sf::IntRect{52,1,16,16} },
-                    { bt::texture_id::grass_light_dec_2, sf::IntRect{69,1,16,16} },
-                    { bt::texture_id::grass_light_dec_3, sf::IntRect{86,1,16,16} },
-
-                    { bt::texture_id::grass_light_dec_4, sf::IntRect{52,18,16,16} },
-                    { bt::texture_id::grass_light_dec_5, sf::IntRect{69,18,16,16} },
-                    { bt::texture_id::grass_light_dec_6, sf::IntRect{86,18,16,16} },
-
-                    { bt::texture_id::grass_light_dec_7, sf::IntRect{52,35,16,16} },
-                    { bt::texture_id::grass_light_dec_8, sf::IntRect{69,35,16,16} },
-                    { bt::texture_id::grass_light_dec_9, sf::IntRect{86,35,16,16} },
-
-                    { bt::texture_id::grass_dark_tl, sf::IntRect{1,52,16,16} },
-                    { bt::texture_id::grass_dark_tm, sf::IntRect{18,52,16,16} },
-                    { bt::texture_id::grass_dark_tr, sf::IntRect{35,52,16,16} },
-
-                    { bt::texture_id::grass_dark_lm, sf::IntRect{1,69,16,16} },
-                    { bt::texture_id::grass_dark_m, sf::IntRect{18,69,16,16} },
-                    { bt::texture_id::grass_dark_rm, sf::IntRect{35,69,16,16} },
-
-                    { bt::texture_id::grass_dark_bl, sf::IntRect{1,86,16,16} },
-                    { bt::texture_id::grass_dark_bm, sf::IntRect{18,86,16,16} },
-                    { bt::texture_id::grass_dark_br, sf::IntRect{35,86,16,16} },
-                }
-            };
+            const auto map_atlas = bt::atlas_data{ "game_data/atlases/map_forest_tileset.json" };
 
             texture_warehouse_->pre_load_atlas(map_atlas);
 
@@ -135,9 +98,7 @@ namespace bt
             connection_state_manager_->start();
         }
 
-        ~sfml_game()
-        {
-        }
+        ~sfml_game() = default;
 
     public:
         void add_game_object(const std::shared_ptr<bt::game_object>& game_object) const
diff --git a/battle_tanks/client/headers/renderer/textures.hpp b/battle_tanks/client/headers/renderer/textures.hpp
index 3fc9706..74551c4 100644
--- a/battle_tanks/client/headers/renderer/textures.hpp
+++ b/battle_tanks/client/headers/renderer/textures.hpp
@@ -1,14 +1,17 @@
 #pragma once
 
+#include <fstream>
 #include <string>
 #include <memory>
 #include <unordered_map>
 
 #include <SFML/Graphics/Texture.hpp>
+#include <nlohmann/json.hpp>
+
 
 namespace bt
 {
-	enum class texture_id
+    enum class texture_id
     {
         unknown = 0,
         tank_base = 1,
@@ -16,45 +19,51 @@ namespace bt
         bullet = 3,
 
         //atlas 
-        grass_light_m,
         grass_light_tl,
         grass_light_tm,
         grass_light_tr,
+
+        grass_light_lm,
+        grass_light_m,
+        grass_light_rm,
+
         grass_light_bl,
         grass_light_bm,
         grass_light_br,
-        grass_light_lm,
-        grass_light_rm,
 
         grass_light_dec_1,
         grass_light_dec_2,
         grass_light_dec_3,
+
         grass_light_dec_4,
         grass_light_dec_5,
         grass_light_dec_6,
+
         grass_light_dec_7,
         grass_light_dec_8,
         grass_light_dec_9,
 
-        grass_dark_m,
         grass_dark_tl,
         grass_dark_tm,
         grass_dark_tr,
+
+        grass_dark_lm,
+        grass_dark_m,
+        grass_dark_rm,
+
         grass_dark_bl,
         grass_dark_bm,
         grass_dark_br,
-        grass_dark_lm,
-        grass_dark_rm,
     };
 
-    enum class textures_pack_id
+    enum class textures_pack_id : unsigned
     {
         unknown = 0,
         tank,
         map_forest,
     };
 
-    enum class atlas_id
+    enum class atlas_id : unsigned
     {
         unknown = 0,
         map_forest_tile_set,
@@ -124,7 +133,7 @@ namespace bt
         {
             if (loader_ == nullptr)
             {
-	            return;
+                return;
             }
             for (const auto& texture_id : textures_ids_)
             {
@@ -171,6 +180,28 @@ namespace bt
         {
         }
 
+        explicit atlas_data(std::string&& atlas_config_path)
+        {
+            nlohmann::json atlas_config_json;
+            std::ifstream atlas_config_file(atlas_config_path);
+            atlas_config_file >> atlas_config_json;
+
+            id_ = atlas_config_json["id"].get<atlas_id>();
+            atlas_path_ = atlas_config_json["atlas_path"];
+            textures_rect_ = {};
+            for (const auto& texture_data : atlas_config_json["textures"])
+            {
+                textures_rect_.emplace(
+                    texture_data["id"].get<texture_id>(),
+                    sf::IntRect{
+                        texture_data["x"].get<int>(),
+                        texture_data["y"].get<int>(),
+                        texture_data["w"].get<int>(),
+                        texture_data["h"].get<int>() }
+                );
+            }
+        }
+
         ~atlas_data() = default;
 
     public:
diff --git a/battle_tanks/client/headers/ui/game_screen.hpp b/battle_tanks/client/headers/ui/game_screen.hpp
index a31b5c9..2e478b6 100644
--- a/battle_tanks/client/headers/ui/game_screen.hpp
+++ b/battle_tanks/client/headers/ui/game_screen.hpp
@@ -1,14 +1,48 @@
 #pragma once
 
+#include <nlohmann/json.hpp>
+
 #include "renderer/container.hpp"
 
 
 namespace bt
 {
+    class game_screen_config final
+    {
+    public:
+        game_screen_config()
+        {
+            nlohmann::json config_json;
+            std::ifstream config_file("game_data/screens/game_screen_config.json");
+            config_file >> config_json;
+
+            wounded_threshold_ = config_json["hp_text_color_thresholds"]["wounded"].get<unsigned>();
+            dying_threshold_ = config_json["hp_text_color_thresholds"]["dying"].get<unsigned>();
+        }
+
+        ~game_screen_config() = default;
+
+    public:
+        unsigned get_wounded_threshold() const
+        {
+            return wounded_threshold_;
+        }
+
+        unsigned get_dying_threshold() const
+        {
+            return dying_threshold_;
+        }
+
+    private:
+        unsigned wounded_threshold_{};
+        unsigned dying_threshold_{};
+    };
+
     class player_hp_text final : public bt::render_object
     {
     public:
-        explicit player_hp_text(const sf::Font& font)
+        explicit player_hp_text(const sf::Font& font, const unsigned wounded_threshold, const unsigned dying_threshold)
+            : wounded_threshold_(wounded_threshold), dying_threshold_(dying_threshold)
         {
             hp_text_.setFont(font);
             hp_text_.setCharacterSize(24);
@@ -55,6 +89,8 @@ namespace bt
 
     private:
         sf::Text hp_text_{};
+        unsigned wounded_threshold_;
+        unsigned dying_threshold_;
     };
 
     class game_screen final : public bt::render_scene
@@ -64,17 +100,17 @@ namespace bt
             : render_scene(render_target)
         {
             font_.loadFromFile("game_data/fonts/wheaton capitals.otf");
+            config_ = std::make_unique<game_screen_config>();
 
-            player_hp_text_ = std::make_shared<bt::player_hp_text>(font_);
-            enemy_hp_text_ = std::make_shared<bt::player_hp_text>(font_);
+            player_hp_text_ = std::make_shared<bt::player_hp_text>(font_, config_->get_wounded_threshold(), config_->get_dying_threshold());
+            enemy_hp_text_ = std::make_shared<bt::player_hp_text>(font_, config_->get_wounded_threshold(), config_->get_dying_threshold());
 
             set_payer_hp(100);
             set_enemy_hp(100);
 
             player_hp_text_->setPosition(10, 10);
             enemy_hp_text_->setPosition(
-                static_cast<float>(bt::game_entity_consts::game_field_size.x) - enemy_hp_text_->get_local_bounds().width
-                - 15,
+                static_cast<float>(bt::game_entity_consts::game_field_size.x) - enemy_hp_text_->get_local_bounds().width - 15,
                 10
             );
 
@@ -98,6 +134,7 @@ namespace bt
     private:
         std::shared_ptr<bt::player_hp_text> player_hp_text_{ nullptr };
         std::shared_ptr<bt::player_hp_text> enemy_hp_text_{ nullptr };
+        std::unique_ptr<game_screen_config> config_{ nullptr };
 
         sf::Font font_{};
     };
diff --git a/battle_tanks/common_logic/CMakeLists.txt b/battle_tanks/common_logic/CMakeLists.txt
index 3376f06..c82c4d4 100644
--- a/battle_tanks/common_logic/CMakeLists.txt
+++ b/battle_tanks/common_logic/CMakeLists.txt
@@ -8,6 +8,7 @@ file(GLOB_RECURSE SOURCES_CPP "./*.cpp")
 
 find_package(SFML COMPONENTS system CONFIG REQUIRED)
 find_package(box2d CONFIG REQUIRED)
+find_package(nlohmann_json CONFIG REQUIRED)
 
 add_library(${LIB_NAME} STATIC ${SOURCES_CPP})
 
@@ -24,4 +25,5 @@ target_link_libraries(${LIB_NAME}
         sfml-system
         sfml-network
         box2d::box2d
+        nlohmann_json::nlohmann_json
 )
\ No newline at end of file
diff --git a/battle_tanks/server/CMakeLists.txt b/battle_tanks/server/CMakeLists.txt
index fbba9c2..352ea18 100644
--- a/battle_tanks/server/CMakeLists.txt
+++ b/battle_tanks/server/CMakeLists.txt
@@ -4,9 +4,6 @@ file(GLOB_RECURSE SOURCES "./*.cpp")
 
 include_directories(${PROJECT_SOURCE_DIR}/headers)
 
-find_package(SFML COMPONENTS system CONFIG REQUIRED)
-find_package(box2d CONFIG REQUIRED)
-
 add_executable (${PROJECT_NAME} ${SOURCES})
 
 if (CMAKE_VERSION VERSION_GREATER 3.12)

From b43cbe33a814e07306a4e8ec19894b5a50adcf27 Mon Sep 17 00:00:00 2001
From: deliriuminthevoid <deliriuminthevoid@gmail.com>
Date: Sun, 15 Oct 2023 01:27:28 +0300
Subject: [PATCH 13/13] macos debug build

---
 CMakePresets.json                           | 5 ++++-
 battle_tanks/server/headers/game_server.hpp | 1 +
 vcpkg_r_d_cpp_gamedev                       | 2 +-
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/CMakePresets.json b/CMakePresets.json
index be4ee24..47e75f1 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -85,7 +85,10 @@
             "binaryDir": "${sourceDir}/out/build/${presetName}",
             "installDir": "${sourceDir}/out/install/${presetName}",
             "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug"
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_C_COMPILER": "clang",
+                "CMAKE_CXX_COMPILER": "clang++",
+                "CMAKE_TOOLCHAIN_FILE": "vcpkg_r_d_cpp_gamedev/scripts/buildsystems/vcpkg.cmake"
             },
             "condition": {
                 "type": "equals",
diff --git a/battle_tanks/server/headers/game_server.hpp b/battle_tanks/server/headers/game_server.hpp
index c4a2048..255946d 100644
--- a/battle_tanks/server/headers/game_server.hpp
+++ b/battle_tanks/server/headers/game_server.hpp
@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <unordered_map>
+#include <thread>
 
 #include "SFML/Config.hpp"
 #include "SFML/Network/Packet.hpp"
diff --git a/vcpkg_r_d_cpp_gamedev b/vcpkg_r_d_cpp_gamedev
index 26588c0..486a464 160000
--- a/vcpkg_r_d_cpp_gamedev
+++ b/vcpkg_r_d_cpp_gamedev
@@ -1 +1 @@
-Subproject commit 26588c07d59311e9c7959e157faacc00e0c5fb8f
+Subproject commit 486a4640db740f5994e492eb60748111dfc48de7