Рандомное перемещение фишек по квадратной матрице (клеточный автомат)

#include <cstdlib>
#include <ctime>
 
#include <vector>
#include <iostream>
#include <algorithm>
 
typedef struct tagCoords
{
    int nRow;
    int nCol;
    int nCount;
    int nCheck;
} CHECK_COORDS;
 
const static int  N = 10;
const static long n_iterations = 100;
 
enum { mvForward = 0x01, mvBackward = 0x02 };
enum { mvHorizontal = 0x01, mvVertical = 0x02, mvDiagonal = 0x03 };
 
static long n_it = 0;
static short mv_path = mvForward;
static std::vector<CHECK_COORDS> vCheckCoords, vMatchCoords;
 
using namespace std;
 
void InitMatrix(vector< vector<int> >& Matrix)
{
    vector< vector<int> >::iterator 
        row_iterator = Matrix.begin();
    while (row_iterator != Matrix.end())
        (row_iterator++)->resize(N, 0);
 
    Matrix[0][0] = !Matrix[0][0];
    Matrix[N-1][N-1] = !Matrix[N-1][N-1];
}
 
void Display(int val) { std::cout << val << " "; }
int  MoveOrient() { return std::rand() % mvDiagonal + mvHorizontal; }
 
void UpdateView(vector< vector<int> >& Matrix)
{
    vector< vector<int> >::iterator 
        row_iterator = Matrix.begin();
    while (row_iterator != Matrix.end())
    {
        std::for_each(row_iterator->begin(), 
            row_iterator->end(), Display);
        std::cout << endl;
        row_iterator++;
    }
 
    std::cout << endl;
}
 
void MoveCheck(int row, int col, int check, 
    vector< vector<int> >& Matrix, vector<CHECK_COORDS>& CheckCoords)
{
    if (n_it >= n_iterations) return;
    if (row > N-1 && col <= N-1) row--;
    if (col > N-1 && row <= N-1) col--;
 
    if (row >= N-1 && col >= N-1 && mv_path == mvForward)
        mv_path = mvBackward;
    else if (row <= 0 && col <= 0 && mv_path == mvBackward) 
        mv_path = mvForward;
        
    Matrix[row][col] = !Matrix[row][col];
 
    std::cout << "row = " << row << " " << "col = " << 
        col << " " << "iteration = " << n_it+1 << endl << endl;
    if (mvHorizontal == MoveOrient() && row < N-1 && mv_path == mvForward) row++;
    else if (mvVertical == MoveOrient() && col < N-1 && mv_path == mvForward) col++;
    else if (mvDiagonal == MoveOrient() && row < N-1 && col < N-1 && mv_path == mvForward) { row++; col++; }
    else if (mvHorizontal == MoveOrient() && row > 0 && mv_path == mvBackward) row--;
    else if (mvVertical == MoveOrient() && col > 0 && mv_path == mvBackward) col--;
    else if (mvDiagonal == MoveOrient() && row > 0 && col > 0 && mv_path == mvBackward) { row--; col--; }
 
    bool bFound = false;
    vector<CHECK_COORDS>::iterator 
        coords_iterator = CheckCoords.begin();
    while (coords_iterator != CheckCoords.end() && !bFound)
    {
        if (coords_iterator->nRow == row && 
            coords_iterator->nCol == col && 
            coords_iterator->nCheck == check)
            { coords_iterator->nCount++; bFound = true; }
 
        coords_iterator++;
    }
 
    if (bFound == false)
    {
        CHECK_COORDS Coords;
        std::memset((void*)&Coords, 0x00, sizeof(CHECK_COORDS));
        Coords.nRow = row; Coords.nCol = col;
        Coords.nCheck = check; Coords.nCount = 1;
 
        CheckCoords.push_back(Coords);
    }
 
    Matrix[row][col] = !Matrix[row][col]; n_it++;
    UpdateView(Matrix); std::cin.get();
 
    MoveCheck(row, col, check, Matrix, CheckCoords);
}
 
