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

const char* LOGO = R"(
///----------------------|
/// minesweeper-ver:0.1  |
///----------------------|
)";
///----------------------------------------------------------------------------|
/// C++20 / исходник в utf-8
/// хеллоуворлд: Тест поля.
/// - пользовательские типы всегда начинаются с большой буквы.
///
/// Список базовых структур:
///     - struct Config
///     - struct Cell
///     - struct Field
///     - struct Logic
///----------------------------------------------------------------------------:
const char* RULES = R"(
===============================================================================
|       Правила игры «Сапёр»:                                                 |
|       (minigames.mail.ru/info/article/pravila_sapera)                       |
==============================================================================|
|   1. Цель игры — вскрыть пустые ячейки,                                     |
|   не вскрыв при этом ни одной, содержащей мину.                             |
|                                                                             |
|   2. Игра начинается с первого клика по любой ячейке на поле.               |
|                                                                             |
|   3. При клике на ячейке она открывается. Если в ней находится мина,        |
|   назначается штраф в размере 10 секунд, в течение которых поле недоступно. |
|                                                                             |
|   4. Если в самой ячейке мины нет, но есть мины в соседних ячейках,         |
|   то отображается число, соответствующее количеству мин в соседних ячейках. |
|   Несколько соседних ячеек с числами указывают на одни и те же мины,        |
|   что позволяет точно определить опасные клетки.                            |
|                                                                             |
|   5. Если ни в самой ячейке, ни в соседних с ней ячейках нет мин,           |
|   то открываются все соседние пустые ячейки.                                |
|                                                                             |
|   6. Для удобства, ячейки с минами можно помечать флажками.                 |
|                                                                             |
|   7. Игра выигрывается, как только открыты все ячейки, не содержащие мин.   |
===============================================================================
    ПРОДОЛЖИТЬ ---> PRESS ENTER ...
===============================================================================
)";
 
#include <functional>
#include <iostream>
#include <sstream>
#include <vector>
#include <stack>
#include <array>
#include <list>
 
///----------------|
/// Лог в консоль. |
///----------------:
#define log(a) std::cout << #a << ": \n" << (a) << '\n';
#define   l(a) std::cout << #a << ": "   << (a) << '\n';
 
///----------------------------------------------------------------------------|
/// Модуль игровой логики.
///---------------------------------------------------------------- minesweeper:
namespace minesweeper
{
    ///------------------------------------------------------------------------|
    /// Вспомогательные.
    ///----------------------------------------------------------------- Plot2D:
    template<typename T>
    struct Plot2D
    {   T x, y;
 
        Plot2D<T> operator+(Plot2D<T> p) const
        {   return {p.x + x, p.y + y};
        }
    };
 
    ///------------------------------------------------------------------------|
    /// Настройки.
    ///----------------------------------------------------------------- Config:
    struct Config
    {
        ///-------------------------|
        /// Размер поля.            |
        ///-------------------------:
        size_t W = 21;
        size_t H = 11;
 
        ///-------------------------|
        /// Кол-во бомб в процентах |
        /// от кол-ва клеток.       |
        ///-------------------------:
        float bomb = 5.f;
 
        unsigned getNBomb() const { return bomb * W * H / 100; }
    };
 
    extern Config* cfg;
 
    using plot_t = Plot2D<unsigned>;
 
    ///------------------------------------------------------------------------|
    /// Ячейка поля.
    ///------------------------------------------------------------------- Cell:
    struct Cell
    {
        void setVisual(unsigned n)
        {   if(decoder.isOut(n)) throw "ERROR CODING!";
            visual = n;
        }
 
        char     getVisual2Char()  const
        {   if(!isOpen()) return 'a';
            return decoder(visual);
        }
 
        unsigned getVisual2Uint()  const
        {   if(!isOpen()) return 10;
            return visual;
        }
 
        bool isBomb() const { return bomb   != 0; }
        bool isZero() const { return visual == 0; }
        bool isOpen() const { return open;        }
 
        void doOpen()       { open = true;        }
 
        void setBomb(int type = 1)
        {   bomb   = type;
            visual =   11;
        }
 
    protected:
        ///-------------------|
        /// Поле закрыто.     |
        ///-------------------:
        bool      open {false};
 
        unsigned  visual   {0};
        int         bomb   {0};
 
    public:
        ///----------------------------------------|
        /// Декодер.(нужен для красивого дебага)   |
        ///----------------------------------------:
        struct  Decoder
        {       Decoder() { init(); };
 
