Совместное создание игры

...
 
namespace myl
{
    ///--------------------------------------|
    /// Карманный рендер, чтобы увидеть obj. |
    ///--------------------------------------:
    template<class T> void show(const T& obj)
    {
        sf::RenderWindow window(sf::VideoMode(800, 600), "myl::show(obj)");
                         window.setFramerateLimit  (50);
 
        sf::View camW  = window.getView();
                 camW.setCenter({0,0});
                 window.setView(camW);
 
        while (window.isOpen())
        {
            for (sf::Event event; window.pollEvent(event); )
            {   if (event.type == sf::Event::Closed) window.close();
            }
            window.clear  ();
            window.draw(obj);
            window.display();
        }
    }
 
...

///---------------------------------|
/// Это прототип ресурса.           |
///---------------------------------:
struct  HeroTest : sf::RectangleShape
{       HeroTest()
        {   setFillColor   (sf::Color(0,128,0));
            setSize        ({700, 450}        );
            setOutlineColor(sf::Color(222,0,0));
            setOutlineThickness           (5.f);
            setOrigin({getSize().x / 2, getSize().y / 2});
        }
 
    TEST
    {   HeroTest  hero ;
        myl::show(hero);
    }
};

...
 
void tests()
{
/// myl::testfoo_getVSizeWH();
/// CastomFilesCargo ::test();
    HeroTest         ::test();
}
 
 
///----------------------------------------------------------------------------|
/// Start.
///----------------------------------------------------------------------------:
int main ()
{   std::cout << "START ...\n\n";
    tests();
    std::cout << "\nFINISHED PROGRAMM!\n";
}

///-----------------------------------------------------------------------------
/// Класс-расширение для sf::Image.
///-------------------------------------------------------------------- myImage:
struct  myImage : sf::Image
{       myImage(std::string_view _filename) : filename(_filename)
        {   loadFromFile(filename);
        }
 
    std::string filename;
 
    virtual myImage* getThis() { return this; }
 
    ///----------------------------------|
    /// Что уже есть в составе:          |
    /// см. доку на www.sfml-dev.org     |
    ///----------------------------------:
    /// Например,
    sf::Vector2u getSize() const { return sf::Image::getSize(); };
 
    std::string debug() const
    {   return std::format(
            "    filename: \"{}\", Size: [{}, {}]",
            filename,
            getSize().x,
            getSize().y
        );
    }
};

using Mat2dPixel = std::vector<std::vector<sf::Color>>;
 
///-----------------------------------------------------------------------------
/// Прототип класса для задачи.
///------------------------------------------------------------------ TaskImage:
struct  TaskImage : myImage
{       TaskImage(std::string_view filename) : myImage(filename)
        {   init_4Sides();
        }
 
    enum eSIDES
    {    UP   ,
         RIGHT,
         DOWN ,
         LEFT
    };
 
    const Mat2dPixel& get(eSIDES Side) const { return _4Sides[Side]; }
 
private:
    ///--------------------------------------|
    /// 4 дампа с пикселями.                 |
    ///--------------------------------------:
    std::array<Mat2dPixel, 4>         _4Sides;
 
    ///--------------------------------------|
    /// Берём пиксели с пазла и укладываем.  |
    ///--------------------------------------:
    void init_4Sides()
    {
        /// TODO ...
    }
 
    ///--------------------------------------|
    /// Тест разраба.                        |
    ///--------------------------------------:
    TEST
    {   FilesCargo     filesCargo;
        TaskImage task(filesCargo.get(".png").front().string());
               ln(task.debug());
    }
};

void tests()
{
/// myl::testfoo_getVSizeWH();
/// CastomFilesCargo ::test();
/// HeroTest         ::test();
 
///
TaskImage        ::test();
...

///-----------------------------------------------------------------------------
/// Класс-загрузчик всех выбранных картинок на диске в контексте sf::Image.
///--------------------------------------------------------------- LoaderImages:
struct  LoaderImages : std::vector<TaskImage>
{       LoaderImages()
        {
            FilesCargo filesCargo;
            reserve   (filesCargo.get(".png").size());
 
            for(const auto&  filename : filesCargo.get(".png"))
            {   emplace_back (TaskImage(filename.string()));
            }
        }
 
private:
    std::vector<sf::Texture>* getTextures()
    {   static std::vector<sf::Texture> tt;
        if(!tt.empty())         return &tt;
 
        tt.reserve(size());
 
        for(const auto& image : *this)
        {   tt.emplace_back(sf::Texture());
            tt.back().loadFromImage(image);
        }
        return &tt;
    }
 
    friend struct DrawImage;
    ///--------------------------------------|
    /// Тест разраба.                        |
    ///--------------------------------------:
    TEST
    {   LoaderImages loaderImages;
                   l(loaderImages.size())
                   l(loaderImages[0].debug());
                   l(loaderImages[1].debug());
                   l(loaderImages[2].debug());
    }
};

void tests()
{
/// myl::testfoo_getVSizeWH();
/// CastomFilesCargo ::test();
/// HeroTest         ::test();
/// TaskImage        ::test();
///
LoaderImages     ::test();
...

///-----------------------------------------------------------------------------
/// Класс готовит массив sf::Image для визуализации.
///------------------------------------------------------------------ DrawImage:
struct  DrawImage : sf::Drawable
{       DrawImage(LoaderImages& _images) : images(_images)
        {   init(myl::getVSizeWH(images.size()).front());
        }
 
private:
    LoaderImages&       images;
    std::vector<sf::Sprite> sp;
 
    ///--------------------------------------|
    /// Расстановка спрайтов на экране.      |
    ///--------------------------------------:
    void init(const sf::Vector2u& sz)
    {
        if(images.empty()) return;
 
        std::vector<sf::Texture>& tt = *images.getTextures();
 
        sp.reserve(tt.size());
 
        const unsigned& SIDEx  = images.front().getSize().x;
        const unsigned& SIDEy  = images.front().getSize().y;
        const unsigned  SIDE2x = SIDEx / 2;
        const unsigned  SIDE2y = SIDEy / 2;
 
        const sf::Vector2u sza{sz.x * SIDEx / 2 - SIDE2x,
                               sz.y * SIDEy / 2 - SIDE2y};
 
        for    (unsigned y = 0; y < sz.y; ++y)
        {   for(unsigned x = 0; x < sz.x; ++x)
            {
                sp.emplace_back(sf::Sprite());
                sp.back().setOrigin  (SIDE2x, SIDE2y);
                sp.back().setTexture (  tt[sz.x  * y + x]);
                sp.back().setPosition(  float(x) * SIDEx - sza.x,
                                        float(y) * SIDEy - sza.y);
            }
        }
    }
 
    ///--------------------------------------|
    /// На рендер.                           |
    ///--------------------------------------:
    virtual void draw(sf::RenderTarget& target,
                      sf::RenderStates  states) const
    {
        for(const auto& sprite : sp) target.draw(sprite);
    }
 
    ///--------------------------------------|
    /// Тест разраба.                        |
    ///--------------------------------------:
    TEST
    {   LoaderImages        loaderImages ;
        DrawImage drawImage(loaderImages);
        SHOW(drawImage);
    }
};

void tests()
{
/// myl::testfoo_getVSizeWH();
/// CastomFilesCargo ::test();
/// HeroTest         ::test();
/// TaskImage        ::test();
/// LoaderImages     ::test();
///
 DrawImage        ::test();
...