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

const char* LOGO = R"(
///----------------------|
/// minesweeper-ver:0.2  |
///----------------------|
)";
///----------------------------------------------------------------------------|
/// C++20 / исходник в utf-8
/// хеллоуворлд: Тест поля.
/// - пользовательские типы всегда начинаются с большой буквы.
///
/// Список базовых структур:
///     - struct Config
///     - struct Cell
///     - struct Field
///     - struct Logic
///     - struct Game
///----------------------------------------------------------------------------:
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 <memory>
#include <vector>
#include <stack>
#include <array>
#include <list>
 
///----------------------------------------------------------------------------|
/// Доступ(интерфейс) к модели.
///----------------------------------------------------------------------------:
namespace minesweeper
{
    struct Config;
 
    Config                startGame();
    std::vector<unsigned> getVisual();
    int                   inputPlot(unsigned x, unsigned y);
 
    void openAll();
}
 
///----------------|
/// Лог в консоль. |
///----------------:
#define log(a) std::cout << #a << ": \n" << (a) << '\n';
#define   l(a) std::cout << #a << ": "   << (a) << '\n';
 
void  tests();
 
///----------------------------------------------------------------------------|
/// Модуль c моделью игровой логики.
///---------------------------------------------------------------- minesweeper:
namespace minesweeper
{
    ///------------------------------------------------------------------------|
    /// Вспомогательные.
    ///----------------------------------------------------------------- Plot2D:
    template<typename T>
    struct Plot2D
    {   T x, y;
 
        Plot2D<T> operator+(const 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 std::unique_ptr<Config> cfg;
 
    using plot_t = Plot2D<unsigned>;
 
    ///------------------------------------------------------------------------|
    /// Ячейка поля.
    ///------------------------------------------------------------------- Cell:
    struct Cell
    {
        ///-------------------|
        /// Cтатус ячейки.    |
        ///-------------------:
        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;
        }
 
    private:
        ///-------------------|
        /// Поле закрыто.     |
        ///-------------------:
        bool      open {false};
 
        unsigned  visual   {0};
        int         bomb   {0};
 
    public:
        ///----------------------------------------|
        /// Декодер(нужен для красивого дебага).   |
        ///------------------------------------------------------------ Decoder:
        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 fooCells_t = std::function<bool(const Cells2D&)>; /// Not used.
 
    ///------------------------------------------------------------------------|
    /// Поле.
    ///------------------------------------------------------------------ Field:
    struct  Logic;
 
    struct  Field : Cells2D
    {       Field(size_t w, size_t h)
                :   Cells2D(h, Cells1D(w)),
                    W(w),
                    H(h),
                    view(h * w)
            {
                geneBombs(cfg->getNBomb());
                calcBombs ();
                updateView();
            }
 
        size_t W;
        size_t H;
 
        ///----------------------------------------|
        /// Открыть на поле все ячейки.            |
        ///----------------------------------------:
        void doOpenAll()
        {   for    (auto& row  : *this)
            {   for(auto& cell : row  )
                {   cell.doOpen();
                }
            }
        }
 
        ///----------------------------------------|
        /// Пакет для вьюера.                      |
        ///----------------------------------------:
        const std::vector<unsigned>& getView()
        {   updateView();
            return view;
        }
 
    private:
        std::vector<unsigned> 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;
        }
 
        ///----------------------------------------|
        /// Открыта ли ячейка?                     |
        ///----------------------------------------:
        bool isOpen(const plot_t& p) const
        {   return ((*this)[p.y][p.x]).isOpen();
        }
 
        ///----------------------------------------|
        /// Отсутствуют ли рядом мины?             |
        ///----------------------------------------:
        bool isZero(const plot_t& p) const
        {   return (*this)[p.y][p.x].isZero();
        }
 
        ///----------------------------------------|
        /// Ячейка вне поля?                       |
        ///----------------------------------------:
        bool isOut(const plot_t& p) const
        {   return p.y >= H || p.x >= W;
        }
 
        ///----------------------------------------|
        /// Есть ли в ячейке бомба?                |
        ///----------------------------------------:
        bool isBomb(const plot_t& p) const
        {   return (*this)[p.y][p.x].isBomb();
        }
 
        ///----------------------------------------|
        /// Команда Открыть!                       |
        ///----------------------------------------:
        void doOpen(const plot_t& p) const
        {   Cell* pc = const_cast<Cell*>(&((*this)[p.y][p.x]));
            pc->doOpen();
        }
 
        ///----------------------------------------|
        /// Расставить бомбы.                      |
        ///----------------------------------------:
        void geneBombs(unsigned bombs)
        {
            while(bombs--)
            {
                unsigned w = rand()%W;
                unsigned h = rand()%H;
 
                Cell& cell = (*this)[h][w];
 
                cell.setBomb();
            }
        }
 
        ///----------------------------------------|
        /// Подсчитать соседей с бомбами.          |
        ///----------------------------------------:
        void calcBombs()
        {
            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;
                }
            }
        }
 