            unsigned operator()(char     c) const { return dcd [unsigned(c)]; }
            char     operator()(unsigned i) const { return data[i];           }
            bool     isOut     (unsigned i) const { return i >= data.size();  }
 
        private:
            std::string data    {" 123456789abcdefh"};
            unsigned    dcd[256]{};
 
            void init()
            {   unsigned cnt = 0;
                for(auto c : data) dcd[unsigned(c)] = cnt++;
            }
        };
        inline static const Decoder decoder;
    };
 
    using Cells1D = std::vector<Cell>   ;
    using Cells2D = std::vector<Cells1D>;
    using fooOpen = std::function<bool(const Cells2D&)>;
 
    ///------------------------------------------------------------------------|
    /// Поле.
    ///------------------------------------------------------------------ Field:
    struct  Logic;
    struct  Field : Cells2D
    {       Field(size_t w, size_t h)
                :   Cells2D(h, Cells1D(w)),
                    W(w),
                    H(h),
                    view(h * w)
            {
                l(cfg->getNBomb())
                generateField(cfg->getNBomb());
                calculate ();
                updateView();
            }
 
        size_t W;
        size_t H;
 
        ///----------------------------------------|
        /// Открыть на поле все ячейки.            |
        ///----------------------------------------:
        void doOpenAll()
        {   for    (auto& row  : *this)
            {   for(auto& cell : row  )
                {   cell.doOpen();
                }
            }
        }
 
        ///----------------------------------------|
        /// Дебаг Field.                           |
        ///----------------------------------------:
        std::string debugField() const
        {   std::string L(W + 2,    '-');
                        L.front() = '|';
                        L.back () = '|';
                        L.push_back('\n');
 
            std::stringstream o;
                    o << "    " << L ;
            for    (const auto& row  : *this)
            {       o << "    " << '|';
                for(const auto& cell : row  )
                {   o << cell.getVisual2Char();
                }   o << "|\n";
            }       o << "    " <<  L ;
            return o.str();
        }
 
        ///----------------------------------------|
        /// Дебаг View.                            |
        ///----------------------------------------:
        std::string debugView() const
        {   std::string L(W + 2,    '-');
                        L.front() = '|';
                        L.back () = '|';
                        L.push_back('\n');
 
            unsigned i = 0;
 
            const auto& V = (const_cast<Field*>(this))->getView();
 
            std::stringstream o;
                    o << "    " <<  L ;
            for    (unsigned h = 0; h < H; ++h)
            {       o << "    " << '|';
                for(unsigned w = 0; w < W; ++w)
                {   o << Cell::decoder(V[i++]);
                }   o << "|\n";
            }       o << "    " <<  L ;
            return o.str();
        }
 
        ///----------------------------------------|
        /// Ручной тест.                           |
        ///----------------------------------------:
        static void test()
        {
            l(Cell::decoder(1u ))
            l(Cell::decoder(10u))
 
            ///------------------------------------|
            /// Создаем поле.                      |
            ///------------------------------------:
            Field field(21, 11);
 
            ///------------------------------------|
            /// Открываем все поле.                |
            ///------------------------------------:
            field.doOpenAll();
 
            ///------------------------------------|
            /// Вывод поля в лог.                  |
            ///------------------------------------:
            log(field.debugField());
            log(field.debugView ());
 
            ///------------------------------------|
            /// Тест исключения на ошибку кодера.  |
            ///------------------------------------:
            field[0][0].setVisual(666);
        }
 
        ///----------------------------------------|
        /// Пакет для вьюера.                      |
        ///----------------------------------------:
        const std::vector<unsigned>& getView()
        {   updateView();
            return view;
        }
 
        ///----------------------------------------|
        /// Восемь направлений.                    |
        ///----------------------------------------:
        static const auto& AROUNDCELLS()
        {
            constexpr unsigned U = (unsigned)-1;
            static constexpr std::array<const plot_t, 9> a
            {   plot_t{ 1, 0},
                plot_t{ U, 0},
                plot_t{ 0, 1},
                plot_t{ 0, U},
                plot_t{ 1, 1},
                plot_t{ U, 1},
                plot_t{ 1, U},
                plot_t{ U, U},
                plot_t{ 0, 0}
            };
            return a;
        }
 
    private:
        std::vector<unsigned> view;
 
        ///----------------------------------------|
        /// Открыта ли ячейка?                     |
        ///----------------------------------------:
        bool isOpen(const Plot2D<unsigned>& p) const
        {   return ((*this)[p.y][p.x]).isOpen();
        }
 
