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

#include <iostream>
#include <sstream>
#include <fstream>
#include <cstring>
#include <vector>
#include <stack>
#include <ctime>
 
#define   l(v) std::cout << #v << " = " << (v) << "\n";
#define log(a) std::cout << #a << ": \n" << (a) << '\n';
 
///----------------------------------------------------------|
/// В С++ индексы массивов(те что контейнеры) size_t типа... |
/// не будем же цать против ветра.                           |
///----------------------------------------------------------:
using uint = unsigned;
 
struct Coord
{   uint  x,y;
};
 
class Matrix : public std::vector<uint>
{   uint c, r;
public:
    Matrix(uint, uint, bool);
    Matrix() : c(0), r(0) {}
 
    void set(uint i, uint j, uint v)       { (*this)[c*i+j] = v   ; }
    uint get(uint i, uint j        ) const { return (*this)[c*i+j];}
 
    void  renew(uint, uint, bool);
    uint& operator()(uint, uint );
 
    uint sizeC() const { return c; }
    uint sizeR() const { return r; }
 
private:
    void clr();
    void fill_zero()
    {   for    (uint i=0; i<r; i++)
            for(uint j=0; j<c; j++)
                set(i, j, 0);
    }
};
 
uint& Matrix::operator()(uint i, uint j)
{   return (*this)[c*i+j];
}
 
Matrix::Matrix(uint cc, uint rr, bool n=false) : std::vector<uint>(cc*rr)
{   c=cc;
    r=rr;
 
    if(n) fill_zero();
}
 
void Matrix::clr()
{   clear();
    c=0;
    r=0;
}
 
void Matrix::renew(uint cc, uint rr, bool n)
{   this->resize(cc*rr);
 
    c=cc;
    r=rr;
 
    if(n) fill_zero();
}
 
std::ostream& operator<<(std::ostream& o, const Matrix& m)
{   for    (uint i=0; i<m.sizeR(); i++)
    {   for(uint j=0; j<m.sizeC(); j++)
        {   o << m.get(i, j);
        }   o << '\n';
    }
    return o;
}
 
///----------------------------------------------------------------------------|
/// Алгоритм Хулигана в одном модуле.
///     - можно создать в программе кучу таких модулей, т.е. объектов такого типа.
///     - хранить состояние сколько угодно долго.
///     - гонять этот модуль(объект) по всей программе.
///     - ничего не торчит в наружу - легче читать код.
///     - ...
///----------------------------------------------------------------------------|
struct  AlgorithmHuligan
{       AlgorithmHuligan(uint R = 9, uint C = 9, bool a = true) : b(R, C, a)
        {   v.reserve(b.size());
 
            for    (uint i=0; i<b.sizeR(); i++)
            {   for(uint j=0; j<b.sizeC(); j++)
                {   v.push_back({i, j});
                }
            }
 
            uint t = b.size();
 
            for(uint j=0; j<nm; j++, t--)
            {   uint g=rand()%t;
 
                b(v[g].x, v[g].y) = 1; /// b.set(v[g].x, v[g].y, 1);
                v[g]=v[t-1];
 
                v.pop_back();
            }
        }
 
    ///------------------|<--- !!!
    /// Интерфейс.       |
    ///------------------:
    void doStep(const Coord& coord)
    {   flood(b, coord);
    }
 
    ///------------------|<--- !!!
    /// ПОДВАЛ...        |
    ///----------------...
private:
    Matrix             b;
    std::vector<Coord> v;
 
    uint nm = 40;
 
    void flood(Matrix& m, Coord cr)
    {
        std::stack<Coord> st;
 
        while(true)
        {   m.set(cr.x, cr.y, 2);
 
        for(uint x=cr.x-1; x>=0        && m(x, cr.y)==0; x--) st.push({x, cr.y});
        for(uint x=cr.x+1; x<m.sizeC() && m(x, cr.y)==0; x++) st.push({x, cr.y});
        for(uint y=cr.y-1; y>=0        && m(cr.x, y)==0; y--) st.push({cr.x, y});
        for(uint y=cr.y+1; y<m.sizeR() && m(cr.x, y)==0; y++) st.push({cr.x, y});
 
            if(st.empty()) return;
 
            cr.x=st.top().x;
            cr.y=st.top().y;
            st.pop();
        }
    }
 
    ///------------------|
    /// Автотест.        |
    ///------------------:
    static bool autoTest()
    {
        AlgorithmHuligan task;
                         task.doStep({7,7}); /// нужно изменить координаты чтобы
                                             /// попасть в пустую область
        const auto& m = task.b;
 
        std::stringstream ss;
                          ss << m << std::endl;
 
        std::string file; std::getline(std::ifstream("etalon.txt"), file, '\f');
        if(file.empty())
        {
            std::cout << "WARNING: File \"etalon.txt\" absent!\n";
 
            ///------------------------------------------|
            /// Изготовливаем эталонный файл результата. |
            /// (теперь будем вносить изменения в код)   |
            ///------------------------------------------:
            std::ofstream("etalon.txt") << m << std::endl;
 
            std::cout << "File \"etalon.txt\" was created!\n";
        }
 
        l(file.size())
        l(ss.str().size())
 
        log(file)
        log(ss.str())
 
        bool b = file == ss.str();
        {   std::cout << "Autotest: "
                      << (b ? "SUCCESS!" : "ERROR CODE...") << '\n';
        }
 
        return b;
    }
 
    friend int main();
};
 
 
int main()
{   //srand(time(NULL));
 
    bool isGood = AlgorithmHuligan::autoTest();
 
    std::cin.get();
    return  isGood;
}

return  isGood == false;