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

@Vladymyr_2020 · Регистрация: 09.05.2019

Студворк — интернет-сервис помощи студентам

Вожусь уже долго, разобраться с этой консольной игрой, выход за пределы массива,вот мой код:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
#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;
}

@ibse · 29.09.2019, 19:15

Vladymyr_2020,

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
#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 < SIZE*10; 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;
}

@XLAT · 29.09.2019, 20:39

Vladymyr_2020, чуть подкрутил, гляньте, щас вылетает?

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
#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;
}
 
 
 
 
 
 
#include "conio.h"
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 i = 0; i < SIZE; i++)
                    {   for (int j = 0; j < SIZE; j++)
                        {   Playing_field[i][j] = 0;
                                     open[i][j] = 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;
}

Добавлено через 4 минуты
сам код ужасен,
нарушено правило N1 Не повторяйся
и т.д..

@Vladymyr_2020 · 29.09.2019, 20:55 **[ТС]**

Теперь не вылетает, координаты не работают хотя по таблице аски все верно

Добавлено через 2 минуты
XLAT, Теперь не вылетает), координаты не работают хотя по таблице аски все верно, что делать?)

@XLAT · 29.09.2019, 22:10

Сообщение от Vladymyr_2020

координаты не работают

а что? раньше работали???

Добавлено через 22 минуты
Vladymyr_2020, а щас???

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
#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] = {"ABCDEFGHFGHIJKLMNOPQRSTUVWXYZ"};
    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])
            {   switch(Playing_field[x][y])
                {   case -1:
                    show_of_mines();
                    break;
                    
                    case 0:
                    cout << "* ";
                    break;
                    
                    default:
                    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;
}
 
 
 
 
 
 
#include "conio.h"
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];
                    }
 
                    
                    for (int i = 0; i < SIZE; i++)
                    {   for (int j = 0; j < SIZE; j++)
                        {   Playing_field[i][j] = 0;
                                     open[i][j] = false;
                        }
                    }
                    
                    int i, j;
                    // заполняем массив поля минами
                    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 (int i = 0; i < SIZE; i++)
                    {   for (int 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.clear();
                        cin.ignore(100, '\n');
                        cin.get(input_coordinate, 4);
 
                        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 
                        {   std::cout << "Не пытайтесь жульничать!1"; _getch();
                            continue;
                        }
                        
                        i = input_coordinate[1] - 48;
                        if(i < 0  && 9 < i)
                        {   std::cout << "Не пытайтесь жульничать!2";
                            std::cout << i;
                            _getch();
                            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);
                    }
                    delete Playing_field;
                    for (int i = 0; i < SIZE; i++)
                    {   delete[] * (open + i);
                    }
                    delete open;
                }
                break;
 
            case '2':
                {   rules();
                }
                break;
 
            default:
                cout << "Ошибка, попробуйте еще раз, нажмите кнопку <Enter>, чтобы повторить попытку"
                     << endl;
                break;
        }
        system("pause");
    }
    return 0;
}

@Vladymyr_2020 · 30.09.2019, 15:12 **[ТС]**

Да, работает, спасибо большое!)

@Vladymyr_2020 · 01.10.2019, 23:05 **[ТС]**

Чуть до изменял этот код, помогите пожалуйста переписать функцию clean так, чтобы я мог задать размер N до 30 и при этом чтобы координаты работали при любом N(размер поля) правильно и + чтобы еще поля открывались правильно.

+

1. Игра ведется до трех жизней (3 мины).
2. Подсчет очков пользователя:
a) За каждую мину – минус 5 баллов.
b) За открытые «чистые» поля набавляются баллы в следующей последовательности: первые 5 полей – плюс 5 баллов за каждое поле; вторые 5 полей - плюс 10 баллов за каждое поле; третьи 5 полей – плюс 15 баллов за каждое поле и т.д.)
Пожалуйста, помогите реализовать!)
Описание после using namespace std; Буду очень благодарен)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
#include <iostream>
#include <time.h>
#include <stdio.h>
using namespace std;
 