        ///----------------------------------------|
        /// Отсутсвуют ли рядом мины?              |
        ///----------------------------------------:
        bool isZero(const Plot2D<unsigned>& p) const
        {   return (*this)[p.y][p.x].isZero();
        }
 
        ///----------------------------------------|
        /// Ячейка вне поля?                       |
        ///----------------------------------------:
        bool isOut(const Plot2D<unsigned>& p) const
        {   return p.y >= this->size() || p.x >= this->front().size();
        }
 
        ///----------------------------------------|
        /// Есть ли в ячейке бомба?                |
        ///----------------------------------------:
        bool isBomb(const Plot2D<unsigned>& p) const
        {   return (*this)[p.y][p.x].isBomb();
        }
 
        ///----------------------------------------|
        /// Команда Открыть!                       |
        ///----------------------------------------:
        void doOpen(const Plot2D<unsigned>& p) const
        {   Cell* pc = const_cast<Cell*>(&((*this)[p.y][p.x]));
            pc->doOpen();
        }
 
        ///----------------------------------------|
        /// Расставить бомбы.                      |
        ///----------------------------------------:
        void generateField(unsigned bomb)
        {
            while(bomb--)
            {
                unsigned w = rand()%W;
                unsigned h = rand()%H;
 
                Cell& cell = (*this)[h][w];
 
                cell.setBomb();
            }
        }
 
        ///----------------------------------------|
        /// Подсчитать соседей с бомбами.          |
        ///----------------------------------------:
        void calculate()
        {
            for    (unsigned h = 0; h < H; ++h)
            {   for(unsigned w = 0; w < W; ++w)
                {
                    Cell& cell = (*this)[h][w];
 
                    if(cell.isBomb()) continue;
 
                    unsigned  cnt = 0;
                    for(const auto& e : AROUNDCELLS())
                    {
                        const plot_t P = e + plot_t{w, h};
 
                        if(!isOut(P) && isBomb(P))
                        {
                            ++cnt;
                        }
                    }
                    cell.setVisual(cnt);
                }
            }
        }
 
        ///----------------------------------------|
        /// Сформовать пакет для Вьюера.           |
        ///----------------------------------------:
        void updateView()
        {   size_t i{0};
            for    (const auto& row  : *this)
            {   for(const auto& cell : row  )
                {   if(cell.isOpen())
                    {    view[i] = cell.getVisual2Uint();
                    }
                    else view[i] = 10;
 
                    ++i;
                }
            }
        }
 
        friend struct Logic;
    };
 
    ///------------------------------------------------------------------------|
    /// Логика.
    ///------------------------------------------------------------------ Logic:
    struct  Logic
    {       Logic(Field& f) : field(f)
            {
            }
 
    private:
        Field& field;
 
        ///----------------------------------------|
        /// Открыть безопасные ячейки.             |
        ///----------------------------------------:
        void openCells(const Plot2D<unsigned>& p)
        {
            if(field.isOut(p)) return;
 
            if(field.isOpen(p) || !field.isZero(p)) return;
 
            std::stack<Plot2D<unsigned>> st; st.push(p);
 
            do
            {   const plot_t P{st.top()}; st.pop();
 
                add_near_cells(st, P);
 
            }while(!st.empty());
        }
 
        ///----------------------------------------|
        /// Нужно для openCells.                   |
        ///----------------------------------------:
        void add_near_cells(std::stack<plot_t>& st, const plot_t& plot) const
        {
            for(const auto& e : Field::AROUNDCELLS())
            {
                const plot_t P{plot + e};
 
                if(!field.isOut(P) && !field.isOpen(P))
                {
                    field.doOpen(P);
 
                    if(field.isZero(P)) st.push(P);
                }
            }
            st.pop();
        }
    };
 
    Config* cfg = nullptr;
}
 
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------- main:
int main()
{
    std::system("chcp 65001>0");
 
    std::cout << LOGO << RULES << std::endl;
 
    std::cin.get(); std::system("cls");
 
    minesweeper::Config c; minesweeper::cfg = &c;
 
    try
    {   ///----------------|
        /// Запускаем тест.|
        ///----------------:
        minesweeper::Field::test();
    }
    catch(const char* error)
    {   ///----------------|
        /// Ошибки кодера. |
        ///----------------:
        std::cerr << error << '\n';
    }
}

#include "stdafx.h"
#include <windows.h>
 
