Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.93/41: Рейтинг темы: голосов - 41, средняя оценка - 4.93
Алексаша
0 / 0 / 1
Регистрация: 30.03.2016
Сообщений: 29
1

Написание игры "Крестики - Нолики"

24.04.2016, 14:43. Просмотров 7918. Ответов 15
Метки нет (Все метки)

Доброго времени суток. Можете пожалуйста посоветовать ресурсы, чтобы можно было получить достаточно знаний, чтобы написать игру крестики нолики( и если не сложно- код с объяснением) . Заранее спасибо
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
24.04.2016, 14:43
Ответы с готовыми решениями:

Создать графический интерфейс (GUI) для игры "Крестики-нолики"
#include <stdio.h> #include <string.h> char board={}; void...

Исправить код игры "Крестики-нолики"
игру 'крестики нолики' с++ с помащу функций пример(не работаєт) #include...

Игра "Крестики нолики", почему не работает проверка окончания?
#include <iostream> using namespace std; int main () { int a,k=0; char...

Игра "Крестики-нолики": правильно выстроить поле
Я очень сильно начинающий программист. Поэтому попрошу сразу не кидатся что я...

Сделать статистику игроков в игре "Крестики-нолики"
Доброго времени суток! Вот, решил для курсовой работы написать игру...

15
zss
Модератор
Эксперт С++
7258 / 6703 / 4244
Регистрация: 18.12.2011
Сообщений: 17,693
Завершенные тесты: 1
24.04.2016, 14:44 2
Посмотрите ссылки внизу страницы. Они все на Вашу тему.
0
Aymurat
24.04.2016, 14:54
  #3

Не по теме:

А поиском воспользоваться?


 Комментарий модератора 
П3.3. Правил
Не отсылайте других пользователей в поиск и избегайте ссылок на поисковые системы (Google, Yandex и др.). Самостоятельно найдите ответ на вопрос и разместите его на форуме.
0
Сарсен
1 / 1 / 3
Регистрация: 20.01.2014
Сообщений: 90
24.04.2016, 15:57 4
Можно посмотреть здесь, Денис Марков объясняет крестики нолики https://www.youtube.com/watch?v=hyFQCH2bndM
0
Алексаша
0 / 0 / 1
Регистрация: 30.03.2016
Сообщений: 29
26.04.2016, 20:18  [ТС] 5
Ну вот, поработал, правда ещё проверки нет. Оцените пожалуйста
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
#include "stdafx.h"
#include <iostream>//стандартная библиотека
 
using namespace std;
 
 
 
