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

#ifndef TASK384_H
#define TASK384_H
/// "task384.h"
///-----------------------------------------------------------------------------
/// ...
///----------------------------------------------------------------------------:
#include <cmath>
#include <iomanip>
 
#include <SFML/Graphics.hpp>
#include "images.h"
 
 
///-----------------------------------------------------------------------------
/// _2Sides.
///-------------------------------------------------------------------- _2Sides:
struct  _2Sides
{       _2Sides(TaskImage const* _a, TaskImage const* _b)
            : a(_a), b(_b)
        {
            do4Similarity();
        }
 
    ///--------------------------------------|
    /// Кто участвует?                       |
    ///--------------------------------------:
    TaskImage const* a;
    TaskImage const* b;
 
    ///--------------------------------------|
    /// Общие оценки для 4 пар сторон.       |
    ///--------------------------------------:
    std::array<int, 4> similarity;
 
    ///--------------------------------------|
    /// Для пары картинок -> 4 пары сторон.  |
    ///--------------------------------------:
    void do4Similarity()
    {   unsigned  cnt{0};
        for(auto& e :   similarity)
        {         e = doSimilarity(cnt++);
        }
    }
 
    using TE = TaskImage::eSIDES;
 
    ///--------------------------------------|
    /// Правила коннекта - "кто с кем?".     |
    ///--------------------------------------:
    inline static    TE  E[4][2]
    {   { TE::UP   , TE::DOWN  },
        { TE::DOWN , TE::UP    },
        { TE::RIGHT, TE::LEFT  },
        { TE::LEFT , TE::RIGHT }
    };
 
    ///--------------------------------------|
    /// Вычисляем оценку по пикселям...      |
    ///--------------------------------------:
    int doSimilarity(const unsigned cnt)
    {
        const Mat2dPixel& matA = a->get(E[cnt][0]);
        const Mat2dPixel& matB = b->get(E[cnt][1]);
 
        int SS{};
 
        for(auto ai  = matA[0].begin(),
                 bi  = matB[0].begin();
                 ai != matA[0].end(); ++ai, ++bi)
        {
            int N1 = int(ai->r) - bi->r; N1 *= N1;
            int N2 = int(ai->b) - bi->b; N2 *= N2;
            int N3 = int(ai->g) - bi->g; N2 *= N2;
 
            SS += N1 + N2 + N3;
        }
 
        return SS;
    }
 
    ///--------------------------------------|
    /// Инфа о том, что происходит...        |
    ///--------------------------------------:
    std::string debug() const
    {
        std::cout << "1. "; l(a->filename)
        std::cout << "2. "; l(b->filename) std::cout << '\n';
 
        unsigned cnt{};
        for(const auto similar : similarity)
        {   std::cout << std::format("[{}, {}]: ",
                                    TaskImage::whatSIDE(E[cnt][0]),
                                    TaskImage::whatSIDE(E[cnt][1])); ++cnt;
                     l(similar);
        }
 
        return "";
    }
};
 
 
///-----------------------------------------------------------------------------
/// Task384.
///-------------------------------------------------------------------- Task384:
struct  Task384 : std::vector<TaskImage const*>
{       Task384(const LoaderImages& imgs)
        {   reserve(imgs.size());
            for(const auto& e : imgs) push_back(&e);
            m.reserve(calcElem(size()));
            go();
        }
 
    ///--------------------------------------|
    /// Все пары, какие только есть ...      |
    ///--------------------------------------:
    void go()
    {
        for    (auto a = cbegin(), END = cend() - 1; a != END   ; ++a)
        {   for(auto b = a + 1;                      b != cend(); ++b)
            {
                m.push_back(_2Sides(*a, *b));
 
                ASSERT((*a)->filename != (*b)->filename)
            }
        }
            ASSERT(calcElem(384) == m.size())
    }
 
private:
    ///--------------------------------------|
    /// Склад для пар сторон.                |
    ///--------------------------------------:
    std::vector<_2Sides> m;
 
    ///--------------------------------------|
    /// Прогноз на кол-во пар.               |
    ///--------------------------------------:
    static unsigned calcElem(unsigned n){ return n * (n - 1) / 2; }
 
