Консольный сапер

#include <iostream>
#include <time.h>
//#include <windows.h>
#include <iomanip>
#include <time.h>
#include <stdio.h>
#include <conio.h>
using namespace std;
#define BOOM 10 //количество бомб на поле
 
//  1
void show_of_mines()
{
    cout << "* ";
}
void print_array_2D(int **Playing_field, bool ** open, const int SIZE)
{
    char strLetters[30] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\0' };
    cout << "  ";
    for (int i = 0; i < SIZE; i++)
    {
        
        cout << " " << strLetters[i];
    }   
    cout << endl;
 
 
    for (int x = 0; x <= SIZE; x++)
    {
        if (x < 10)
        {
            cout << x << " |";
        }
        else
        {
            cout << x << "|";
        }
    /////////////////////////////////////   
 
        for (int y = 0; y < SIZE; y++)
        {
            if (open[x][y])
            {
 
                if (Playing_field[x][y] == -1)      
                {
                    show_of_mines();
                }
                else if (Playing_field[x][y] == 0)
                {
                    cout << "* ";
                }
                else
                {
                    cout << Playing_field[x][y] << " ";
                }
            }
            else
            {
                cout << "& ";
            }
        }
        cout << endl;
    }
}
// проверяет ячейку на пустоту (true), выход за пределы массива возвращает false
bool empty(int **Playing_field, int i, int j, const int SIZE)
{
    if ((i >= 0) && (i < SIZE))
    {
        if ((j >= 0) && (j < SIZE))
        {
            if (Playing_field[i][j] == 0) return true;
        }
    }
    return false;
}
// рекурсивная функция, которая открывает поля в точке попадания
void clean(int **Playing_field, bool **open, int i, int j, const int SIZE)
{
    // проверим на выход за пределы массива
    if ((i >= 0) && (i < SIZE))
    {
        if ((j >= 0) && (j < SIZE))
        {
            // проверим, не было ли открыто поле раньше
            if (!open[i][j])
            {
                open[i][j] = true;  //откроем
                                    // если поле пустое (=0), просто пооткрываем всех его соседей
                if (Playing_field[i][j] == 0)
                {
                    clean(Playing_field, open, i - 1, j - 1, SIZE);
                    clean(Playing_field, open, i - 1, j, SIZE);
                    clean(Playing_field, open, i - 1, j + 1, SIZE);
                    clean(Playing_field, open, i, j - 1, SIZE);
                    clean(Playing_field, open, i, j + 1, SIZE);
                    clean(Playing_field, open, i + 1, j - 1, SIZE);
                    clean(Playing_field, open, i + 1, j, SIZE);
                    clean(Playing_field, open, i + 1, j + 1, SIZE);
                }
                // если не пустое (!=0) открываем только пустых (=0) соседей
                else
                {
                    if (empty(Playing_field, i - 1, j - 1, SIZE)) clean(Playing_field, open, i - 1, j - 1, SIZE);
                    if (empty(Playing_field, i - 1, j, SIZE)) clean(Playing_field, open, i - 1, j, SIZE);
                    if (empty(Playing_field, i - 1, j + 1, SIZE)) clean(Playing_field, open, i - 1, j + 1, SIZE);
                    if (empty(Playing_field, i, j - 1, SIZE)) clean(Playing_field, open, i, j - 1, SIZE);
                    if (empty(Playing_field, i, j + 1, SIZE)) clean(Playing_field, open, i, j + 1, SIZE);
                    if (empty(Playing_field, i + 1, j - 1, SIZE)) clean(Playing_field, open, i + 1, j - 1, SIZE);
                    if (empty(Playing_field, i + 1, j, SIZE)) clean(Playing_field, open, i + 1, j, SIZE);
                    if (empty(Playing_field, i + 1, j + 1, SIZE)) clean(Playing_field, open, i + 1, j + 1, SIZE);
                }
            }
        }
    }
}
 
// проверяет ячейку на мину ; выход за пределы возвращает false
bool mine(int **Playing_field, int i, int j, const int SIZE)
{
    if ((i >= 0) && (i < SIZE))
    {
        if ((j >= 0) && (j < SIZE))
        {
            if (Playing_field[i][j] == -1) return true;
        }
    }
    return false;
}
 
void empty_play_space(int **Playing_field, bool ** open, const int SIZE)
{
    for (int i = 0; i < SIZE; i++)
    {
        for (int j = 0; j < SIZE; j++)
        {
            if (Playing_field[i][j] == -1)
            {
                open[i][j] = true;
            }
        }
    }
}
 
bool win_or_lose(int **Playing_field, bool ** open, const int SIZE)
{
    for (int x = 0; x < SIZE; x++)
    {
        for (int y = 0; y < SIZE; y++)
        {
            if ((Playing_field[x][y] != -1) && (!open[x][y])) return false;
        }
    }
    return true;
}
 
// в случае проигрыша эта функция откроет все мины
void openmines(int **Playing_field, bool ** open, const int SIZE)
{
    for (int i = 0; i < SIZE; i++)
    {
        for (int j = 0; j < SIZE; j++)
        {
            if (Playing_field[i][j] == -1) open[i][j] = true;
        }
    }
}
 