#define N 10    //рамер поля
#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 < 100; i++) // заполнение 0-ми
            {
                for (j = 0; j < 100; 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 <= SIZE; i++)
    {
        
        cout << " " << strLetters[i];
    }   
    cout << endl;
 
 
    for (int x = 0; x < N; x++)
    {
        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;
}

@XLAT · 01.10.2019, 23:11

ок, гляну, чуть позже.
просьба модераторам засунть код под [SPOILER][CPP]

@Vladymyr_2020 · 01.10.2019, 23:15 **[ТС]**

Извините, я немножко дундук, не знаю что значит засунть код под [SPOILER][CPP]

@XLAT · 01.10.2019, 23:16

Сообщение от Vladymyr_2020

помогите пожалуйста переписать функцию

могу помочь переписать весь этот код.
ну это на днях, т.е. небыстро.

имейте ввиду, что вся семантика(то как оно будет работать для юзера) будет реализована на правилах:

Сообщение от Vladymyr_2020

1. Игра ведется до трех жизней (3 мины).
2. Подсчет очков пользователя:
a) За каждую мину – минус 5 баллов.
b) За открытые «чистые» поля набавляются баллы в следующей последовательности: первые 5 полей – плюс 5 баллов за каждое поле; вторые 5 полей - плюс 10 баллов за каждое поле; третьи 5 полей – плюс 15 баллов за каждое поле и т.д.)
Пожалуйста, помогите реализовать!)
Описание после using namespace std; Буду очень благодарен)

если есть неточности, то лучше поправить сразу.
хотя
код надо писать так, чтобы любые изменения делать быстро, приятно и в точку.

я как раз тренируюсь так писать

@Vladymyr_2020 · 01.10.2019, 23:34 **[ТС]**

А так, чтобы добить уже этот код?)
Просто время заканчивается...
Пожалуйста

@XLAT · 01.10.2019, 23:52

Сообщение от Vladymyr_2020

[SPOILER][CPP]

[*CPP]
в этом месте код. звездочки в тегах убрать, тогда теги будут не видны.
[*/CPP]

Сообщение от Vladymyr_2020

А так, чтобы добить уже этот код?)

знаете в чем парадокс,
очень часто разобраться в коде который написать с нарушениями кодостайла(это не только отстутпы, но и ...идиомы и патерны)
бывает сложнее, чем переписать заново.

Сообщение от Vladymyr_2020

Чуть до изменял этот код, помогите пожалуйста переписать функцию clean так, чтобы я мог задать размер N до 30 и при этом чтобы координаты работали при любом N(размер поля) правильно и + чтобы еще поля открывались правильно.

это всё? или еще что-то забыли?

@Vladymyr_2020 · 01.10.2019, 23:59 **[ТС]**

Да, пока это всё
��

@XLAT · 02.10.2019, 00:59

правильно и + чтобы еще поля открывались правильно.

вот в этом месте как раз нужны правила открытия полей.
в сапера никогда не играл: раскладывал пасьянсы я.

@Vladymyr_2020 · 02.10.2019, 10:35 **[ТС]**

Пускай поля открываються так, как они открываются сейчас, главное, чтобы игра велась д 3 жизней, и очки правильно насчитывались и выводились, и чтобы я мог задать размер поля хоть 20 (до 30) и координаты корректно работали))

@XLAT · 02.10.2019, 14:49

Сообщение от Vladymyr_2020

чтобы игра велась д 3 жизней

пока только динамический размер поля.

вот потестите именно по размеру поля.
да и вообще будет ли она у вас запускаться

@XLAT · 02.10.2019, 14:55

смотрите в меню третий пункт

Добавлено через 4 минуты
ограничил таким вот диапазоном

Code
1
2
3
4
5
(" Введите ШИРИНУ  поля: ");
b = (x < 4) || (x > 28);
 
(" Введите ВЫСОТУ поля: ");
b = (y < 4) || (y > 35);

букв по горизонтали 29 поэтому 28

вниз только размер окна мешает: увеличивать можно ~~до бесконечности~~.

@Vladymyr_2020 · 02.10.2019, 15:13 **[ТС]**

Нуу, поле и должно же быть динамическим, не запускается архив, поделайте пожалуйста комментарии на все что вы кодите, могу вам в лс написать свою электронную почту или если можете, скиньте в тхт, я в студию закину и буду тестировать

Добавлено через 2 минуты
то бишь, нужно чтобы я мог задать размер поля от 5 и до 30, и чтобы координаты при этом работали и был счет на жизни)

@XLAT · 02.10.2019, 15:16

Сообщение от Vladymyr_2020

не запускается архив

ок, я хочу знать почему у вас не запускается exe.
компилятор VS2010 флаг /MT

что пишет, или как ведет при запуске?

@Vladymyr_2020 · 02.10.2019, 15:21 **[ТС]**