int main(int argc, char** argv)
{
    vector< vector<int> > Matrix(N,0);
 
    std::srand((unsigned)std::time(NULL));
 
    InitMatrix(Matrix);
    UpdateView(Matrix);
 
    n_it = 0; 
    MoveCheck(0, 0, 0, Matrix, vCheckCoords);
    
    n_it = 0; 
    MoveCheck(N-1, N-1, 1, Matrix, vCheckCoords);
 
    vector<CHECK_COORDS>::iterator 
        coords_iterator = vCheckCoords.begin();
    while (coords_iterator != vCheckCoords.end())
    {
        long nVCount = 1;
        vector<CHECK_COORDS>::iterator 
            seek_iterator = coords_iterator;
        while (seek_iterator != vCheckCoords.end())
        {
            if (seek_iterator->nRow == coords_iterator->nRow &&
                seek_iterator->nCol == coords_iterator->nCol && 
                seek_iterator->nCheck == 1)
                nVCount = nVCount + 1;
 
            seek_iterator++;
        }
 
        CHECK_COORDS CheckCoords;
        std::memset((void*)&CheckCoords, 0x00, sizeof(CHECK_COORDS));
 
        CheckCoords.nRow = coords_iterator->nRow;
        CheckCoords.nCol = coords_iterator->nCol;
        CheckCoords.nCheck = 0; CheckCoords.nCount = nVCount;
 
        vMatchCoords.push_back(CheckCoords);
 
        std::cout << "row = " << coords_iterator->nRow << " " << 
                     "col = " << coords_iterator->nCol << " " <<
                     "check = " << coords_iterator->nCheck << " " <<
                     "count = " << coords_iterator->nCount << endl;
 
        coords_iterator++;
    }
 
    std::cout << endl << endl;
 
    long total = 0;
    vector<CHECK_COORDS>::const_iterator 
        match_iterator = vMatchCoords.begin();
    while (match_iterator != vMatchCoords.end())
    {
        std::cout << "row = " << match_iterator->nRow << " " << 
                     "col = " << match_iterator->nCol << " " <<
                     "count = " << match_iterator->nCount << endl;
        
        total+=match_iterator->nCount;
        match_iterator++;
    }
 
    std::cout << "\nTotal matches of both checks movement: " << total << endl << endl;
    cout << "\nPress any key to continue..." << endl; std::cin.get();
 
    return 0;
}

#include <iostream>
#include <sstream>
#include <ctime>
#include <Windows.h>
 
HWND hW = GetConsoleWindow();
HDC hDC = GetDC(hW);
HANDLE hSTD = GetStdHandle(STD_INPUT_HANDLE); 
 
class Dot
{   
public:
    Dot();
    void SetDot (POINT*, POINT *,COLORREF);
    void CurToPrev ();
    POINT *GetPrev()    {   return coordPrev;}
    POINT *GetCur()     {   return coordCur; }
    COLORREF GetColor() {   return color;   }
    HBRUSH GetBrush()   {   return brush;   }
    void RandomMove (int);
    ~Dot();
 
private:
    POINT *coordPrev, *coordCur;
    COLORREF color;
    HBRUSH brush;
};
 
Dot::Dot ()
{   coordPrev = new POINT;
    coordCur = new POINT;
    coordPrev->x = coordPrev->y = 0;
    coordCur->x = coordCur->y = 0;
    color = RGB(0,0,0);
}
 
void Dot::SetDot (POINT *p0, POINT *p1, COLORREF c)
{   coordPrev->x = p0->x;
    coordPrev->y = p0->y;
    coordCur->x = p1->x;
    coordCur->y = p1->y;
    color = c;
    brush = CreateSolidBrush(c);
}
 
Dot::~Dot()
{   delete coordPrev;
    delete coordCur;
    DeleteObject(brush);
}
 
void Dot::CurToPrev()
{   coordPrev->x = coordCur->x;
    coordPrev->y = coordCur->y;
}
 
void Dot::RandomMove (int N)
{   int choice = rand() % 9;
    while (choice == 4 )
        choice = rand() % 9;
    int i = choice/3 - 1, j = choice%3 - 1; 
    
    coordCur->x = coordPrev->x + j;
    coordCur->y = coordPrev->y + i;
 
    if (coordCur->x < 0)    coordCur->x ++;
    if (coordCur->y < 0)    coordCur->y ++;
    if (coordCur->x > N-1)  coordCur->x --;
    if (coordCur->y > N-1)  coordCur->y --;
}
 