void final(bool loser, int **Playing_field, bool ** open, const int SIZE)
{
    system("cls");
    print_array_2D(Playing_field, open, SIZE);
    if (loser)
    {
        cout << "ВЫ ПРОИРАЛИ!(";
    }
    else
    {
        cout << "ВЫ ВЫИГРАЛИ!)";
    }
    cout << endl;
}
void inputSize(int &size)   //запрос на ввод колиство элементов массива
{
    while (true)
    {
        cout << "ВВЕДИТЕ РАЗМЕР ПОЛЯ (10):" << endl << endl;
        cin >> size;
        if (cin.fail())
        {
            cout << "ОШИБКА, ВВЕДИТЕ МЕНЬШЕЕ ЗНАЧЕНИЕ" << endl;
            cin.clear();
            while (cin.get() != '\n');
        }
        else if (size > 0) break;
    }
}
 
//  2
void rules()
{
    cout << "\t\t\t\t\t\t\t\tСАПЕР: ПРАВИЛА И ОБЩИЕ СВЕДЕНИЯ" << endl << endl << endl << endl;
    cout << "\tНачните с открытия одной ячейки." << endl;
    cout << "\tЧисло в ячейке показывает, сколько мин скрыто вокруг данной ячейки. Это число поможет понять вам, где находятся безопасные ячейки, а где находятся бомбы." << endl;
    cout << "\tЕсли рядом с открытой ячейкой есть пустая ячейка, то она откроется автоматически." << endl;
    cout << "\tЕсли вы открыли ячейку с миной, то игра проиграна." << endl;
    cout << "\tЕсли в ячейке указано число, оно показывает, сколько мин скрыто в восьми ячейках вокруг данной. Это число помогает понять, где находятся безопасные ячейки." << endl;
    cout << "\tИгра продолжается до тех пор, пока вы не откроете все не заминированные ячейки." << endl << endl << endl;
    cout << "\tУдачной игры!)" << endl << endl << endl << endl << endl << endl;
}
 
 
 
 
 
 
 
int main()
{
    srand((unsigned int)time(NULL));
    setlocale(LC_ALL, "Russian");
 
    char choice{};
    while (true)
    {
        system("cls");
        cout << "1 - ИГРАТЬ " << endl;
        cout << "2 - ПРАВИЛА ИГРЫ << САПЕР >> " << endl;
        cout << "0 - ВЫХОД" << endl << endl << endl;
        cout << "СДЕЛАЙТЕ ВАШ ВЫБОР:" << endl << endl;
        cin >> choice;
        cout << endl;
        cin.ignore(100, '\n');
        if (choice == '0') break;
        switch (choice)
        {
        case '1':
        {
 
            int SIZE = 0;
            inputSize(SIZE);
            int **Playing_field = new int *[SIZE];
            bool **open = new bool *[SIZE];
 
            for (int i = 0; i < SIZE; i++)
            {
                *(Playing_field + i) = new int[SIZE];
            }
            for (int i = 0; i < SIZE; i++)
            {
                *(open + i) = new bool[SIZE];
            }
            int i{};
            int j{};
            for (int c = 0; c < 100; c++)
            {
                Playing_field[c / 10][c % 10] = 0;
                open[c / 10][c % 10] = false;
            }
            // заполняем массив поля минами
            for (int c = 0; c < BOOM; c++)
            {
                do
                {
                    i = rand() % SIZE;
                    j = rand() % SIZE;
                } 
                while (Playing_field[i][j] != 0);
                Playing_field[i][j] = -1;
            }
            // заполняем массив поля цифрами
            for (i = 0; i < SIZE; i++)
            {
                for (j = 0; j < SIZE; j++)
                {
                    if (Playing_field[i][j] != -1)
                    {
                        int quantity{};
                        if (mine(Playing_field, i - 1, j - 1, SIZE)) quantity++;
                        if (mine(Playing_field, i - 1, j, SIZE)) quantity++;
                        if (mine(Playing_field, i - 1, j + 1, SIZE)) quantity++;
                        if (mine(Playing_field, i, j - 1, SIZE)) quantity++;
                        if (mine(Playing_field, i, j + 1, SIZE)) quantity++;
                        if (mine(Playing_field, i + 1, j - 1, SIZE)) quantity++;
                        if (mine(Playing_field, i + 1, j, SIZE)) quantity++;
                        if (mine(Playing_field, i + 1, j + 1, SIZE)) quantity++;
                        Playing_field[i][j] = quantity;
                    }
                }
            }
            while (true)
            {
                system("cls");
                cout << "*****************************" << endl << endl;
                cout << "* САПЕР ОШИБАЕТЬСЯ ОДИН РАЗ *" << endl << endl;
                cout << "*****************************" << endl;
                cout << endl << endl;
                print_array_2D(Playing_field, open, SIZE);
                cout << endl;
                // запрашиваем координаты удара
                char input_coordinate[4]{ '\0' };
                cout << "Введите координаты удара (E7): ";
                cin >> input_coordinate;
                
                if ((input_coordinate[0] >= 65) && (input_coordinate[0] <= 90))
                {
                    j = input_coordinate[0] - 65;        // буква в промежутке от A до Z
                }
                else if ((input_coordinate[0] >= 97) && (input_coordinate[0] <= 122))
                {
                    j = input_coordinate[0] - 97;  // буква в промежутке от a до z
                }
                else continue;                              // если введены неверные значения, возврат в начало цикла
                if ((input_coordinate[1] >= 48) && (input_coordinate[0] <= 57))     //переводим координаты в цифровой вид от 0 до 9
                {
                    i = input_coordinate[1] - 48;
                }
                else continue;
                // далее проверяем все восемь окрестных полей на пустые клетки показываем некий кусок поля               
                clean(Playing_field, open, i, j, SIZE);
                if (mine(Playing_field, i, j, SIZE))
                {
                    openmines(Playing_field, open, SIZE); 
                    final(true, Playing_field, open, SIZE); break;
                }
                if (win_or_lose(Playing_field, open, SIZE))
                {
                    final(false, Playing_field, open, SIZE); break;
                }
            }
            for (int i = 0; i < SIZE; i++)
            {
                delete[] * (Playing_field + i);
            }
            for (int i = 0; i < SIZE; i++)
            {
                delete[] * (open + i);
            }
            //delete[] Playing_field;
        }
        break;
 
        case '2':
        {
            rules();
        }
        break;
 
        default: cout << "Ошибка, попробуйте еще раз, нажмите кнопку <Enter>, чтобы повторить попытку" << endl; break;
        }
        system("pause");
    }
    return 0;
}

