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

#include <iostream>
//#include <sstream>
#include <cstring>
#include <vector>
#include <stack>
#include <ctime>
 
struct Coord
{   int  x,y;
};
 
class Matrix : public std::vector<int>
{
    int c, r;
public:
    Matrix(int, int, bool);
    Matrix() : c(0), r(0){}
 
    void set(int i, int j, int v)       {        (*this)[c*i+j] = v; }
    int  get(int i, int j       ) const { return (*this)[c*i+j]    ; }
 
    void renew(int, int, bool);
    int& operator()(int, int );
 
    int sizeC() const { return c; }
    int sizeR() const { return r; }
 
private:
    void clr();
    void fill_zero()
    {   for    (int i=0; i<r; i++)
            for(int j=0; j<c; j++)
                set(i, j, 0);
    }
};
 
int& Matrix::operator()(int i, int j)
{   return (*this)[c*i+j];
}
 
Matrix::Matrix(int cc, int rr, bool n=false) : std::vector<int>(cc*rr)
{
    c=cc;
    r=rr;
 
    if(n) fill_zero();
}
 
void Matrix::clr()
{   clear();
    c=0;
    r=0;
}
 
void Matrix::renew(int cc, int rr, bool n)
{
    this->resize(cc*rr);
 
    c=cc;
    r=rr;
 
    if(n) fill_zero();
}
 
std::stack<Coord> st;
 
void flood(Matrix& m, Coord cr)
{   Coord c;
    while(true)
    {   m.set(cr.x, cr.y, 2);
        c.y=cr.y;
        for(int i=cr.x-1; i>=0 && m(i, cr.y)==0; i--)
        {   c.x=i;
            st.push(c);
        }
        c.y=cr.y;
        for(int i=cr.x+1; i<m.sizeC() && m(i, cr.y)==0; i++)
        {   c.x=i;
            st.push(c);
        }
        c.x=cr.x;
        for(int i=cr.y-1; i>=0 && m(cr.x, i)==0; i--)
        {   c.y=i;
            st.push(c);
        }
        c.x=cr.x;
        for(int i=cr.y+1; i<m.sizeR() && m(cr.x, i)==0; i++)
        {   c.y=i;
            st.push(c);
        }
 
        if(st.empty())return;
 
        cr.x=st.top().x;
        cr.y=st.top().y;
        st.pop();
    }
}
 
int main()
{   //srand(time(NULL));
    //stack st;
 
    int t, nm = 40;
 
    Matrix b(9, 9, true);
 
    std::vector<Coord> v; v.reserve(b.size());
 
    for    (int i=0; i<b.sizeR(); i++)
    {   for(int j=0; j<b.sizeC(); j++)
        {   v.push_back({i, j});
        }
    }
 
    t=b.size();
 
    for(int j=0; j<nm; j++, t--)
    {   int 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();
    }
 
    flood(b, {7, 7});//нужно изменить координаты чтобы попасть в пустую область
 
    for    (int i=0; i<b.sizeR(); i++)
    {   for(int j=0; j<b.sizeC(); j++)
            std::cout << b(i, j);
        std::cout << std::endl;
    }
 
    std::cin.get();
    return 0;
}

#include <algorithm>
 
void fill_zero()
{
    std::fill(begin(), end(), 0);
}

#include <iostream>
#include <sstream>
#include <fstream>
#include <cstring>
#include <vector>
#include <stack>
#include <ctime>
 
///----------------------------------------------------------|
/// В С++ индексы массивов(те что контейнеры) 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::cout            << ss.str() << std::endl;
 
        std::string s; std::getline(std::ifstream("etalon.txt"), s, '\f');
        if(s.empty())
        {
            std::cout << "WARNING: File \"etalon.txt\" absent!\n";
 
            ///------------------------------------------|
            /// Изготовливаем эталонный файл результата. |
            /// (теперь будем вносить изменения в код)   |
            ///------------------------------------------:
            std::ofstream("etalon.txt") << m << std::endl;
 
            std::cout << "File \"etalon.txt\" was created!\n";
        }
 
        bool b = s == ss.str();
        {   std::cout << "Autotest: "
                      << (b ? "ERROR CODE..." : "SUCCESS!") << '\n';
        }
 
        return b;
    }
 
    friend int main();
};
 
 
int main()
{   //srand(time(NULL));
 
    bool isGood = AlgorithmHuligan::autoTest();
 
    std::cin.get();
    return  isGood;
}