    ///--------------------------------------|
    /// Тест разраба.                        |
    ///--------------------------------------:
    TEST
    {
        LoaderImages    images ;
        Task384 task384(images);
/*
        _2Sides _2sides(task384[0], task384[1]);
                _2sides.debug();
*/
        l(calcElem(384) == task384.m.size())
 
        unsigned cnt{};
 
        for(const auto& e : task384.m)
        {
            std::cout << "\n///-------------------------------:"; l(cnt)
            e.debug();
 
            if(++cnt == 4) break;
        }
 
        std::cout << "\n...\n\nВсего таких пар: " << task384.m.size() << '\n';
    }
};
 
#endif // IMAGES_H

void tests()
{
/// myl::testfoo_getVSizeWH();
/// CastomFilesCargo ::test();
/// HeroTest         ::test();
/// TaskImage        ::test();
/// TaskImage ::test_4Sides();
/// LoaderImages     ::test();
/// DrawImage        ::test();
    Task384          ::test();
 
    std::unique_ptr<Render> run(new Render);
}

    ///--------------------------------------|
    /// unsigned ---> max: 4294967296        |
    /// хватит на картинку с сайзом:         |
    /// l(4294967296 / (255 * 255 * 3)) ==   |
    ///                                22017 |
    ///--------------------------------------:
    static unsigned calcMaxSimilar(const unsigned sizePixels)
    {   return 255 * 255 * 3 * sizePixels;
    }

#ifndef GENIMG_H
#define GENIMG_H
/// "gen-img.h"
///-----------------------------------------------------------------------------
/// Генератор простых картинок(для настройки глаза Саурона).
///----------------------------------------------------------------------------:
#include <cmath>
#include <SFML/Graphics.hpp>
 
#include "debug.h"
 
namespace tools
{
    ///------------------------------------------------------------------------|
    /// GenData.
    ///---------------------------------------------------------------- GenData:
    struct GenData
    {
        sf::Color  colorA;
        sf::Color  colorB; /// Not used ...
 
        sf::Vector2u Size{123, 47};
    };
 
 
    ///------------------------------------------------------------------------|
    /// ConfigGI.
    ///--------------------------------------------------------------- ConfigGI:
    struct ConfigGI
    {
        std::vector<GenData> data
        {
            {   { 255, 255, 255 },
                {   0, 255,   0 }
            },
            {   {   0,   0,   0 },
                { 255, 255, 255 }
            },
            {   { 255,   0,   0 },
                {   0, 255,   0 }
            },
            {   { 255, 255, 255 },
                {   0, 255,   0 }
            }
        };
 
        std::string dir{"./genTest/"};
 
        static     const ConfigGI& get()
        {   static const ConfigGI  cfg;
            return                 cfg;
        }
    };
 
 
    ///------------------------------------------------------------------------|
    /// GeneratorImages.
    ///-------------------------------------------------------- GeneratorImages:
    struct  GeneratorImages : std::vector<sf::Image>
    {       GeneratorImages(const ConfigGI& _cfg) : cfg(_cfg)
            {   gen();
                countSave = save2file();
            }
 
        unsigned countSave{};
 
    private:
        const ConfigGI& cfg;
        void  gen()
        {
            reserve(cfg.data.size());
 
            for(const auto& data : cfg.data)
            {   emplace_back (sf::Image());
                back().create(data.Size.x, data.Size.y, data.colorA);
            }
        }
 
        unsigned save2file() const
        {   unsigned   cnt{};
            for(const auto& image : *this)
            {  if(!image.saveToFile(getName(++cnt))) return --cnt;
            }
            return cnt;
        }
 
        std::string getName(const unsigned n) const
        {                    std::string     a{std::to_string(n)};
            return cfg.dir + std::string(4 - a.size(), '0') + a + ".png";
        }
 
        TEST
        {   GeneratorImages generatorImages(ConfigGI::get());
 
            std::cout << "generatorImаges сохранил на диске: "
                      <<  generatorImages.countSave << " png-файлов.\a\n\n"
                      << std::endl;
        }
    };
}
 
#endif // GENIMG_H