        ///----------------------------------------|
        /// Дебаг 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();
        }
 
    public:
        ///----------------------------------------|
        /// Дебаг View.                            |
        ///----------------------------------------:
        static std::string debugView(const std::vector<unsigned>& V)
        {
            const unsigned& W = cfg->W;
            const unsigned& H = cfg->H;
 
            std::string L(W + 2,    '-');
                        L.front() = '|';
                        L.back () = '|';
                        L.push_back('\n');
 
            unsigned i = 0;
 
            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))
 
            l(cfg->getNBomb())
 
            ///------------------------------------|
            /// Создаем поле.                      |
            ///------------------------------------:
            Field field(21, 11);
 
            ///------------------------------------|
            /// Открываем все поле.                |
            ///------------------------------------:
            field.doOpenAll();
 
            ///------------------------------------|
            /// Вывод поля в лог.                  |
            ///------------------------------------:
            log(field.debugField( ));
            log(field.debugView (field.getView()));
 
            ///------------------------------------|
            /// Тест исключения на ошибку кодера.  |
            ///------------------------------------:
            field[0][0].setVisual(666);
        }
 
        friend struct Logic;
        friend void ::tests();
    };
 
    ///------------------------------------------------------------------------|
    /// Логика.
    ///------------------------------------------------------------------ Logic:
    struct  Logic
    {       Logic(Field& f) : field(f)
            {
            }
 
        enum EVENT
        {    E_GOOD,
             E_BOMB,
             E_OUT ,
             E_NONE
        };
 
        ///----------------------------------------|
        /// Команда для контроллера.               |
        ///----------------------------------------:
        EVENT inputOpenCell(const plot_t& p)
        {
            ///------------------------------------|
            /// Ничего делать не надо.             |
            ///------------------------------------:
            if(field.isOut(p) || field.isOpen(p)) return E_OUT;
 
            ///------------------------------------|
            /// Если безопасная ячейка.            |
            ///------------------------------------:
            if(field.isZero  (p))
            {   openZeroCells(p);
                return E_GOOD;
            }
 
            ///------------------------------------|
            /// Окрываем.                          |
            ///------------------------------------:
            else field.doOpen(p);
 
            ///------------------------------------|
            /// Если там бомба, то песец...        |
            ///------------------------------------:
            if(  field.isBomb(p))
            {   return E_BOMB;
            }
 
            ///------------------------------------|
            /// Пока всё гуд.                      |
            ///------------------------------------:
            return E_GOOD;
        }
 
    private:
        Field& field;
 
        ///----------------------------------------|
        /// Открыть безопасные ячейки.             |
        ///----------------------------------------:
        void openZeroCells(const plot_t& p)
        {
            std::stack<plot_t> st; st.push(p);
 
            do
            {   const plot_t P{st.top()}; st.pop();
 
                addNearCells(st, P);
 
            }while(!st.empty());
        }
 
        ///----------------------------------------|
        /// Сбор окрестностей ячейки.              |
        ///----------------------------------------:
        void addNearCells(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();
        }
    };
 
    ///------------------------------------------------------------------------|
    /// Game.
    ///------------------------------------------------------------------- Game:
    struct  Game
    {       Game() : field(21, 11), logic(field)
            {
                std::cout << LOGO << RULES << std::endl;
                std::cin.get(); std::system("cls");
            }
 
        int inputPlot(const plot_t& p)
        {   logic.inputOpenCell    (p);
            return 0;
        }
 
        const std::vector<unsigned>& getVisual()
        {   return field.getView();
        }
 
        void openAll()
        {   field.doOpenAll();
        }
 
    private:
        Field field;
        Logic logic;
    };
 
    std::unique_ptr<Config> cfg;
    std::unique_ptr<Game> pgame;
 
    Config startGame()
    {
        cfg   = std::make_unique<Config>();
        pgame = std::make_unique<Game  >();
 
        return *cfg;
    }
 
    std::vector<unsigned> getVisual()
    {   return pgame->getVisual();
    }
 
    int inputPlot(unsigned x, unsigned y)
    {   pgame->inputPlot({x, y});
        return 0;
    }
 
    void openAll()
    {   pgame->openAll();
    }
}
 
///----------------------------------------------------------------------------|
/// Клиентская часть.
///--------------------------------------------------------------------- client:
namespace client
{
    void test()
    {
        [[maybe_unused]] minesweeper::Config c = minesweeper::startGame();
 
        l(c.W)
        l(c.H)
 
        minesweeper::openAll();
 
        log(minesweeper::Field::debugView(minesweeper::getVisual()));
    }
}
 
///--------|
/// Тесты. |
///--------:
void tests()
{
    minesweeper::cfg = std::make_unique<minesweeper::Config>();
 
//  minesweeper::Field::test();
 
    client::test();
}
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------- main:
int main()
{
    std::system("chcp 65001>0");
 
    srand(time(NULL));
 
    try
    {   ///-----------------|
        /// Запускаем тесты.|
        ///-----------------:
        tests();
    }
    catch(const char*  error)
    {   ///-----------------|
        /// Ошибки кодера.  |
        ///-----------------:
        std::cerr << error << '\n';
    }
 
    std::cout << "PROGRAM FINISHED!" << std::endl;
}