Тут ветка форума про С++!

#include <iostream>
#include <time.h>
#include <stdio.h>
using namespace std;
 
#define N 26    //рамер поля
#define BOOM 10 //количество бомб на поле
 
int** Playing_field = nullptr;
bool** open = nullptr;
 
void createIntArr(int**& Playing_field)
{
    Playing_field = new int*[N];
    for (int i = 0; i < N; i++)
    {
        *(Playing_field + i) = new int[N] {};
    }
}
void createBoolArr(bool**& open)
{
    open = new bool*[N] {};
    for (int i = 0; i < N; i++)
    {
        *(open + i) = new bool[N] {};
    }
}
void deleteIntArr(int** Playing_field)
{
    for (int i = 0; i < N; i++)
    {
        delete[] * (Playing_field + i);
    }
    delete[] Playing_field;
    Playing_field = nullptr;
}
void deleteBoolArr(bool** open)
{
    for (int i = 0; i < N; i++)
    {
        delete[] * (open + i);
    }
    delete[] open;
    open = nullptr;
}
 
void rules();
void show_of_mines();
void openmines();
bool empty(int, int);
bool mine(int, int);
void print_array_2D();
void clean(int, int);
bool win_or_lose();
void final(bool);
 
int main()
{
    srand((unsigned int)time(NULL));
    setlocale(LC_ALL, "Russian");
 
    char choice{};
    while (true)
    {
        system("cls");
        cout << "САПЕР " << endl << endl << endl;
 
        cout << "1 - ИГРАТЬ " << endl;
        cout << "2 - ПРАВИЛА ИГРЫ << САПЕР >> " << endl;
        cout << "0 - ВЫХОД" << endl << endl << endl;
        cout << "СДЕЛАЙТЕ ВАШ ВЫБОР:" << endl << endl;
        cin >> choice;
        cout << endl;
        cin.ignore(100, '\n');
        if (choice == '0') break;
        switch (choice)
        {
        case '1':
        {
            createIntArr(Playing_field);
            createBoolArr(open);
            int i{};
            int j{};
            for (i = 0; i < 10; i++) // заполнение 0-ми
            {
                for (j = 0; j < 10; j++) // заполнение 0-ми
                {
                    *(*(Playing_field + i) + j) = 0;
                    *(*(open + i) + j) = false;
                }
            }
            for (int c = 0; c < BOOM; c++) // заполнение минами
            {
                do
                {
                    i = rand() % N;
                    j = rand() % N;
                }
                while (*(*(Playing_field + i) + j) != 0);
                *(*(Playing_field + i) + j) = -1;
            }
            for (i = 0; i < N; i++) // заполнение подсказками
            {
                for (j = 0; j < N; j++)
                {
                    if (*(*(Playing_field + i) + j) != -1)
                    {
                        int quantity{};
                        if (mine(i - 1, j - 1)) quantity++;
                        if (mine(i - 1, j)) quantity++;
                        if (mine(i - 1, j + 1)) quantity++;
                        if (mine(i, j - 1)) quantity++;
                        if (mine(i, j + 1)) quantity++;
                        if (mine(i + 1, j - 1)) quantity++;
                        if (mine(i + 1, j)) quantity++;
                        if (mine(i + 1, j + 1)) quantity++;
                        Playing_field[i][j] = quantity;
                    }
                }
            }
            while (true)
            {
                system("cls");
                cout << "*****************************" << endl << endl;
                cout << "* САПЕР ОШИБАЕТЬСЯ ОДИН РАЗ *" << endl << endl;
                cout << "*****************************" << endl;
                cout << endl << endl;
                print_array_2D();
                cout << endl;
 
 
                // запрашиваем координаты удара
                char input_coordinate[3]{ '\0' };
                cout << "Введите координаты удара (E7): ";
                cin >> input_coordinate;
                // переводим координаты в цифровой вид
                if ((input_coordinate[0] >= 65) && (input_coordinate[0] <= 74))
                {
                    j = input_coordinate[0] - 65;        // буква в промежутке от A до J
                }
                else if ((input_coordinate[0] >= 97) && (input_coordinate[0] <= 106))
                {
                    j = input_coordinate[0] - 97;  // буква в промежутке от a до j
                }
                else continue;                              // если введены неверные значения, возврат в начало цикла
                if ((input_coordinate[1] >= 48) && (input_coordinate[1] <= 57))
                {
                    i = input_coordinate[1] - 48;
                }
                else continue;
 
 
                // далее проверяем все восемь окрестных полей на пустые клетки показываем некий кусок поля               
                clean(i, j);
                if (mine(i, j))
                {
                    openmines();
                    final(true);
                    break;
                }
                if (win_or_lose())
                {
                    final(false);
                    break;
                }
            }
            deleteBoolArr(open);
            deleteIntArr(Playing_field);
        }
        break;
 
        case '2':
        {
            rules();
            system("pause");
        }
        break;
 
        default:
        {
            cout << "Ошибка, попробуйте еще раз, нажмите кнопку <Enter>, чтобы повторить попытку" << endl;
            break;
        }
        system("pause");
        }
    }
    return 0;
}
 
 
//  2
void rules()
{
    cout << "\t\t\t\t\t\t\t\tСАПЕР: ПРАВИЛА И ОБЩИЕ СВЕДЕНИЯ" << endl << endl << endl << endl;
    cout << "\tНачните с открытия одной ячейки." << endl;
    cout << "\tЧисло в ячейке показывает, сколько мин скрыто вокруг данной ячейки. Это число поможет понять вам, где находятся безопасные ячейки, а где находятся бомбы." << endl;
    cout << "\tЕсли рядом с открытой ячейкой есть пустая ячейка, то она откроется автоматически." << endl;
    cout << "\tЕсли вы открыли ячейку с миной, то игра проиграна." << endl;
    cout << "\tЕсли в ячейке указано число, оно показывает, сколько мин скрыто в восьми ячейках вокруг данной. Это число помогает понять, где находятся безопасные ячейки." << endl;
    cout << "\tИгра продолжается до тех пор, пока вы не откроете все не заминированные ячейки." << endl << endl << endl;
    cout << "\tУдачной игры!)" << endl << endl << endl << endl << endl << endl;
}
//  1
void print_array_2D()
{
 
 
    char strLetters[30] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\0' };
    cout << "  ";
    for (int i = 0; i < N; i++)
    {
 
        cout << " " << strLetters[i];
    }
    cout << endl;
 
    for (int x = 0; x < N; x++)
    {
        if (x < 10)
        {
            cout << x << " |";
        }
        else
        {
            cout << x << "|";
        }
 
        for (int y = 0; y < N; y++)
        {
            if (open[x][y])
            {
 
                if (Playing_field[x][y] == -1)
                {
                    show_of_mines();
                }
                else if (Playing_field[x][y] == 0)
                {
                    show_of_mines();
                }
                else
                {
                    cout << Playing_field[x][y] << " ";
                }
            }
            else
            {
                cout << "& ";
            }
        }
        cout << "\n";
    }
}
 