int main() 
{
    setlocale(0,"");
    
 
    char cells[9] = {'-','-','-','-','-','-','-','-','-',};
    
    int cell;
    int cell1;
    
     cout << "------------" << "\n" << endl;
    cout << "Номера клеток:" << endl;
    cout << "-" << 1 << "-" << '|' << "-" << 2 << "-" << '|' << "-" << 3 << "-" << " |" << endl;
    cout << "-" << 4 << "-" << '|' << "-" << 5 << "-" << '|' << "-" << 6 << "-" << " |" <<  endl;
    cout << "-" << 7 << "-" << '|' << "-" << 8 << "-" << '|' << "-" << 9 << "-" << " |" << "\n" << endl;
 
 
    cout << "Игровое поле (--- пусто):" << endl;
    cout << "-" << cells[0] << "-" << '|' << "-" << cells[1] << "-" << '|' << "-" << cells[2] << "-" << " |" <<  endl;
    cout << "-" << cells[3] << "-" << '|' << "-" << cells[4] << "-" << '|' << "-" << cells[5] << "-" << " |" <<  endl;
    cout << "-" << cells[6] << "-" << '|' << "-" << cells[7] << "-" << '|' << "-" << cells[8] << "-" << " |" <<  "\n" << endl;
 
    cout << "------------\n" << endl;
 
 
    
    for(int o = 0; o <= 9; ++o){
        cout << "Введите номер клетки, куда ходить  X: ";
        cin >> cell;  
        cells[cell-1] = 'x';
 
        cout << "-" << cells[0] << "-" << '|' << "-" << cells[1] << "-" << '|' << "-" << cells[2] << "-" << " |" <<  endl;
        cout << "-" << cells[3] << "-" << '|' << "-" << cells[4] << "-" << '|' << "-" << cells[5] << "-" << " |" <<  endl;
        cout << "-" << cells[6] << "-" << '|' << "-" << cells[7] << "-" << '|' << "-" << cells[8] << "-" << " |" <<  "\n" << endl;
 
 
 
        cout << "Введите номер клетки, куда ходить 0: ";
        cin >> cell1;
        cells[cell1-1] = '0';
 
        cout << "-" << cells[0] << "-" << '|' << "-" << cells[1] << "-" << '|' << "-" << cells[2] << "-" << " |" <<  endl;
        cout << "-" << cells[3] << "-" << '|' << "-" << cells[4] << "-" << '|' << "-" << cells[5] << "-" << " |" <<  endl;
        cout << "-" << cells[6] << "-" << '|' << "-" << cells[7] << "-" << '|' << "-" << cells[8] << "-" << " |" <<  "\n" << endl;
        
 
    }
    
 
    
 
 
 
    system("pause");
    return 0;
 
 
}
Добавлено через 57 минут
Вот проверка(потом == 'x' заменить на == '0')
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
if((cells[0] == 'x') && (cells[1] == 'x') && (cells[2] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[3] == 'x') && (cells[4] == 'x') && (cells[5] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[6] == 'x') && (cells[7] == 'x') && (cells[8] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[0] == 'x') && (cells[3] == 'x') && (cells[6] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[1] == 'x') && (cells[4] == 'x') && (cells[7] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[2] == 'x') && (cells[5] == 'x') && (cells[8] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[0] == 'x') && (cells[4] == 'x') && (cells[8] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[2] == 'x') && (cells[4] == 'x') && (cells[6] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
0
Ryuk
179 / 177 / 56
Регистрация: 10.06.2011
Сообщений: 871
26.04.2016, 23:58 6
Алексаша, не проще ли победу в 1 иф через "или" в несколько строк?
0
Алексаша
0 / 0 / 1
Регистрация: 30.03.2016
Сообщений: 29
27.04.2016, 19:35  [ТС] 7
Хотелось побольше рутинного кода. Я же только учусь
0
Cetych
6 / 6 / 4
Регистрация: 08.01.2016
Сообщений: 36
27.04.2016, 19:50 8
Алексаша, Так может сразу учится писать оптимизированный код?
0
Fixer_84
1059 / 665 / 655
Регистрация: 30.04.2016
Сообщений: 2,284
01.05.2016, 21:30 9
Алексаша, недавно писал эту игру в консоли. Смотрите код ниже.

Добавлено через 6 минут
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
#include <iostream>
#include <cmath>
#include <cstdlib>
 
using namespace std;
 
int main()
{
const int N = 3;
int x, y, k, dgt;
char A[N][N], c, z;
string s, a, b, name1, name2;
a = "НОЛИКИ";
b = "КРЕСТИКИ";
z = '0';
c = 'X';
cout << "Игра крестики-нолики:" << endl;
cout << "Введите имя первого игрока: ";
getline(cin, name1);
cout << "Введите имя второго игрока: ";
getline(cin, name2);
cout << "За кого ходит первый игрок?(введите цифру):" << endl;
cout << "0: 1" << endl;
cout << "X: 2" << endl;
cout << "Цифра: ";
cin >> dgt;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
A[i][j] = '?';
cout << A[i][j] << " ";
}
cout << endl;
}
for (int i = 0; i < 9; i++)
{
if ((!(i % 2)) && (dgt == 1)) s = a;
if ((!(i % 2)) && (dgt == 2)) s = b;
if ((i % 2) && (dgt == 1)) s = b;
if ((i % 2) && (dgt == 2)) s = a;
mylabel:
cout << "Сделайте ваш ход (" << s << ")" << endl;
cout << "Строка: ";
cin >> x;
cout << "Столбец: ";
cin >> y;
x--;
y--;
if (A[x][y] != '?')
{
system("cls");
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
cout << A[i][j] << " ";
}
cout << endl;
}
cout << "Данная позиция занята!" << endl;
goto mylabel;
}
if ((!(i % 2)) && (dgt == 1)) A[x][y] = z;
if ((!(i % 2)) && (dgt == 2)) A[x][y] = c;
if ((i % 2) && (dgt == 1)) A[x][y] = c;
if ((i % 2) && (dgt == 2)) A[x][y] = z;
system("cls");
k = 0;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
cout << A[i][j] << " ";
}
cout << endl;
}
if (((A[0][0] == '0') && (A[0][1] == '0') && (A[0][2] == '0')) ||
    ((A[1][0] == '0') && (A[1][1] == '0') && (A[1][2] == '0')) ||
    ((A[2][0] == '0') && (A[2][1] == '0') && (A[2][2] == '0')) ||
    ((A[0][0] == '0') && (A[1][0] == '0') && (A[2][0] == '0')) ||
    ((A[0][1] == '0') && (A[1][1] == '0') && (A[2][1] == '0')) ||
    ((A[0][2] == '0') && (A[1][2] == '0') && (A[2][2] == '0')) ||
    ((A[0][0] == '0') && (A[1][1] == '0') && (A[2][2] == '0')) ||
    ((A[2][0] == '0') && (A[1][1] == '0') && (A[0][2] == '0')) ||
    ((A[0][0] == 'X') && (A[0][1] == 'X') && (A[0][2] == 'X')) ||
    ((A[1][0] == 'X') && (A[1][1] == 'X') && (A[1][2] == 'X')) ||
    ((A[2][0] == 'X') && (A[2][1] == 'X') && (A[2][2] == 'X')) ||
    ((A[0][0] == 'X') && (A[1][0] == 'X') && (A[2][0] == 'X')) ||
    ((A[0][1] == 'X') && (A[1][1] == 'X') && (A[2][1] == 'X')) ||
    ((A[0][2] == 'X') && (A[1][2] == 'X') && (A[2][2] == 'X')) ||
    ((A[0][0] == 'X') && (A[1][1] == 'X') && (A[2][2] == 'X')) ||
    ((A[2][0] == 'X') && (A[1][1] == 'X') && (A[0][2] == 'X')))
{
k++;
cout << "Игра закончена! ";
if ((A[x][y] == z) && (dgt == 1)) cout << name1 << " победил(a)!" << endl;
if ((A[x][y] == c) && (dgt == 2)) cout << name1 << " победил(а)!" << endl;
if ((A[x][y] == c) && (dgt == 1)) cout << name2 << " победил(а)!" << endl;
if ((A[x][y] == z) && (dgt == 2)) cout << name2 << " победил(а)!" << endl;
break;
}
}
if (!(k)) cout << "Игра закончилась вничью!" << endl;
system("pause");
return 0;
}
2
Алексаша
0 / 0 / 1
Регистрация: 30.03.2016
Сообщений: 29
03.05.2016, 10:57  [ТС] 10
Большое спасибо
0
Mr.X
Эксперт С++
3180 / 1707 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
03.05.2016, 22:16 11
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
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < T_str     >   T_strings;
typedef T_strings                       T_field_matr;
///////////////////////////////////////////////////////////////////////////////
class   T_xs_and_os
{
    //-------------------------------------------------------------------------
    static  const   int     FIELD_DIM           =   3;
 
