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

#include <iostream>
#include <vector>
#include <random>
#include <string>
 
using Arr1d = std::vector<unsigned>;
using Arr2d = std::vector<Arr1d   >;
 
 
///----------------------------------------------------------------------------|
/// 10 - туман войны(клетка закрыта)
///----------------------------------------------------------------------------:
struct  Matrix   : Arr2d
{       Matrix(unsigned h, unsigned w) : Arr2d(h, Arr1d(w, 10))
        {
        }
 
    inline static std::string_view command{"matrix"};
 
};
 
std::ostream& operator<<(std::ostream& o, const Matrix& m)
{   for    (const auto&  r : m)
    {   for(const auto   e : r)
        {   std::cout << e  << ' ';
        }   std::cout <<      '\n';
    }       std::cout << std::endl;
    return o;
}
 
 
int main()
{
    std::mt19937 gen(std::random_device{}());
    std::uniform_int_distribution<> dist(0, 99);
 
    Matrix matrix(10, 20);
 
    for (std::string s; std::getline(std::cin, s);)
    {
        if (s == "quit"         ) break;
        if (s == "rand"         ) std::cout << dist(gen) << std::endl;
        if (s == Matrix::command) std::cout << matrix    << std::endl;
    }
}

#include <iostream>
#include <sstream>
#include <vector>
#include <random>
#include <string>
 
constexpr bool ISDEBUG{false};
 
using Arr1d = std::vector<unsigned>;
using Arr2d = std::vector<Arr1d   >;
 
///----------------------------------------------------------------------------|
/// Парсер команд с аргументами.
///----------------------------------------------------------------------------:
struct  RPCParser
{       RPCParser()
        {
        }
 
    void operator<<(const std::string& str)
    {
        error = false;
        a.clear();
 
        std::stringstream ss(str);
 
        ss >> command;
 
        for(std::string s; ss >> s;)
        {   try
            {   a.push_back(std::stoi(s));
            }
            catch(...)
            {   error = true;
                return;
            }
        }
    }
 
    std::string command;
    Arr1d             a;
    bool          error;
 
    void debug() const
    {   if(ISDEBUG) return;
        std::cout << "RPCParser:debug()-------------:\n"
                  << "command: " << command   << ' ';
        for(const auto  e : a) std::cout << e << ' ';
        std::cout << '\n';
    }
}rpcParser;
 
 
///----------------------------------------------------------------------------|
/// 10 - туман войны(клетка закрыта)
/// 99 - тест.
///
/// Умеет:
///     - "open Y X" - где Y номер ряда матрицы,
///                        X номер столбца матрицы.
///----------------------------------------------------------------------------:
struct  Matrix   : Arr2d
{       Matrix(unsigned h, unsigned w) : Arr2d(h, Arr1d(w, 10))
        {
        }
 
    inline static std::string_view command {"matrix"};
    inline static std::string_view command1{"open"  };
 
    void doCommand(const RPCParser& com)
    {
        if(com.command  != command1) return;
        if(com.a.size() == 2           &&
           com.a[0]     >= this->size() &&
           com.a[1]     >= this->back().size())
        {
            std::cout << "ERROR CODING: BAD ARGUMENTS\n";
            return;
        }
 
        (*this)[com.a[0]][com.a[1] ] = 99;
    }
};
 
 
std::ostream& operator<<(std::ostream& o, const Matrix& m)
{   for    (const auto&  r : m)
    {   for(const auto   e : r)
        {   std::cout << e  << ' ';
        }   std::cout <<      '\n';
    }       std::cout << std::endl;
    return o;
}
 
 
int main()
{
    std::mt19937 gen(std::random_device{}());
    std::uniform_int_distribution<> dist(0, 99);
 
    Matrix matrix(5, 5);
 
    for (std::string s; std::getline(std::cin, s);)
    {
        if (s == "quit"         ) break;
        if (s == "rand"         ) std::cout << dist(gen) << std::endl;
        if (s == Matrix::command) std::cout << matrix    << std::endl;
 
        rpcParser << s;
 
        rpcParser.debug();
 
        if(!rpcParser.error)
        {
            matrix.doCommand(rpcParser);
        }
    }
}

constexpr bool ISDEBUG{false};

    {   if(!ISDEBUG) return;

    namespace mns = minesweeper;
    ///------------------------------------------------------------------------|
    /// ...
    ///------------------------------------------------------------------------:
    void test_02()
    {
        //std::mt19937 gen(std::random_device{}());
        //std::uniform_int_distribution<> dist(0, 99);
 
        for (std::string s; std::getline(std::cin, s);)
        {   if (s == "quit"  ) break;
          //if (s == "rand"  ) std::cout << dist(gen) << std::endl;
 
            ///--------------------------|
            /// Отправляем на парсер.    |
            ///--------------------------:
            rpcParser << s;
 
            if(!rpcParser.error)
            {
                if (s == "getVisual")
                {
                    const std::vector<unsigned>& m = mns::getVisual();
 
                    for(const auto e : m) std::cout << e << ' ';
 
                    continue;
                }
                if (s == "startGame")
                {
                    ///--------------------------|
                    /// Старт новой игры.        |
                    ///--------------------------:
                    mns::Config _cfg = mns::startGame();
 
                    ///--------------------------|
                    /// Отправляем размеры поля. |
                    ///--------------------------:
                    std::cout << _cfg.H << ' ' << _cfg.W << std::endl;
 
                    continue;
                }
                if (rpcParser.command == "inputPlot")
                {
                    ///--------------------------|
                    /// Получаем координаты.     |
                    ///--------------------------:
                    mns::Config::eEVENT EVENT
                        = mns::inputPlot(rpcParser.a[1], rpcParser.a[0]);
 
                    ///--------------------------|
                    /// Отправляем сообщение.    |
                    ///--------------------------:
                    std::cout << EVENT << std::endl;
 
                    continue;
                }
                if (rpcParser.command == "setFlag"  )
                {
                    ///--------------------------|
                    /// Установка флага.         |
                    ///--------------------------:
                    mns::setFlag(rpcParser.a[1], rpcParser.a[0]);
                }
            }
        }
    }

                if (s == "getVisual")
                {
                    const std::vector<unsigned>& m = mns::getVisual();
 
                    ///--------------------------|
                    /// Отправить на визуализацию|
                    ///--------------------------:
                    for(const auto e : m) std::cout << e << ' ';
                    std::cout << std::endl; ///<--- нужно добавить!
                    continue;
                }