void show_of_mines()
{
    cout << "* ";
}
// рекурсивная функция, которая открывает поля в точке попадания
void clean(int i, int j)
{
    if ((i >= 0) && (i<N))
    {
        if ((j >= 0) && (j<N))
        {
            if (!open[i][j])
            {
                open[i][j] = true;
                if (Playing_field[i][j] == 0)
                {
 
                    //clean(i - 1, j - 1);
                    clean(i - 1, j);
                    //clean(i - 1, j + 1);
                    clean(i, j - 1);
                    clean(i, j + 1);
                    //clean(i + 1, j - 1);
                    clean(i + 1, j);
                    //clean(i + 1, j + 1);
                }
            }
        }
    }
}
 
// проверяет ячейку на пустоту (true), выход за пределы массива возвращает false
bool empty(int i, int j)
{
    if ((i >= 0) && (i<N))
    {
        if ((j >= 0) && (j<N))
        {
            if (*(*(Playing_field + i) + j) == 0) return true;
        }
    }
    return false;
}
 
// проверяет ячейку на мину ; выход за пределы возвращает false
bool mine(int i, int j)
{
    if ((i >= 0) && (i<N))
    {
        if ((j >= 0) && (j<N))
        {
            if (*(*(Playing_field + i) + j) == -1) return true;
        }
    }
    return false;
}
 
bool win_or_lose()
{
    for (int x = 0; x < N; x++)
    {
        for (int y = 0; y < N; y++)
        {
            if ((*(*(Playing_field + x) + y) != -1) && (!*(*(open + x) + y))) return false;
        }
    }
    return true;
}
 
// в случае проигрыша эта функция откроет все мины
void openmines()
{
    for (int i = 0; i<N; i++)
    {
        for (int j = 0; j<N; j++)
        {
            if (*(*(Playing_field + i) + j) == -1) *(*(open + i) + j) = true;
        }
    }
}
 