Дело в том, что я работаю не дома, а в компьютерном классе, и меня нет прав администратора на запуск сторонних приложений(антивирус) ((
И можно сделать так чтобы пользователь задавал 1 размер поля, типо если задал 14, то будет квадратное поле 14*14?)

Новые блоги и статьи Все статьи Все блоги /
Модель заражения группы наркоманов alhaos 17.04.2026 Условия задачи сформулированы тут Суть: - Группа наркоманов из 10 человек. - Только один инфицирован ВИЧ. - Колются одной иглой. - Колются раз в день. - Колются последовательно через. . .	Мысли в слух. Про "навсегда". kumehtar 16.04.2026 Подумалось тут, что наверное очень глупо использовать во всяких своих установках понятие "навсегда". Это очень сильное понятие, и я только начинаю понимать край его смысла, не смотря на то что давно. . .	My Business CRM MaGz GoLd 16.04.2026 Всем привет, недавно возникла потребность создать CRM, для личных нужд. Собственно программа предоставляет из себя базу данных клиентов, в которой можно фиксировать звонки, стадии сделки, а также. . .	Знаешь почему 90% людей редко бывают счастливыми? kumehtar 14.04.2026 Потому что они ждут. Ждут выходных, ждут отпуска, ждут удачного момента. . . а удачный момент так и не приходит.
Фиксация колонок в отчете СКД Maks 14.04.2026 Фиксация колонок в СКД отчета типа Таблица. Задача: зафиксировать три левых колонки в отчете. Процедура ПриКомпоновкеРезультата(ДокументРезультат, ДанныеРасшифровки, СтандартнаяОбработка) / / . . .	Настройки VS Code Loafer 13.04.2026 { "cmake. configureOnOpen": false, "diffEditor. ignoreTrimWhitespace": true, "editor. guides. bracketPairs": "active", "extensions. ignoreRecommendations": true, . . .	Оптимизация кода на разграничение прав доступа к элементам формы Maks 13.04.2026 Алгоритм из решения ниже реализован на нетиповом документе, разработанного в конфигурации КА2. Задачи, как таковой, поставлено не было, проделанное ниже исключительно моя инициатива. Было так:. . .	Контроль заполнения и очистка дат в зависимости от значения перечислений Maks 12.04.2026 Алгоритм из решения ниже реализован на примере нетипового документа "ПланированиеПерсонала", разработанного в конфигурации КА2. Задача: реализовать контроль корректности заполнения дат назначения. . .

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	29.09.2019, 20:55 [ТС]
	Теперь не вылетает, координаты не работают хотя по таблице аски все верно Добавлено через 2 минуты XLAT, Теперь не вылетает), координаты не работают хотя по таблице аски все верно, что делать?) 0

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	30.09.2019, 15:12 [ТС]
	Да, работает, спасибо большое!) 1

@XLAT Just Do It! 4212 / 2671 / 655 Регистрация: 23.09.2014 Сообщений: 9,093 Записей в блоге: 3
	01.10.2019, 23:11
	ок, гляну, чуть позже. просьба модераторам засунть код под [SPOILER][CPP] 1

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	01.10.2019, 23:15 [ТС]
	Извините, я немножко дундук, не знаю что значит засунть код под [SPOILER][CPP] 0

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	01.10.2019, 23:34 [ТС]
	А так, чтобы добить уже этот код?) Просто время заканчивается... Пожалуйста 0

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	01.10.2019, 23:59 [ТС]
	Да, пока это всё �� 0

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	02.10.2019, 10:35 [ТС]
	Пускай поля открываються так, как они открываются сейчас, главное, чтобы игра велась д 3 жизней, и очки правильно насчитывались и выводились, и чтобы я мог задать размер поля хоть 20 (до 30) и координаты корректно работали)) 0

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	02.10.2019, 15:13 [ТС]
	Нуу, поле и должно же быть динамическим, не запускается архив, поделайте пожалуйста комментарии на все что вы кодите, могу вам в лс написать свою электронную почту или если можете, скиньте в тхт, я в студию закину и буду тестировать Добавлено через 2 минуты то бишь, нужно чтобы я мог задать размер поля от 5 и до 30, и чтобы координаты при этом работали и был счет на жизни) 0

@Vladymyr_2020 4 / 4 / 0 Регистрация: 09.05.2019 Сообщений: 72
	02.10.2019, 15:21 [ТС]
	Дело в том, что я работаю не дома, а в компьютерном классе, и меня нет прав администратора на запуск сторонних приложений(антивирус) (( И можно сделать так чтобы пользователь задавал 1 размер поля, типо если задал 14, то будет квадратное поле 14*14?) 0