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

        ///------------------------------------|
        /// Клик мыши в индексы массива.       |
        ///------------------------------------:
        sf::Vector2u getMousePos2View()
        {
            ///--------------------------------|
            /// Размер объектива камеры.       |
            ///--------------------------------:
            const sf::Vector2f&  v = ConfigRender::p->getView_ms().getSize();
 
            ///--------------------------------|
            /// Смещение от глобального центра.|
            ///--------------------------------:
            const sf::Vector2f&  p = ConfigRender::p->getView_ms().getCenter();
 
            ///--------------------------------|
            /// Координаты окна.               |
            ///--------------------------------:
            sf::Vector2i mouse_pos = sf::Mouse::getPosition(window);
 
            ///--------------------------------|
            /// Поправка на четность.          |
            ///--------------------------------:
            const sf::Vector2f popr(textrSizeY * (cfg.W%2) / 2,
                                    textrSizeY * (cfg.H%2) / 2);
 
            ///--------------------------------|
            /// По правилу подобия.            |
            ///--------------------------------:
            const int Ax  = mouse_pos.x * v.x / window.getSize().x + p.x;
            const int Ay  = mouse_pos.y * v.y / window.getSize().y + p.y;
 
            ///--------------------------------|
            /// Центрируем.                    |
            ///--------------------------------:
            const int A2x = Ax + popr.x - v.x / 2;
            const int A2y = Ay + popr.y - v.y / 2;
 
            ///--------------------------------|
            /// Получаем индексы.              |
            ///--------------------------------:
            mouse_pos.x   = A2x / textrSizeY;
            mouse_pos.y   = A2y / textrSizeY;
 
            ///--------------------------------|
            /// Возвращаем уничтоженный индекс.|
            ///--------------------------------:
            mouse_pos.x += A2x > 0 ? 1 : 0;
            mouse_pos.y += A2y > 0 ? 1 : 0;
 
            ///--------------------------------|
            /// Приводим к индексам массива.   |
            ///--------------------------------:
            return { (unsigned)(mouse_pos.x + (cfg.W)  / 2 - 1),
                     (unsigned)(mouse_pos.y + (cfg.H)  / 2 - 1) };
        }

const int mult = 1e5;
const double asp = 0.75;
bool w = 0, h = 0;
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCanResize(TObject *Sender, int &NewWidth, int &NewHeight,
          bool &Resize)
{
  Tag = Width * mult + Height;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
{
  w = (Width != Tag / mult);
  h = (Height != Tag % mult);
 
  if (w)
    Height = Width * asp;
  else if (h)
    Width = Height / asp;
}

/// [sources:utf-8]
///----------------------------------------------------------------------------|
/// MSYS GCC 9.2
/// MSVC 2010 [Use Unicode Character Set]
#define  MSVC
///----------------------------------------------------------------------------:
 
 
///--------------------------------|
/// Конфиг.                        |
///--------------------------------:
const wchar_t* filename = L"1p.jpg";
///--------------------------------.
 
 
#include <windows.h>
#include <gdiplus.h>
 
namespace gdi = Gdiplus;
 
#ifdef   MSVC
    #pragma comment(lib, "Gdiplus.lib")
#else
    #define UNICODE
#endif //MSVC
 
 
///----------------------------------------------------------------------------|
/// Gdiplus инициализатор.
///----------------------------------------------------------------------------:
struct  GDIPLUS
{       GDIPLUS(){   gdi::GdiplusStartup (&gdiToken, &gdiInput, NULL); }
       ~GDIPLUS(){   gdi::GdiplusShutdown( gdiToken)                 ; }
 
    ULONG_PTR                gdiToken;
    gdi::GdiplusStartupInput gdiInput;
};
 
 
///----------------------------------------------------------------------------|
/// Получение и хранение основных дескрипторов.
///----------------------------------------------------------------------------:
struct  ConWindow
{       ConWindow()
        {   hdc = GetDC     (GetConsoleWindow());
            set_font_console(                  );
            SetConsoleTitleW(L"Bitmap To Text" );
            system          ( "mode 80, 127"   );
        }
 
    HDC hdc;
 
    ///-------------------|
    /// Font магия...     |
    ///-------------------:
    void set_font_console()
    {   CONSOLE_FONT_INFOEX cfi;
                            cfi.cbSize       = sizeof(cfi);
                            cfi.nFont        =           0;
                            cfi.dwFontSize.X =           5;
                            cfi.dwFontSize.Y =           5;
                            cfi.FontFamily   = FF_DONTCARE;
                            cfi.FontWeight   = FW_NORMAL  ;
 
        wcscpy_s(cfi.FaceName, L"Lucida Console");
        SetCurrentConsoleFontEx(GetStdHandle(STD_OUTPUT_HANDLE), FALSE, &cfi);
    }
 
}WIN;
 
 
///----------------------------------------------------------------------------|
/// Show bitmap.
///----------------------------------------------------------------------------:
struct  ShowImg
{       ShowImg(){ work(); }
 
private:
    void work()
    {   gdi::Graphics g(WIN.hdc );
        gdi::Bitmap   b(filename);
        g.DrawImage( &b, 170, 0, b.GetWidth(), b.GetHeight() );
    }
};
 
 
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
 
std::ostream& operator<<(std::ostream& o, const std::vector<std::string>& m)
{   for(auto i = m.cbegin (), E = m.cend(); i != E; ++i)
             o << i->c_str() << '\n';
             o               << '\n';
    return   o;
}
 
 
///----------------------------------------------------------------------------|
/// Convert bitmap to text.
///----------------------------------------------------------------------------:
struct  Convert
{       Convert(){ work(); }
 
private:
    void work()
    {
        ///---------------------|
        /// Подготовка.         |
        ///---------------------:
        gdi::Bitmap         bitmap  (filename);
        const unsigned& W = bitmap.GetWidth ();
        const unsigned& H = bitmap.GetHeight();
 
        std::vector<std::string> char_pixels(H, std::string(W, ' '));
 
        const std::string PEN(" .,:;ox%#@");
        const unsigned    PEN_INTERVALCHAR = 255 / (PEN.size() - 1);
 
        ///---------------------|
        /// Конверт.            |
        ///---------------------:
        for    (unsigned y = 0; y < H; y++)
        {   for(unsigned x = 0; x < W; x++)
            {
                const unsigned GRAY = greyScaleColor(bitmap, x, y);
                char_pixels[y][x]   = PEN[GRAY / PEN_INTERVALCHAR];
            }
        }
 
        ///---------------------|
        /// Вывод реза.         |
        ///---------------------:
        std::cout << char_pixels;
 
        auto file = std::ofstream(L"out.txt");
             file << char_pixels;
    }
 
    gdi::Status stat;
 
    unsigned greyScaleColor(gdi::Bitmap& b, const unsigned x,
                                            const unsigned y)
    {   gdi::Color        color ;
        b.GetPixel(x, y, &color);
        return  (unsigned(color.GetR())
                       +  color.GetG()
                       +  color.GetB()) / 3;
    }
};
 
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   GDIPLUS      _ready;
 
    ///----------------|
    /// Convert.       |
    ///----------------:
    {   Convert convert;
    }
 
    ///----------------|
    /// Show bitmap.   |
    ///----------------:
    {   ShowImg    show;
    }
 
    std::cin.get();
}

const std::string PEN(" .,:;ox%#@");