void final(bool loser)
{
    system("cls");
 
    print_array_2D();
    if (loser)
    {
        cout << "\a" << endl;
        cout << "ВЫ ПРОИРАЛИ!(" << endl << endl;
    }
    else
    {
        cout << "\a" << endl;
        cout << "ВЫ ВЫИГРАЛИ!)" << endl << endl;
    }
    system("pause");
    cout << endl << endl;
}

int main()
{
    return 0;
}

///----------------------------------------------------------------------------|
/// Консольный сапер.
/// Version 0.4.1
/// (нужен тест!)
///----------------------------------------------------------------------------:
#include <iostream>
#include <time.h>
#include <stdio.h>
//#include <cstdlib> atoi()
#include <conio.h>
using namespace std;
 
#define FORi(n)  for (int i = 0; i < n; ++i)
#define FORj(n)  for (int j = 0; j < n; ++j)
#define LOG(v)   Log (#v, v)
#define ENDL(v)  FORi(v)std::cout << "\n"
#define DEBUG(v) Log ("DEBUG: signal!", v); _getch();
 
const char* mode_win_for_base = "mode 64,48";
const char* mode_win_for_help = "mode 64,36";
struct smystart
{   smystart()
    {   setlocale(0, "");
        system(mode_win_for_base);
        srand((unsigned int)time(NULL));
    }
}mystart;
 
 
template<class T1, class T2>
void Log(T1 s, T2 v)
{   std::cout << s << " = " << v << "\n";
}
template<class T>
void Log(T v)
{   std::cout << v << "\n";
}
///----------------------------------------------------------------------------|
/// Двумерный динамический массив инкапсулированный в структуре.
///----------------------------------------------------------------------------:
template<class T>
class carr
{
public:
    carr(int _r, int _c) : arr(NULL), row(_r), column(_c)
    {   arr = create_arr(row, column);
    }
    
    carr() : arr(NULL), row(0), column(0)
    {   
    }
    
    carr(carr& _arr) : arr(NULL), row(0), column(0)
    {   resize(_arr.row, _arr.column);
        FORi(row)
            FORj(column)
                arr[i][j] = _arr[i][j];
    }
    
    carr(carr&& _arr) : arr(NULL), row(0), column(0)
    {   
    }
    
   ~carr()
    {   delete_arr(arr);
    }
    
    //------------------------------------------------------resize(int r, int c)
    void resize(int _r, int _c)
    {   
        if(arr != NULL) 
        {   
            delete_arr   (arr);
        }
        row    = _r;
        column = _c;
        arr = create_arr(row, column);
    }
    
    //-----------------------------------------------------------init_one(T val)
    void init_one(T _val)
    {   if(arr == NULL)
        {   std::cout << "Нет массива!\n";
            return;
        }
        FORi(row)
            FORj(column)
                arr[i][j] = _val;
    }
    
    int row_()
    {   return row;
    }
    int column_()
    {   return column;
    }
    