// Функция обработки сообщений окна
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static char lit[38]{ "   Будущее наступило в гавно" };
    static char lit_one[3]{};
    static int i{};
    static int n{ 100 };
    static bool print_n{ true };
    RECT rectPlace{};
    short distance{ 40 };
    
    switch (message)
    {
    case WM_CREATE:
        SetTimer(hWnd, 1, 5, 0);
 break;
 
    case WM_TIMER:
    {
    if (print_n) {
        if (i < GetSystemMetrics(SM_CXSCREEN) - distance)i += distance;
        else { print_n = false; i = 0; }
    }
  else {
      if (n < GetSystemMetrics(SM_CYSCREEN)// - distance  Немножко не определённое поведение
          && lit[i / distance] !=' ') {
          n += 10;
      }
     else {
          if (i < GetSystemMetrics(SM_CXSCREEN) - distance)i += distance;
          else { KillTimer(hWnd, 1); PostQuitMessage(0); }
          n = 100;
          }
        }
  lit_one[0] = ' ';
  lit_one[1] = lit[i / distance];
  rectPlace.top = n; rectPlace.bottom = n + 50;
  rectPlace.left = i; rectPlace.right = i + distance;
  InvalidateRect(hWnd, &rectPlace, TRUE);
    }
    break;
    
    case WM_PAINT:
    {
PAINTSTRUCT paintStruct;
        rectPlace.top = n; rectPlace.bottom = n+50;
        rectPlace.left = i; rectPlace.right = i + distance;
    HDC  hDeviceContext = BeginPaint(hWnd, &paintStruct);
        SetTextColor(hDeviceContext, 0x000000FF);
        SetBkMode(hDeviceContext, TRANSPARENT);
        HFONT hTFont = CreateFontA(44, 0, 0, 0, 0, 0, 0, 0,
            DEFAULT_CHARSET, 0, 0, 0, 0,
            "Arial Bold"
        );
    SelectObject(hDeviceContext, hTFont);
            DrawTextA(hDeviceContext, (LPCSTR)lit_one, 3, &rectPlace, DT_SINGLELINE | DT_LEFT | DT_VCENTER);
        EndPaint(hWnd, &paintStruct);
        break;
    }
case WM_ERASEBKGND:
        //Это на всякий случай. Без этого форма была чёрная
        DefWindowProcA( hWnd,message, wParam, lParam);
        break;
case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
 
 
// ============================
bool create_window(HINSTANCE hInstance)
{
    WNDCLASSEX windowClass;
    windowClass.cbSize = sizeof(WNDCLASSEX);
    windowClass.style = CS_HREDRAW | CS_VREDRAW;
    windowClass.lpfnWndProc = WndProc;
    windowClass.cbClsExtra = 0;
    windowClass.cbWndExtra = 0;
    windowClass.hInstance = hInstance;
    windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    windowClass.hbrBackground = CreateSolidBrush(RGB(255, 0, 255));// (Цвет фона здесь)
    windowClass.lpszMenuName = NULL;
    windowClass.lpszClassName = L"DragnDropClass";
    windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
 
    if (!RegisterClassEx(&windowClass))
    {
printf("\n Couldn't register window class");
        return false;
    }
HWND hwnd = CreateWindowEx(
        WS_EX_TOPMOST | WS_EX_LAYERED// Был ноль (Хочешь прозрачность --- WS_EX_LAYERED)
        , windowClass.lpszClassName
        , L" Application for Windows",
        WS_POPUP// dwStyle WS_POPUP
        , 0, 0,// Координаты расположения окна  Win_x  cor_x cor_y
        10, 10,// Здесь нули не ставь. С нулями с флагом WS_POPUP, не перерисовывает.
        NULL,// hWndParent
        NULL,// hMenu
        hInstance,
        NULL);
 
    if (!hwnd) {
            printf("Couldn't create window");
        return false;
    }
 
    COLORREF color = RGB(255, 0, 255);
    SetLayeredWindowAttributes(hwnd, color, (BYTE)0, LWA_COLORKEY);
    UpdateWindow(hwnd);
 
    MoveWindow(hwnd, 0, 0, GetSystemMetrics(SM_CXSCREEN),
        GetSystemMetrics(SM_CYSCREEN), false);// Раскрывает прозрачную форму,на весь экран. 
 
    ShowWindow(//return true;
        hwnd// <--- Для создания формы (рамочка)// < ----- Из LRESULT CALLBACK wndProc на глобальную переменную
        , SW_SHOW);// <=== включил рамку из кода === (так же и выключать SW_HIDE)
    //====================
    return true;
}
 
 
 
// Основная функция программы
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    if (!create_window(hInstance))
    {
        system("PAUSE");
        return 1;
    }
    MSG msg;
    //The Message Loop
    while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}