    static  const   int     FIELD_SIZE          =       FIELD_DIM
                                                    *   FIELD_DIM;
 
    static  const   int     FIRST_CELL_NUM      =   1;
    static  const   int     LAST_CELL_NUM       =   FIELD_SIZE;
 
    static  const   char    GAME_SYMB_FIRST     =   'X';
    static  const   char    GAME_SYMB_SECOND    =   'O';
    static  const   char    ZERO_SYMB           =   '0';
 
    static  const   char    SPACE_SYMB          =   ' ';
    static  const   char    MINUS_SYMB          =   '-';
    static  const   char    VERTICAL_LINE_SYMB  =   '|';
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    static
    void    play()
    {
        T_field_matr    field_matr
                            (
                                FIELD_DIM,
 
                                T_str   (
                                            FIELD_DIM,
                                            SPACE_SYMB
                                        )
                            );
 
        print_new_game_message  ();
        print_field_matr        ( field_matr    );
 
        for (
                int
                moves_counter   {};
                moves_counter   <   FIELD_SIZE;
                ++moves_counter
            )
        {
            auto    cur_symb    =   get_cur_symb( moves_counter );
 
            input_move
                (
                    cur_symb,
                    field_matr
                );
 
            print_empty_line    ();
            print_field_matr    ( field_matr    );
 
            if  (
                    symb_won_in_matr
                        (
                            cur_symb,
                            field_matr
                        )
                )
            {
                print_win_message_for_symb  ( cur_symb  );
                return;
            }//if
        }//for
 
        print_draw_message  ();
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    static
    void    print_empty_line()
    {
        std::cout   <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    void    print_new_game_message()
    {
        std::cout   <<  "\n\n\n\n\n\n\n\n\n"
                    <<  "NEW GAME:"
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    char    get_cur_symb( int   moves_counter )
    {
        return  moves_counter   %   2   ==  0
                    ?   GAME_SYMB_FIRST
                    :   GAME_SYMB_SECOND;
    }
    //-------------------------------------------------------------------------
    static
    void    input_move
        (
            char                symb,
            T_field_matr    &   field_matr
        )
    {
        int     i   {};
        int     j   {};
 
        do
        {
            for_symb_input_field_matr_indexes
                (
                    symb,
                    i,
                    j
                );
        }
        while   (
                         field_matr[i][j]
                     !=  SPACE_SYMB
                );
 
        field_matr[i][j]    =   symb;
    }
    //-------------------------------------------------------------------------
    static
    bool    symb_won_in_matr
        (
            char                        symb,
            T_field_matr    const   &   field_matr
        )
    {
        T_field_matr    rotated_matr    { field_matr    };
        transp                          ( rotated_matr  );
        reverse_strings                 ( rotated_matr  );
 
        return      symb_won_in_row_or_main_diag_of_matr
                        (
                            symb,
                            field_matr
                        )
 
                ||  symb_won_in_row_or_main_diag_of_matr
                        (
                            symb,
                            rotated_matr
                        );
    }
    //-------------------------------------------------------------------------
    static
    bool    symb_won_in_row_or_main_diag_of_matr
        (
            char                        symb,
            T_field_matr    const   &   field_matr
        )
    {
        T_str   winning_str
                    (
                        FIELD_DIM,
                        symb
                    );
 
        return          std::find
                            (
                                field_matr.begin    (),
                                field_matr.end      (),
                                winning_str
                            )
 
                    !=  field_matr.end()
 
                ||      winning_str
 
                    ==  T_str   {
                                    field_matr[0][0],
                                    field_matr[1][1],
                                    field_matr[2][2]
                                };
    }
    //-------------------------------------------------------------------------
    static
    void    reverse_strings( T_field_matr    &   field_matr )
    {
        std::reverse
            (
                field_matr.begin    (),
                field_matr.end      ()
            );
    }
    //-------------------------------------------------------------------------
    static
    void    transp( T_field_matr    &   field_matr )
    {
        for( size_t  i{}; i < field_matr.size() - 1; ++i )
        {
            for( size_t  j{i + 1}; j < field_matr.size(); ++j )
            {
                std::swap
                    (
                        field_matr[i][j],
                        field_matr[j][i]
                    );
            }//for
        }//for
    }
    //-------------------------------------------------------------------------
    static
    void    print_win_message_for_symb( char    symb )
    {
        std::cout   <<  "'"
                    <<  symb
                    <<  "'"
                    <<  " won."
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    void    print_draw_message()
    {
        std::cout   <<  "Draw."
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    void    print_field_matr( T_field_matr  const   &   field_matr )
    {
        for( size_t  i{}; i < field_matr.size(); ++i )
        {
            print_field_row_of_matr_with_ind
                (
                    field_matr,
                    i
                );
        }//for
    }
    //-----------------------------------------------------------------------------------
    static
    void    print_field_row_of_matr_with_ind
        (
            T_field_matr    const   &   field_matr,
            int                         i
        )
    {
        const   int     SPACES_COUNT_BETWEEN_CELL_BORDER_AND_SYMBOL     =   1;
 
        int             border_horiz_len
 
            =           ( SPACES_COUNT_BETWEEN_CELL_BORDER_AND_SYMBOL + 1 )
                    *   2
                    *   field_matr.size()
                +   1;
 
        T_str   border_horiz    =   T_str   (
                                                border_horiz_len,
                                                MINUS_SYMB
                                            );
 
        if( i   ==  0 )
        {
            std::cout   <<  border_horiz
                        <<  std::endl;
        }
 
        auto    &   field_row  =   field_matr[i];
 
        for( size_t  j{}; j < field_row.size(); ++j )
        {
            print_field_cell_of_row_with_ind
                (
                    field_row,
                    j,
                    SPACES_COUNT_BETWEEN_CELL_BORDER_AND_SYMBOL
                );
        }//for
 
        std::cout   <<  std::endl
                    <<  border_horiz
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    static
    void    print_field_cell_of_row_with_ind
        (
            T_str   const   &   field_row,
            int                 j,
            size_t              spaces_count_between_cell_border_and_symbol
        )
    {
        T_str   spaces_line     (
                                    spaces_count_between_cell_border_and_symbol,
                                    SPACE_SYMB
                                );
 
        if( j   ==  0 )
        {
            std::cout   <<  VERTICAL_LINE_SYMB;
        }
 
        std::cout   <<  spaces_line
                    <<  field_row[j]
                    <<  spaces_line
                    <<  VERTICAL_LINE_SYMB;
    }
    //-----------------------------------------------------------------------------------
    static
    void    for_symb_input_field_matr_indexes
        (
            char        symb,
            int     &   i,
            int     &   j
        )
    {
        int     move_cell_num   {};
        char    digit_symb      {};
 
        for(;;)
        {
            print_move_prompt_for_symb( symb );
            std::cin    >>  digit_symb;
 
            if  (
                    std::isdigit( digit_symb )
                )
            {
                move_cell_num   =       digit_symb
                                    -   ZERO_SYMB;
 
                if  (
                            move_cell_num   >=  FIRST_CELL_NUM
                        &&  move_cell_num   <=  LAST_CELL_NUM
                    )
                {
                    break;
                }//if
            }//if
        }//for
 
        //Так как строки матрицы цифровой клавиатуры расположены по убыванию индекса строки,
        //а матрицы игрового поля - по возрастанию, то делаем реверс по индексу строки
        //матрицы.
 
        int     ind_from_num    =       move_cell_num
                                    -   FIRST_CELL_NUM;
 
        int     i_from_num      =       ind_from_num
                                    /   FIELD_DIM;
 
        i                       =       FIELD_DIM
                                    -   1
                                    -   i_from_num;
 
        j                       =       ind_from_num
                                    %   FIELD_DIM;
    }
    //-------------------------------------------------------------------------
    static
    void    print_move_prompt_for_symb( char    symb )
    {
        std::cout   <<  "Move '"
                    <<  symb
                    <<  "'."
                    <<  std::endl
                    <<  "Enter cell number "
                    <<  FIRST_CELL_NUM
                    <<  ".."
                    <<  LAST_CELL_NUM
                    <<  " on numeric keypad: ";
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        T_xs_and_os::play();
    }
}
0
Hilarior
18 / 17 / 22
Регистрация: 03.05.2016
Сообщений: 105
Завершенные тесты: 1
03.05.2016, 23:05 12
Тебе понравится этот видео-урок
youtube. com/ watch?v=hyFQCH2bndM
0
Mostick
9 / 9 / 3
Регистрация: 19.05.2013
Сообщений: 47
29.05.2016, 06:09 13
Марков хорошо объясняет, ну всегда приятнее делать это самому.

Когда он объяснил поверхностно про функции и сказал что далее будем делать крестики-нолики, сразу же появилось желание сделать самому.

Мозг плавился но за ночь все таки сумел написать. Посмотрев продолжение урока, понял что у меня ужасный код и что Денис все умудрился уместить в 140 строк. Дал себе скидку на то что С++ изучаю неделю и забил на это

Вот сам код если кому интересно. От оценки тоже не откажусь.
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
#include <conio.h>
#include <iostream>
#include <locale.h>
 
using namespace std;
 
int const N = 3;
int Win;
char const P1S = 'X', P2S = '0', NPS = '-';
void Instructions()
{
    cout << "Добро пожаловать в мою первую игру КРЕСТИКИ НОЛИКИ:\n\n";
    cout << "Инструкция:\n\n";
    cout << "1. Игрок A ходит крестиками \'X\' игрок B ходит \'0\' по очереди.\n";
    cout << "1. Побеждает тот, у кого выставленные им символы трижды пересекаются либо по горизонтали, либо по вертикали, либо по диагонали.\n";
    cout << "1. Если тройной комбинации нет, получается ничья!\n\n";
}
void NewGame(char a[N][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            a[i][j] = NPS;
        }
    }
}
bool PlayerTurn(bool a)
{
    if (a)
    {
        return false;
    }
    else
        return true;
}
bool Mistake(int b[2], char a[N][N])
{
    if ((a[b[0]-1][b[1]-1] == P1S) || (a[b[0] - 1][b[1] - 1] == P2S))
    {
        return true;
    }
    else return false;
}
void TextInput(bool a, bool b)
{
    if (a && !b)
    {
        cout << "\nИгрок 1, введите координаты \'" << P1S << "\': ";
    }
    else if(!a && !b)
    {
        cout << "\nИгрок 2, введите координаты \'" << P2S << "\': ";
    }
    if (a && b)
    {
        cout << "\nИгрок 1, вы ошиблись, повторите ввод \'" << P1S << "\': ";
    }
    else if (!a && b)
    {
        cout << "\nИгрок 2, вы ошиблись, повторите ввод \'" << P2S << "\': ";
    }
}
int Input()
{
    int a;
    while (!(cin >> a ) || a <=0 ||a > 3)
    {
        cin.clear();
        while (cin.get() != '\n');
        cout << "Ошибка!!! Повторите ввод: ";
    }
    return a;
}
void GameMap(char a[N][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (a[i][j] != P1S && a[i][j] != P2S)
            {
                a[i][j] = NPS;
            }
        }
    }
    cout << "   1  2  3\n";
    for (int i = 0; i < N; i++)
    {
        cout << i+1 << " ";
        for (int j = 0; j < N; j++)
        {
            cout << "[" << a[i][j] << "]";
        }
        cout << endl;
    }
}
bool InGame(char a[N][N], bool b)
{
    char simbol;
    if (b) simbol = P1S;
    else simbol = P2S;
    bool GameOwer = false;
    Win = 0;
    for (int i = 0; i < N; i++)
    {
        Win = 0;
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[j][i] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            if (a[i][i] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0, j = N - 1; j > 0; i++, j--)
        {
            if (a[i][j] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == P1S || a[i][j] == P2S) Win++;
            }
        }
        if (Win == 9) GameOwer = true;
        else if (Win < 9) Win = 0;
    }
    if (!GameOwer) return true;
    else return false;
}
void Outpoot(char a[N][N])
{
    bool Player1 = true;
    bool GameRuning = InGame(a, Player1);
    while (GameRuning)
    {
        bool OutputMistake = false;
        bool Turn = true;
        int Coordinates[2];
        while (Player1 && Turn)
        {
            Turn = true;
            Instructions();
            GameMap(a);
            TextInput(Player1, OutputMistake);
            Coordinates[0] = Input();
            Coordinates[1] = Input();
            if (!Mistake(Coordinates, a))
            {
                a[Coordinates[0] - 1][Coordinates[1] - 1] = P1S;
                GameRuning = InGame(a, Player1);
                if (GameRuning)
                {
                    Player1 = PlayerTurn(Player1);
                    system("cls");
                    Turn = false;
                }
                else if (!GameRuning) Turn = false;
            }
            else if (Mistake(Coordinates, a))
            {
                OutputMistake = true;
                system("cls");
            }
        }
        while (!Player1 && Turn)
        {
            Turn = true;
            Instructions();
            GameMap(a);
            TextInput(Player1, OutputMistake);
            Coordinates[0] = Input();
            Coordinates[1] = Input();
            if (!Mistake(Coordinates, a))
            {
                a[Coordinates[0] - 1][Coordinates[1] - 1] = P2S;
                GameRuning = InGame(a, Player1);
                if (GameRuning)
                {
                    Player1 = PlayerTurn(Player1);
                    system("cls");
                    Turn = false;
                }
                else if (!GameRuning) Turn = false;
            }
            else if (Mistake(Coordinates, a))
            {
                OutputMistake = true;
                system("cls");
            }
        }
        if (!GameRuning && Win != 9)
        {
            switch (Player1)
            {
            case 1:
            {
                system("cls");
                Instructions();
                GameMap(a);
                cout << "\nПоздравляем! Победил игрок 1.\n";
            }
            break;
            case 0:
            {
                system("cls");
                Instructions();
                GameMap(a);
                cout << "\nПоздравляем! Победил игрок 2.\n";
            }
            break;
            }
        }
        else if (Win == 9)
        {
            system("cls");
            Instructions();
            GameMap(a);
            cout << "\nХо-хо-хо, ничья!!!\n";
        }
    }
}
 
int main()
{
    setlocale(LC_ALL, "RUS");
    bool Retry = true;
    char a;
    while (Retry)
    {
        char Game[N][N];
        Outpoot(Game);
        cout << "\nЖелаете повторить? (y/s): ";
        while (!(cin >> a) || a != 'y' && a != 'n')
        {
            cin.clear();
            while (cin.get() != '\n');
            cout << "Ошибка! Повторите! (y/n): ";
        }
        switch (a)
        {
        case 'y':
        {
            NewGame(Game);
            Retry = true;
            system("cls");
        }
        break;
        case 'n': Retry = false; break;
        }
    }
    return 0;
}
Добавлено через 12 минут
Вот алгоритм победы и ничьей:

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
char simbol;
    if (b) simbol = P1S;
    else simbol = P2S;
    bool GameOwer = false;
    Win = 0;
    for (int i = 0; i < N; i++)
    {
        Win = 0;
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[j][i] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            if (a[i][i] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0, j = N - 1; j > 0; i++, j--)
        {
            if (a[i][j] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == P1S || a[i][j] == P2S) Win++;
            }
        }
        if (Win == 9) GameOwer = true;
        else if (Win < 9) Win = 0;
    }
1
Mr.X
Эксперт С++
3180 / 1707 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
29.05.2016, 08:05 14
Цитата Сообщение от Mostick Посмотреть сообщение
От оценки тоже не откажусь.
Ну, первое - это неудобный ввод. А чем вам мой ввод не понравился, где игровое поле
ассоциируется с цифровой клавиатурой, и для ввода достаточно нажать одну клавишу?

По оформлению программы.
1. В С++ функции должны быть короткими, а функция main - очень короткой.
У вас две функции очень длинные и малопонятные.
2. Код должен быть самодокументируемым. Т.е. читатель не должен расшифровывать ваши
письмена и разгадывать что же делает ваша функция. Функция должна словами, т.е. именами
сущностей понятно и просто рассказывать что она делает.
3. Не следует объявлять несколько переменных в одном объявлении. Каждая переменная должна
объявляться в отдельной строке.
4. Имена переменных должны быть самодокументируемыми, т.е. рассказывать что это за переменная
и для чего она нужна. Что у вас за переменные с именами a и b читателю непонятно и требует
отдельного расследования.
5. Не рекомендуется использовать в выражениях голые цифры. Нужно использовать константы
с самодокументируемыми именами.

Ну и малое количество строк программы - это не показатель ее качества.
Сейчас основным критерием качества программы считается ее понятность. Некоторые
экперты считают, что это даже важнее, чем быстродействие программы и экономия памяти.
0
Mostick
9 / 9 / 3
Регистрация: 19.05.2013
Сообщений: 47
29.05.2016, 14:09 15
Мне ваш ввод понравился даже очень! Он более логичен и понятен любому пользователю.

За советы огромное спасибо! Обязательно их учту!

Добавлено через 5 часов 39 минут
Кстати вот нашел хороший код с книжки с работающим ИИ.

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
// Tic-Tac-Toe 2.0
// Plays the game of tic-tac-toe against a human opponent
// Uses pointers instead of refernces for function parameters
 
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
 
using namespace std;
 
// global constants
const char X = 'X';
const char O = 'O';
const char EMPTY = ' ';
const char TIE = 'T';
const char NO_ONE = 'N';
 
// function prototypes
void instructions();
char askYesNo(string question);
int askNumber(string question, int high, int low = 0);
char humanPiece();
char opponent(char piece);
void displayBoard(const vector<char>* const pBoard);
char winner(const vector<char>* const pBoard);
bool isLegal(const vector<char>* const pBoard, int move);
int humanMove(const vector<char>* const pBoard, char human);
int computerMove(vector<char> board, char computer);
void announceWinner(char winner, char computer, char human);
 
// main function
int main()
{
    int move;
    const int NUM_SQUARES = 9;
    vector<char> board(NUM_SQUARES, EMPTY);
 
    instructions();
    char human = humanPiece();
    char computer = opponent(human);
    char turn = X;
    displayBoard(&board);
 
    while (winner(&board) == NO_ONE)
    {
        if (turn == human)
        {
            move = humanMove(&board, human);
            board[move] = human;
        }
        else
        {
            move = computerMove(board, computer);
            board[move] = computer;
        }
        displayBoard(&board);
        turn = opponent(turn);
    }
 
    announceWinner(winner(&board), computer, human);
 
    return 0;
}
 
// functions
void instructions()
{
    cout << "Welcome to the ultimate man-machine showdown: Tic-Tac-Toe.\n";
    cout << "--where human brain is pit against silicon processor\n\n";
 
    cout << "Make your move known by entering a number, 0 - 8.  The number\n";
    cout << "corresponds to the desired board position, as illustrated:\n\n";
 
    cout << "       0 | 1 | 2\n";
    cout << "       ---------\n";
    cout << "       3 | 4 | 5\n";
    cout << "       ---------\n";
    cout << "       6 | 7 | 8\n\n";
 
    cout << "Prepare yourself, human.  The battle is about to begin.\n\n";
}
 
char askYesNo(string question)
{
    char response;
    do
    {
        cout << question << " (y/n): ";
        cin >> response;
    } while (response != 'y' && response != 'n');
 
    return response;
}
 
int askNumber(string question, int high, int low)
{
    int number;
    do
    {
        cout << question << " (" << low << " - " << high << "): ";
        cin >> number;
    } while (number > high || number < low);
 
    return number;
}
 
char humanPiece()
{
    char go_first = askYesNo("Do you require the first move?");
    if (go_first == 'y')
    {
        cout << "\nThen take the first move.  You will need it.\n";
        return X;
    }
    else
    {
        cout << "\nYour bravery will be your undoing... I will go first.\n";
        return O;
    }
}
 
char opponent(char piece)
{
    if (piece == X)
    {
        return O;
    }
    else
    {
        return X;
    }
}
 
void displayBoard(const vector<char>* const pBoard)
{
    cout << "\n\t" << (*pBoard)[0] << " | " << (*pBoard)[1] << " | " << (*pBoard)[2];
    cout << "\n\t" << "---------";
    cout << "\n\t" << (*pBoard)[3] << " | " << (*pBoard)[4] << " | " << (*pBoard)[5];
    cout << "\n\t" << "---------";
    cout << "\n\t" << (*pBoard)[6] << " | " << (*pBoard)[7] << " | " << (*pBoard)[8];
    cout << "\n\n";
}
 
char winner(const vector<char>* const pBoard)
{
    // all possible winning rows
    const int WINNING_ROWS[8][3] = { { 0, 1, 2 },
    { 3, 4, 5 },
    { 6, 7, 8 },
    { 0, 3, 6 },
    { 1, 4, 7 },
    { 2, 5, 8 },
    { 0, 4, 8 },
    { 2, 4, 6 } };
    const int TOTAL_ROWS = 8;
 
    // if any winning row has three values that are the same (and not EMPTY),
    // then we have a winner
    for (int row = 0; row < TOTAL_ROWS; ++row)
    {
        if (((*pBoard)[WINNING_ROWS[row][0]] != EMPTY) &&
            ((*pBoard)[WINNING_ROWS[row][0]] == (*pBoard)[WINNING_ROWS[row][1]]) &&
            ((*pBoard)[WINNING_ROWS[row][1]] == (*pBoard)[WINNING_ROWS[row][2]]))
        {
            return (*pBoard)[WINNING_ROWS[row][0]];
        }
    }
 
    // since nobody has won, check for a tie (no empty squares left)
    if (count(pBoard->begin(), pBoard->end(), EMPTY) == 0)
        return TIE;
 
    // since nobody has won and it isn't a tie, the game ain't over
    return NO_ONE;
}
 
inline bool isLegal(int move, const vector<char>* pBoard)
{
    return ((*pBoard)[move] == EMPTY);
}
 
int humanMove(const vector<char>* const pBoard, char human)
{
    int move = askNumber("Where will you move?", (pBoard->size() - 1));
    while (!isLegal(move, pBoard))
    {
        cout << "\nThat square is already occupied, foolish human.\n";
        move = askNumber("Where will you move?", (pBoard->size() - 1));
    }
    cout << "Fine...\n";
    return move;
}
 
int computerMove(vector<char> board, char computer)
{
    unsigned int move = 0;
    bool found = false;
 
    //if computer can win on next move, that’s the move to make
    while (!found && move < board.size())
    {
        if (isLegal(move, &board))
        {
            //try move
            board[move] = computer;
            //test for winner
            found = winner(&board) == computer;
            //undo move
            board[move] = EMPTY;
        }
 
        if (!found)
        {
            ++move;
        }
    }
 
    //otherwise, if opponent can win on next move, that's the move to make
    if (!found)
    {
        move = 0;
        char human = opponent(computer);
 
        while (!found && move < board.size())
        {
            if (isLegal(move, &board))
            {
                //try move
                board[move] = human;
                //test for winner
                found = winner(&board) == human;
                //undo move
                board[move] = EMPTY;
            }
 
            if (!found)
            {
                ++move;
            }
        }
    }
 
    //otherwise, moving to the best open square is the move to make
    if (!found)
    {
        move = 0;
        unsigned int i = 0;
 
        const int BEST_MOVES[] = { 4, 0, 2, 6, 8, 1, 3, 5, 7 };
        //pick best open square
        while (!found && i <  board.size())
        {
            move = BEST_MOVES[i];
            if (isLegal(move, &board))
            {
                found = true;
            }
 
            ++i;
        }
    }
 
    cout << "I shall take square number " << move << endl;
    return move;
}
 
void announceWinner(char winner, char computer, char human)
{
    if (winner == computer)
    {
        cout << winner << "'s won!\n";
        cout << "As I predicted, human, I am triumphant once more -- proof\n";
        cout << "that computers are superior to humans in all regards.\n";
    }
 
    else if (winner == human)
    {
        cout << winner << "'s won!\n";
        cout << "No, no!  It cannot be!  Somehow you tricked me, human.\n";
        cout << "But never again!  I, the computer, so swear it!\n";
    }
 
    else
    {
        cout << "It's a tie.\n";
        cout << "You were most lucky, human, and somehow managed to tie me.\n";
        cout << "Celebrate... for this is the best you will ever achieve.\n";
    }
}
1
Alex Kireev
5 / 10 / 1
Регистрация: 21.11.2017
Сообщений: 108
21.11.2017, 21:51 16
Здравствуйте.
Скажите пожалуйста, а как книжка называеться?
0
21.11.2017, 21:51
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
21.11.2017, 21:51

Алгоритм хода компьютера в игре "Крестики-Нолики" на неограниченном поле
Крестики нолики на неограниченном поле

Игра "Крестики-нолики" формат 5х5
Есть данный код игры (позаимствован у юзера Fixer 84), но с массивом 3х3. Нужно...

"Крестики-Нолики": проверка на повтор знака
Помогите сделать проверку повтора знака #include &lt;iostream&gt; #include &lt;locale&gt;...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
16
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.
Рейтинг@Mail.ru