Dot **CreateArray (int M)
{   Dot **dots = new Dot*[M];
    for (int i = 0; i<M; i++)
        dots[i] = new Dot;
    return dots;
}
 
void DeleteArray (Dot **dots, int M)
{   for (int i = 0; i<M; i++)
        delete dots[i];
    delete [] dots;
}
 
void NextMove (Dot **dots, int M, int N)
{   for (int i = 0; i<M; i++)
    {   dots[i]->CurToPrev();
        dots[i]->RandomMove(N);
    }   
}
 
bool Meeting (Dot *d1, Dot *d2)
{   return (d1->GetCur()->x == d2->GetCur()->x && d1->GetCur()->y == d2->GetCur()->y);
}
 
void SetField (int N, int h)
{   int i, j;
    int x0 = 20, y0 = 80;
    HBRUSH  blueBrush = CreateSolidBrush(RGB(0,0,255)),\
            blackBrush = CreateSolidBrush(RGB(0,0,0));
    
    SelectObject(hDC, blueBrush);
    Rectangle(hDC, x0-1, y0-1, x0+N*h+2, y0+N*h+2);
    DeleteObject(blueBrush);
        
    SelectObject(hDC, blackBrush);
    for(i = 0; i<N; i++)
        for(j = 0; j<N; j++)
            Rectangle(hDC, x0+j*h+1, y0+i*h+1, x0+(j+1)*h, y0+(i+1)*h);
    DeleteObject(blackBrush);
}
 
void ShowPicture (int step, int meet, Dot **dots, int M, int N, int h)
{   int x0 = 20, y0 = 80, x, y, i;
    std::string num;
    std::string message = "     Step ";
    std::ostringstream oss;
    oss << step;
    message += oss.str();
    message += "     ";
    SetBkColor(hDC, RGB(255,255,0));
    TextOutA(hDC, 20, 10, message.c_str(), message.length());
    oss.str(""); oss.clear(); 
    message = "     Having met ";
    oss << meet;
    message += oss.str();
    message += " times     ";
    TextOutA(hDC, 20, 40, message.c_str(), message.length());
    SetBkColor(hDC, RGB(0,0,0));
 
    HBRUSH  blackBrush = CreateSolidBrush(RGB(0,0,0));
    for (i = 0; i<M; i++)
    {   SelectObject(hDC, blackBrush);
        x = dots[i]->GetPrev()->x; y = dots[i]->GetPrev()->y;
        Rectangle(hDC, x0+x*h+1, y0+y*h+1, x0+(x+1)*h, y0+(y+1)*h);
        
        SelectObject(hDC, dots[i]->GetBrush());
        x = dots[i]->GetCur()->x; y = dots[i]->GetCur()->y;
        Rectangle(hDC, x0+x*h+1, y0+y*h+1, x0+(x+1)*h, y0+(y+1)*h);
    }
    DeleteObject(blackBrush);
}
 
int main()
{   //SetWindowPos(hW, HWND_TOPMOST, 0,0,350,450,SWP_SHOWWINDOW);
    srand ((unsigned int) time (NULL));
    int N = 10;             //размер поля NxN
    int M = 2;              //кво объектов
    int step = 0;           //шаг 
    int h = 20;             //размер одной ячейки поля в пикселях
    int meet = 0;           //кво встреч 
    
    Dot **dots = CreateArray(M);
    POINT *point = new POINT;
    point->x = point->y = 0;
    dots[0]->SetDot (point, point, RGB(255,0,0));
    point->x = point->y = N-1;
    dots[1]->SetDot (point,point, RGB(0,255,0));
 
    SetField (N, h);
    ShowPicture (++step, meet, dots, M, N, h);
    
    while(++step < 500)
    {   NextMove (dots, M, N);
        if (Meeting (dots[0], dots[1])) meet++;
        ShowPicture (step, meet,dots, M, N, h);
        Sleep (100);
    }
 
    DeleteArray (dots, M);
    delete point;
    std::cin.get();
    return 0;
}