    //-------------------------------------------------------------------show():
    void show()
    {   //info();
        if(arr == NULL)
        {   std::cout << "Нет массива!\n";
            return;
        }
        FORi(row)
        {   FORj(column)
            {   std::cout << arr[i][j];
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
    void info()
    {   Log(__FUNCTION__);
        LOG(row);
        LOG(column);
        LOG(arr);
        std::cout << "\n";
    }
    //-------------------------------------------Форматированный вывод на экран:
    void show_format()
    {   
    }
    
    T*  operator[](const int i)const  //noexcept
    {   return arr[i];
    }
 
    carr<T>& operator=(carr<T>& rhs) //noexcept ///-------------copy assignment:
    {   Log("copy assignment");
        if (this != &rhs)
        {   carr<T> tmp(rhs);
            swap (*this, tmp);
        }
        return *this;
    }
 
    carr<T>& operator=(carr<T>&& rhs) //noexcept ///------------move assignment:
    {   Log("move assignment");
        swap (*this, rhs);
        return *this;
    }
    
    void init_rand(int border_start, int border_end = 0)
    {   if(arr == NULL)
        {   std::cout << "Нет массива!\n";return;
        }
        if (border_start > border_end) std::swap(border_start, border_end);
        FORi(row)
            FORj(column)
                arr[i][j] = rrand(border_end, border_start);
    }
    
    static int rrand(int range_max, int range_min = 0)
    {   return rand() % (range_max - range_min + 1) + range_min;
    }
    
protected:
    T** arr;
    int row, column;
    
    //--------------------------------------------------------------create_arr()
    T** create_arr(int r, int c)
    {   //LOG(__PRETTY_FUNCTION__);
        T** _arr;
        _arr = new T*[r];
        FORi(r)
        {   _arr[i] = new T[c];
        }
        return _arr;
    }
    
    //--------------------------------------------------------------delete_arr()
    void delete_arr(T**& p)
    {   
        FORi(row)
        {   delete[] p[i];
        }
        delete[] p;
        p = NULL;
    }
    
    friend void swap (carr<T>& l, carr<T>& r) //noexcept
    {   using std::swap;
        swap (l.arr ,    r.arr);
        swap (l.row ,    r.row);
        swap (l.column , r.column);
    }
};
 
typedef  const char* CCR;
void rules          ();
void show_of_mines  ();
void openmines      ();
bool empty  (int, int);
bool is_mine(int, int);
void print_array_2D ();
void clean  (int, int);
bool is_win         ();
bool final      (bool);
void pause       (CCR);
void is_find_mine   ();
 
template<class T>
T input_user(const char* promt)
{   std::cout << promt << " ";
    T my;
        
    while(!(std::cin>>my) || std::cin.get() != '\n')
    {   std::cout << "Incorrect input!";
        std::cin.clear();
        std::cin.sync();
    }
    return my;
}
 
///----------------------------------------------------------------------------|
/// Глобалы.
///----------------------------------------------------------------------------:
const int SIZEE = 12; // Рамер поля по дефолту.
const int Bomba =  9; // Чтоб не тратиься на форматировние :)
 
carr<int>  Playing_field;
carr<bool> openn        ;
int        its_my_lifes ;
int        myrating     ;
int        prize        ;
int        steps        ;
 
 
class cConfig
{
public:
    cConfig() : NRow(SIZEE), NCol(SIZEE), BOOM(10)
    {   
    }
 
    int NRow, NCol;
    int BOOM;
 
    void init_start()
    {   NRow = SIZEE;
        NCol = SIZEE;
    
        Playing_field.resize(NRow, NCol);
        Playing_field.init_one       (0);
 
        openn.resize        (NRow, NCol);
        openn.init_one           (false);
 
        its_my_lifes = 3;
        myrating     = 0;
        prize        = 5;
        steps        = 0;
    }
}config;
 
int& NRow = config.NRow;
int& NCol = config.NCol;
int& BOOM = config.BOOM; // Количество бомб на поле.
 
 
///----------------------------------------------------------------------------|
/// GUI
///----------------------------------------------------------------------------:
class cGui_03
{
    carr<int>&  mi;
    carr<bool>& mb;
    cConfig&   cfg;
 
public:
    cGui_03(carr<int>& i, carr<bool>& b, cConfig& c) : mi(i), mb(b), cfg(c)
    {
    }
    
    void work()
    {   
        while(true)
        {   system("cls");
            cout << " Настройки\n\n\n"
                 << " 1 - РАЗМЕР ПОЛЯ.\n"
                 << " 2 - Количество БОМБ.\n"
                 << " ...\n"
                 //////////////////////
                 << " 0 - ВЫХОД.\n\n\n";
            char choice = 0;
            choice = input_user<char>(" СДЕЛАЙТЕ ВАШ ВЫБОР: "); ENDL(2);
            if(choice == '0') return;
 
            switch (choice)
            {   case '1':
                {
                    int   x = 0;
                    int   y = 0;
                    bool  b = true;
                    while(b)
                    {
                        x = input_user<int>(" Введите ШИРИНУ  поля: ");
                        b = (x < 4) || (x > 25);
                     if(b) continue;
                        y = input_user<int>(" Введите ВЫСОТУ поля: ");
                        b = (y < 4) || (y > 35);
                    }
                    mi.resize(x, y);
                    mb.resize(x, y);
                    cfg.NCol = x;
                    cfg.NRow = y;
                }
                break;
 
                case '2':
                    cfg.BOOM = input_user<int>(" Введите кол-во БОМБ: ");
                break;
 
                case '0':
                return;
 
                default:
                    ;
            }
        }
    }
}gui_03(Playing_field, openn, config);
 
void test_class_cGui_03(carr<int>& i, carr<bool>& b)
{   Log("test_class_cGui_03()");
    cGui_03 gui(i, b, config);
            gui.work();
    pause   ("Тест закончен!\n\n");
}
 
///--------------------------|
/// Тест всех классов.       |
///--------------------------:
void test_all()
{
    //test_class_cGui_03(Playing_field, openn);
}
///----------------------------------------------------------------------------|
/// main()
///----------------------------------------------------------------------------:
int main()
{   test_all();
    config.init_start();
 
    char choice;
    while (true)
    {   choice = 0;
        system("cls");
        cout << " САПЕР\n\n\n"
             << " 1 - ИГРАТЬ. \n"
             << " 2 - ПРАВИЛА ИГРЫ << САПЕР. >> \n"
             << " 3 - НАСТРОЙКИ. >> \n"
             << " 0 - ВЫХОД.\n\n\n";
 
           choice = input_user<char>(" СДЕЛАЙТЕ ВАШ ВЫБОР: "); ENDL(2);
        if(choice == '0') break;
 
        switch (choice)
        {   
            ///----------------------------------------------------------------|
            /// ИГРАТЬ.     |
            ///----------------------------------------------------------------:
            case '1':
            {   
start:          Playing_field.init_one (0);
                openn.init_one (false);
                
                ///------------------------|
                /// Заполнение минами.     |
                ///------------------------:
                int i,j;
 
                for (int c = 0; c < BOOM; c++)
                {   do
                    {   i = rand() % NRow;
                        j = rand() % NCol;
                    }
                    while (Playing_field[i][j] != 0);
                    Playing_field[i][j] = Bomba;
                }
 
//Playing_field[0][0] = Bomba;
//Playing_field[3][3] = Bomba;
 
                ///------------------------|
                /// Заполнение подсказками.|
                ///------------------------:
                FORi(NRow)
                {   FORj(NCol)
                    {   if (Playing_field[i][j] != Bomba)
                        {   int quantity = 0;
                            if (is_mine(i - 1, j - 1)) quantity++;
                            if (is_mine(i - 1, j    )) quantity++;
                            if (is_mine(i - 1, j + 1)) quantity++;
                            if (is_mine(i, j - 1    )) quantity++;
                            if (is_mine(i, j + 1    )) quantity++;
                            if (is_mine(i + 1, j - 1)) quantity++;
                            if (is_mine(i + 1, j    )) quantity++;
                            if (is_mine(i + 1, j + 1)) quantity++;
                            Playing_field[i][j]  =  quantity;
                        }
                    }
                }
                    
                while (true)
                {   system("cls");
                    cout << "*****************************\n"
                         << "* САПЕР ОШИБАЕТСЯ  ОДИН РАЗ *\n"
                         << "*****************************\n";
                    ENDL(3);
                    print_array_2D();
                    ENDL(1);
 
                    if(steps == 5)
                    {   steps = 0;
                        prize += 5;
                    }
                    std::cout << "\n\nМои жизни: " << its_my_lifes;
                    std::cout <<   "\nОчки     : " << myrating     << "\n\n";
 
Log("Я читер!");
Playing_field.show();
 
                    ///-----------------------------|
                    ///запрашиваем координаты удара.|
                    ///-----------------------------:
                    char input_coordinate[4] = {0};
                    cout << "Введите координаты удара (E7): ";
                    std::cin.clear();
                    std::cin.sync();
                    cin.get(input_coordinate, 4, '\n');
 
                int i, j;
                // Переводим координаты в цифровой вид ------------------------:
                j = (unsigned int)input_coordinate[0];
                if(j < 90 ) j = j - 65; // буква в промежутке от A до Z [65- 90]
                else        j = j - 97; // буква в промежутке от a до z [97-122]
 
                i = (input_coordinate[1] - 48);
                if(input_coordinate[2]) i = i *10 +(input_coordinate[2] - 48);
/*
///==================|
/// Отладочный код.  |
///------------------:
Log("\nDEBUGER:\n");
LOG(input_coordinate);
LOG(j);
LOG(i);
pause("дальше\n");
///==================|
*/
                if ((0 > j) && (j > NCol))
                {   std::cout << "Не пытайтесь жульничать!"; LOG(j);
                    _getch();
                    continue;
                }
                //i = atoi(input_coordinate+1);
                if( 0 > i  && i > NRow)
                {   std::cout << "Не пытайтесь жульничать!"; LOG(i);
                    _getch();
                    continue;
                }
                ///--------------
                /// Ход принят! |
                ///-------------:
                steps++;
 
                    ///--------------------------------------------------------|
                    /// Показываем окрестный кусок поля c пустыми клетками.    |
                    ///--------------------------------------------------------:
                    clean(i, j);
 
                    if (is_mine(i, j))
                    {   openmines();
                        
                        its_my_lifes--;
                        myrating  -= 5;
 
                        if(final(true))
                        {   prize = 5;
                            steps = 0;
                            goto start;
                        }
 
                        if(its_my_lifes == 0)
                        {   break;        /// Проигрыш!
                        }
                    }
                    else
                    {   if (is_win())
                        {   final(false); /// Выигрыш!
                            break;
                        }
                    }
 
                    is_find_mine();
                } /// loop
            }
            break;
 
            case '2':
            {   rules();
            }
            break;
                
 
            case '3':
            ////////////////////////////////////////////////////////////////////
            gui_03.work();
            ////////////////////////////////////////////////////////////////////
            break;
 
            default:
            {   cout <<
"Ошибка, попробуйте еще раз, нажмите кнопку <Enter>, чтобы повторить попытку" <<
                endl;
                break;
            }
            system("pause");
        }
    }
    return 0;
}
 
void rules()
{   system(mode_win_for_help);
    cout << "\t\t\t\t\t\t\t\tСАПЕР: ПРАВИЛА И ОБЩИЕ СВЕДЕНИЯ\n\n\n\n";
    cout << "\tНачните с открытия одной ячейки.\n"
         << "\tЧисло в ячейке показывает, сколько мин скрыто вокруг\n"
         << " данной ячейки. Это число поможет понять вам, где находятся\n"
         << " безопасные ячейки, а где находятся бомбы.\n\n";
         
    cout << "\tЕсли рядом с открытой ячейкой есть пустая ячейка,\n"
         << " то она откроется автоматически.\n\n";
    
    cout << "\tЕсли вы открыли ячейку с миной, то игра проиграна.\\nn";
    
    cout << "\tЕсли в ячейке указано число, оно показывает,\n"
         << " сколько мин скрыто в восьми ячейках вокруг данной.\n"
         << " Это число помогает понять, где находятся безопасные ячейки.\n\n";
    
    cout << "\tИгра продолжается до тех пор,\n"
         << " пока вы не откроете все не заминированные ячейки.\n\n\n";
         
    cout << "\tУдачной игры!)\n\n\n\n" << endl;
    
    pause("... продолжить: ENTER");
    system(mode_win_for_base);
}
 
///----------------------------------------------------------------------------|
/// Вывод минного поля на экран.
///----------------------------------------------------------------------------:
#define PRINT(v) FORi(v)std::cout << " "
#include <iomanip>
void print_array_2D()
{   
    char strLetters[30] = {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
    cout << "    ";
    for (int i = 0; i < config.NCol; i++)
    {   cout << " " << strLetters[i];
    }
    cout << endl;
 
    cout << "     ";
    for (int i = 0; i < config.NCol-1; i++)
    {   cout << "--";
    }
    cout << "-\n";
 
    FORi(NRow)
    {   cout << std::setw(3) << i << " |";
        FORj(NCol)
        {   
            if (openn[i][j])
            {   switch(Playing_field[i][j])
                {   case Bomba:
                    show_of_mines();
                    break;
                    
                    case 0:
                    cout << "* ";
                    break;
                    
                    default:
                        cout << Playing_field[i][j] << " ";
                }
            }
            else
            {   cout << "& ";
            }
        }
        cout << "\n";
    }
}
 
void show_of_mines()
{   cout << "* ";
}
///----------------------------------------------------------------|
/// Рекурсивная функция, которая открывает поля в точке попадания. |
///----------------------------------------------------------------:
void clean(int i, int j)
{   if     ((i >= 0) && (i < NRow))
    {   if ((j >= 0) && (j < NCol))
        {   if (!openn[i][j])
            {   openn[i][j] = true;
                if (Playing_field[i][j] == 0)
                {   clean(i - 1, j - 1);
                    clean(i - 1, j    );
                    clean(i - 1, j + 1);
                    clean(i    , j - 1);
                    clean(i    , j + 1);
                    clean(i + 1, j - 1);
                    clean(i + 1, j    );
                    clean(i + 1, j + 1);
                }
            }
        }
    }
}
 
///----------------------------------------------------------------|
/// Проверяет ячейку на пустоту (true),                            |
/// выход за пределы массива возвращает false                      |
///----------------------------------------------------------------:
bool empty(int i, int j)
{   if     ((i >= 0) && (i<NRow))
    {   if ((j >= 0) && (j<NCol))
        {   if (Playing_field[i][j] == 0) return true;
        }
    }
    return false;
}
 
///----------------------------------------------------------------|
/// Проверяет ячейку на мину: выход за пределы возвращает false.   |
///----------------------------------------------------------------:
bool is_mine(int i, int j)
{   if    ((i >= 0) && (i<NRow))
    {   if((j >= 0) && (j<NCol))
        {   if(Playing_field[i][j] == Bomba) return true;
        }
    }
    return false;
}
 
bool is_win()
{   FORi(NRow)
    {   FORj(NCol)
        {   if ((Playing_field[i][j] == Bomba) && !openn[i][j])
                return false;
        }
    }
    return true;
}
 
// в случае проигрыша эта функция откроет все мины
void openmines()
{   FORi(NRow)
    {   FORj(NCol)
        {   if (Playing_field[i][j] == Bomba) openn[i][j] = true;
        }
    }
}
 
///----------------------------------------------------------------------------|
/// true - игра продолжается!
///----------------------------------------------------------------------------:
bool final(bool loser)
{   system("cls");
 
    print_array_2D();
    if (loser)
    {   cout << "\a\n" << "ВЫ ПРОИГРАЛИ...(:\n\n";
        if(its_my_lifes != 0)
        {
            cout << "НО У ВАС ЕЩЁ ЕСТЬ ШАНС!\n\n"
                 << "ОСТАЛОСЬ ЖИЗНЕЙ: " << its_my_lifes << "\n\n";
            pause("продолжить...");
            return true;
        }
        else
        {   cout << "ВЫ ПОКОЙНИК!(:\n\n"
                 << "ЖИЗНЕЙ БОЛЬШЕ НЕТ!\n";
            system("color 47");
        }
    }
    else
    {   cout << "\a\n" << "УРА! ВЫ ВЫИГРАЛИ!)))\n\n";
        system("color 70");
    }
 
    pause("продолжить...");
    system("color 07");
    config.init_start();
    return false;
}
 
///----------------------------------------------------------------------------|
/// Пауза.
///----------------------------------------------------------------------------:
void pause(const char* mess)
{   std::cout << "\nЖмите ENTER " << mess << " ";
    std::cin.clear();
    std::cin.sync();
    _getch();
}
 
///----------------------------------------------------------------------------|
/// Обезвредить мину.
///----------------------------------------------------------------------------:
bool is_open(int i, int j)
{   if    ((i >= 0) && (i<NRow))
    {   if((j >= 0) && (j<NCol))
        {   if(openn[i][j]) return true;
            else            return false;
        }
    }
    return true;
}
 
void is_find_mine()
{   FORi(NRow)
    {   FORj(NCol)
        {   if((!openn[i][j]) && (Playing_field[i][j] == Bomba) &&
                    is_open(i - 1, j - 1) &&
                    is_open(i - 1, j    ) &&
                    is_open(i - 1, j + 1) &&
                    is_open(i    , j - 1) &&
                    is_open(i    , j + 1) &&
                    is_open(i + 1, j - 1) &&
                    is_open(i + 1, j    ) &&
                    is_open(i + 1, j + 1) )
            {   /// Ёлы-палы!!! Тут мина!
                openn[i][j] = true;
                myrating += prize;
            }
        }
    }
}