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

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
    PaintBox1->Canvas->FillRect(PaintBox1->Canvas->ClipRect);
 
        struct Complex // Обьявляем структрура для хранения комплексных чисел
    {
        long double real; // Действительная часть
        long double image; // Мнимая часть
    };
 
    const int iteration = 500; // Обьявляем и инициализируем константу, которая хранит количество итераций
    const int max = 32; // Обьявляем и инициализируем константу, которая хранит максимальное значение,
    // Которое не должно превосходить сумма квадратов действительной и мнимой части комплексного числа
 
    Complex zComplex; // Обьявляем обьекты структуры Complex
    Complex tempComplex; // Которые будут хранить
    Complex cComplex; // Комплексные числа
 
    int valueX; // Координаты по Ох
    int valueY; // Координаты по Оу
    int counter; // Счетчик
 
    int lengthX; // Длина поля по Ох
    int lengthY; // Длина поля по Оу
 
    TColor color; // Цвета для закрашивания пикселей
    TColor secondColor; // Для RGB формата
    TColor thirdColor;
 
    lengthX = PaintBox1->Width / 2; // Считываем половину длины поля по Ох
    lengthY = PaintBox1->Height / 2; // Считываем половину длины поля по Оу
 
    for (valueY = -lengthY; valueY < lengthY; valueY++)
    {
        for (valueX = -lengthX; valueX < lengthX; valueX++)
        {
 
            counter = 0; // Обнуляем счетчик
            zComplex.real = valueX * 0.005; // Инициализируем действительную
            zComplex.image = valueY * 0.005; // И мнимую часть комплексного числа
            cComplex.real = -0.70176; // Инициализируем действительную и
            cComplex.image = -0.3842; // Мнимую часть комплексного числа
 
            // Считаем фрактал Жулиа пока сумма квадратов действительной и мнимой части
            // Комплексного числа меньше констанкты max и пока значение счетчика
            // counter меньше чем число итераций
            while (std::pow(zComplex.real, 2) + std::pow(zComplex.image, 2) < max && counter < iteration)
            {
                tempComplex = zComplex; // Копируем комплексное число во временную структуру
                // Считаем новые значения действительной части комплексного числа
                zComplex.real = std::pow(tempComplex.real, 2) - std::pow(tempComplex.image, 2) + cComplex.real;
                // Считаем новые значения мнимой части комплексного числа
                zComplex.image = 2 * tempComplex.real * tempComplex.image + cComplex.image;
                counter++; // Инкрементируем значение счетчика
            }
 
            // Если значение счетчика меньше, чем число итераций
            if (counter < iteration)
            {
                color = TColor(counter * 6 % 255); // Определяем первый цвет
                secondColor = TColor(counter * 9 % 255); // Определяем второй цвет
                thirdColor = TColor(counter * 11 % 255); // Определяем третий цвет
                // Заполняем пиксель сформируемым цветом
                PaintBox1->Canvas->Pixels[lengthX + valueX*(1+0*cos(M_PI/2))][lengthY + valueY*(1+0*sin(M_PI/2))] = TColor(RGB(color, secondColor, thirdColor));
                         }
        }
    }
}
//---------------------------------------------------------------------------

  // основной цикл
  for (n = 1; n <= n_max * coef; n++)
  {
    // значения радиуса и угла
    double tmp_r = r(c, n), tmp_t = t(n) + eps;
 
    // координаты точки
    x = x0 + tmp_r * cos(tmp_t);
    y = y0 - tmp_r * sin(tmp_t);
 
    // рисуем линии (magic numbers!!!)
    Canvas->Pen->Color = clGreen;
//  int val = r(c, n_max) / 2;
    const int k = 3;
    int u[k] = {n + 55, n + 89, n + 144};
    for (int i = 0; i < k; i++)
      if ((i < k - 1 && n >= 100 || i == k - 1) && u[i] <= n_max * coef)  // && abs(x - x0) <= val && abs(y - y0) <= val)
      {
        Canvas->MoveTo(x0 + r(c, u[i]) * cos(t(u[i]) + eps), y0 - r(c, u[i]) * sin(t(u[i]) + eps));
        Canvas->LineTo(x, y);
      }
 
    int d1 = SE_d1->Text.ToIntDef(D1), d2 = SE_d2->Text.ToIntDef(D2);
    double mult, tmp;  // множитель и радиус кружочков
    Canvas->Pen->Color = clBlack;
    if (n <= n_max)  // && abs(x - x0) <= val / coef && abs(y - y0) <= val / coef)
    {
      mult = tmp_r / r(c, n_max);
      mult *= (mult <= 2. / 3 ? 2. / 3 : 1);
      tmp = d1 - d2 * mult;
      Canvas->Ellipse(x - tmp, y - tmp, x + tmp, y + tmp);  // рисуем кружочки
      //Canvas->TextOutW(x, y, n);
    }
  }

int add1(int a, int b){
  return a + b;
}

struct st{int a, b;};
int add2(struct st){
  return st.a + st.b;
}

с=fn1(st.a, st.b);//вместо st может быть другой тип

            zComplex.real = valueX * 0.00005; // Инициализируем действительную
            zComplex.image = valueY * 0.00005; // И мнимую часть комплексного числа
// 1
            cComplex.real = -0.56267837374; // Инициализируем действительную и
            cComplex.image = 0.65679461735; // Мнимую часть комплексного числа
// 2
//          cComplex.real = -0.743643900055; // Инициализируем действительную и
//          cComplex.image = 0.131825890901; // Мнимую часть комплексного числа
// 3
//          cComplex.real = -0.70176; // Инициализируем действительную и
//          cComplex.image = -0.3842; // Мнимую часть комплексного числа

            zComplex.real = valueX * 0.00001; // Инициализируем действительную
            zComplex.image = valueY * 0.00001; // И мнимую часть комплексного числа
            cComplex.real = -0.56267837374; // Инициализируем действительную и
            cComplex.image = 0.65679461735; // Мнимую часть комплексного числа

struct st { int a, b; };
int add2(st x) {
    return x.a + x.b;
}

struct st { int a, b; };
int add2(st& x) {
    return x.a + x.b;
}

#include <iostream>
 
struct st 
{ 
    int a{}, b{};
    int getSum() { return a + b; }
};
 
int main()
{
    st s{ 3, 4 };
    std::cout << s.getSum() << std::endl;
}

///-----------------------------------------------------------------------------
/// Прототип класса для задачи.
///------------------------------------------------------------------ TaskImage:
struct  TaskImage : myImage
{
 
...
 
private:
    ///--------------------------------------|
    /// 4 дампа с пикселями.                 |
    ///--------------------------------------:
    std::array<Mat2dPixel, 4>         _4Sides;
 
    inline static unsigned width{2};
 
    ///--------------------------------------|
    /// Берём пиксели с пазла и укладываем.  |
    ///--------------------------------------:
    static void init_4Sides(std::array<Mat2dPixel, 4>& _4S,
                            const sf::Image&           img)
    {
        const sf::Vector2u SZ = img.getSize();
 
        ///---------------|
        /// eSIDES::UP    |
        ///---------------:
        {
            Mat2dPixel& mat = _4S[eSIDES::UP];
 
            for    (unsigned y = 0; y < width; ++y)
            {
                mat.emplace_back(std::vector<sf::Color>());
                mat.back().reserve(SZ.x);
 
                for(unsigned x = 0; x < SZ.x ; ++x)
                {   mat.back().emplace_back(img.getPixel(x, y));
                }
            }
        }
 
        ///---------------|
        /// eSIDES::RIGHT |
        ///---------------:
        {
            Mat2dPixel& mat = _4S[eSIDES::RIGHT];
 
            for(unsigned x = SZ.x - 1, i = 0; i < width; --x, ++i)
            {
                mat.emplace_back(std::vector<sf::Color>());
                mat.back().reserve(SZ.y);
 
                for(unsigned y = 0; y < SZ.y ; ++y)
                {   mat.back().emplace_back(img.getPixel(x, y));
                }
            }
        }
 
        ///---------------|
        /// eSIDES::DOWN  |
        ///---------------:
        {
            Mat2dPixel& mat = _4S[eSIDES::DOWN];
 
            for(unsigned y = SZ.y - 1, i = 0; i < width; --y, ++i)
            {
                mat.emplace_back(std::vector<sf::Color>());
                mat.back().reserve(SZ.x);
 
                for(unsigned x = 0; x < SZ.x ; ++x)
                {   mat.back().emplace_back(img.getPixel(x, y));
                }
            }
        }
 
        ///---------------|
        /// eSIDES::LEFT  |
        ///---------------:
        {
            Mat2dPixel& mat = _4S[eSIDES::LEFT];
 
            for(unsigned x = 0; x < width; ++x)
            {
                mat.emplace_back(std::vector<sf::Color>());
                mat.back().reserve(SZ.y);
 
                for(unsigned y = 0; y < SZ.y ; ++y)
                {   mat.back().emplace_back(img.getPixel(x, y));
                }
            }
        }
    }
...

...
 
    static void test_4Sides()
    {   std::cout << "Start::test_4Sides():\n";
 
        sf::Image img;
                  img.create(5, 8);
 
        ln(img.getSize())
 
        ///--------------------------------------|
        /// Заполняем красный в img змейкой.     |
        ///--------------------------------------:
        {
            unsigned char red = 0;
            for(unsigned  x = 0; x < img.getSize().x; ++x)
            {   img.setPixel(x, 0, {red++, 0, 0});
            }
 
            for(unsigned  y = 1; y < img.getSize().y; ++y)
            {   img.setPixel(img.getSize().x - 1, y, {red++, 0, 0});
            }
 
            for(unsigned  x = img.getSize().x - 2; x < img.getSize().x; --x)
            {   img.setPixel(x, img.getSize().y - 1, {red++, 0, 0});
            }
 
            for(unsigned  y = img.getSize().y - 2; y != 0; --y)
            {   img.setPixel( 0, y, {red++, 0, 0});
            }
        }
 
        ///--------------------------------------|
        /// Буфер для пикселей:                  |
        /// 4 матрицы толщиной width.            |
        ///--------------------------------------:
        std::array<Mat2dPixel, 4> _4STest;
 
        ///--------------------------------------|
        /// Кролик тестирования.                 |
        ///--------------------------------------:
        init_4Sides             ( _4STest, img );
 
        unsigned E{eSIDES::UP };
 
        ///--------------------------------------|
        /// Ручная, т.е. глазная верификация.    |
        ///--------------------------------------:
        /// Содержимое img.                      |
        ///--------------------------------------:
        for    (unsigned y = 0; y < img.getSize().y; ++y)
        {       std::cout << "  ";
            for(unsigned x = 0; x < img.getSize().x; ++x)
            {   std::cout << std::setw(3) << (int)img.getPixel(x, y).r;
            }   std::cout << '\n';
        }       std::cout << '\n';
 
        l(width)
 
        ///--------------------------------------|
        /// Содержимое буферов по сторонам img.  |
        ///--------------------------------------:
        for        (const auto& mat   : _4STest)
        {   std::cout << whatSIDE(eSIDES(E++)) << ":\n";
            for    (const auto& line  : mat    )
            {       std::cout << "  ";
                for(const auto& pixel : line   )
                {   std::cout << std::setw(3) << (int)pixel.r;
                }   std::cout << '\n';
            }       std::cout << '\n';
        }           std::cout << '\n';
 
        std::cout << "Finished::test_4Sides():\n";
    }

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

std::string s = "hello";

std::string s{"hello"};