Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > C/C++ > C++ > С++ для начинающих
Войти
Регистрация
Восстановить пароль
Блоги Сообщество Поиск Заказать работу  
 
Рейтинг 4.73/55: Рейтинг темы: голосов - 55, средняя оценка - 4.73
0 / 0 / 0
Регистрация: 08.04.2015
Сообщений: 10

Бот в крестиках-ноликах

22.05.2016, 22:00. Показов 10736. Ответов 5
Метки нет (Все метки)
Студворк — интернет-сервис помощи студентам
Здравствуйте. Суть такова: в код игры крестики- нолики нужно встроить бота, а также добавить третий класс в игру (полагаю, что было бы логичным сделать класс самого бота, но это лишь предположение новичка-нуба в C++). Код игры и бота прилагается, молю о помощи:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//файл main.cpp
#include<iostream>
#include<windows.h>
#include"board.h"
#include"BoardView.h"
 
using namespace std;
 
int main() {
setlocale(LC_ALL,"Rus");
Board b;
View h(&b);
h.StartGame();
  Sleep(2000);
  system("pause");
  return 0;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//Файл board.h
#ifndef _board_h_
#define _board_h_
//Как программа расположенна в памяти,кто ходит,
//кто выграл,что в каждой ячейки.
 
class Board
{
private:
    char b[3][3];
    static int counter;
public:
    Board();
    ~Board();
    bool makeMove(char x,int sign);//метод для занесения хода игрока.
    bool WhoWin(int x);            //Метод для выявления результата игры
    char GetCell(int x,int y);     //метод для вывода конкретной ячейки игрового поля.
    bool sms();                    //вспомогательный метод для вывода инфы про ошибку
};
#endif
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//BoardView.h
#ifndef _BoardView_h_
#define _BoardView_h_
#include "board.h"
//Графический интерфейс, ввод данных
class View
{
 private:
    Board * boar; 
    static int sign;   //Счетчик для определения того, кто ходит (X или O)
    void show();       //Выводит доску
    void star_show();  //Начальное приветствие
 public:
    View(Board * b);
    ~View();
    void StartGame();  //главный метод для взаимодействия с игроками  
};
#endif
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

//board.cpp
#include<iostream>
#include<iomanip>
#include "board.h"
 
using namespace std;
Board::Board()
{
      char c=(char)49;
for(int i=0;i<3;i++)    
    for(int j=0;j<3;j++)
        b[i][j]=c++;
}
Board::~Board()
{}
char Board::GetCell(int x,int y)
{
 return b[x][y];
}
bool Board::makeMove(char x,int sign)
{
bool res=true;
char simvol;
    if (sign==0)
       simvol='x';
    else
       simvol='o';
switch(x)
    {
case('1'):if (b[0][0]!='x'&&b[0][0]!='o'){b[0][0]=simvol;break;} else {res=sms();break;}
case('2'):if (b[0][1]!='x'&&b[0][1]!='o'){b[0][1]=simvol;break;} else {res=sms();break;}
case('3'):if (b[0][2]!='x'&&b[0][2]!='o'){b[0][2]=simvol;break;} else {res=sms();break;}
case('4'):if (b[1][0]!='x'&&b[1][0]!='o'){b[1][0]=simvol;break;} else {res=sms();break;}
case('5'):if (b[1][1]!='x'&&b[1][1]!='o'){b[1][1]=simvol;break;} else {res=sms();break;}
case('6'):if (b[1][2]!='x'&&b[1][2]!='o'){b[1][2]=simvol;break;} else {res=sms();break;}
case('7'):if (b[2][0]!='x'&&b[2][0]!='o'){b[2][0]=simvol;break;} else {res=sms();break;}
case('8'):if (b[2][1]!='x'&&b[2][1]!='o'){b[2][1]=simvol;break;} else {res=sms();break;}
case('9'):if (b[2][2]!='x'&&b[2][2]!='o'){b[2][2]=simvol;break;} else {res=sms();break;}
default:cout<<"Error!\Неверный ввод! Повторите!\n";res=false;
    }
     return res;
}
bool Board::WhoWin(int  sign)                                                                        
{
++counter;                                                                               //00-01-02      
  if((b[0][0]==b[1][1]&&b[0][0]==b[2][2])||(b[0][2]==b[1][1]&&b[0][2]==b[2][0]))         //10-11-12
   {   if (sign==0)                                                                      //20-21-22
        {cout<<"\nВыиграл крестик!\По диагонали!\n";return true;}
          else
        {cout<<"\nВыиграл нолик!\nПо диагонали!\n";return true;}
   }
  if((b[0][0]==b[0][1]&&b[0][0]==b[0][2])||(b[1][0]==b[1][1]&&b[1][0]==b[1][2])||(b[2][0]==b[2][1]&&b[2][0]==b[2][2]))
 {     if (sign==0)
        {cout<<"\nВыиграл крестик!\По горизонтали!\n";return true;}
       else
        {cout<<"\nВыиграл нолик!\nПо горизонтали!\n";return true;}
 }
  if((b[0][0]==b[1][0]&&b[0][0]==b[2][0])||(b[0][1]==b[1][1]&&b[0][1]==b[2][1])||(b[0][2]==b[1][2]&&b[0][2]==b[2][2]))
 {     if (sign==0)
         {cout<<"\nВыиграл крестик!\nПо вертикали!\n";return true;}
       else
         {cout<<"\nВыиграл нолик!\nПо вертикали!\n";return true;}
 }
  if(counter==9){
      cout<<"\nНичья!\n";return true;}
  return false;
}
bool Board::sms()
{
 //system("cls");
 
 cout<<"Error!\Вы ставите в занятую клетку!!!\n";
 return false;
}
int Board::counter=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
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

//BoardView.cpp
#include<iostream>
#include<iomanip>
#include"BoardView.h"
#include <windows.h> 
using namespace std;
 
View::View(Board * b)
{
 boar=b;
}
 
void View::show()
{
    for(int i=0;i<3;i++){   
     for(int j=0;j<3;j++)
        cout<<setw(3)<<boar->GetCell(i,j);
    cout<<endl;
    }
}
View::~View()
{}
void View::StartGame()
{
char x;
bool ui,game=false;
star_show();
 while(game!=true)
  {
    if(sign==0)          //Конструкция, которая пропускается, если нолик не проходил правильно
      {
       cout<<"\nХодит крестик!\n"<<"Введите цифру:";
       cin>>x;
       ui=boar->makeMove(x,sign);
        if(ui==false)
         continue;
       system("cls");
       show();
       game=boar->WhoWin(sign);
       if(game==true)
          break;
       ++sign;
     }
   cout<<"\nХодит нолик!\n"<<"Введите цифру:";
   cin>>x;
   ui=boar->makeMove(x,sign);
       if(ui==false)
        continue;
   system("cls");
   show();
   game=boar->WhoWin(sign);
       if(game==true)
        break;
   --sign;
  }
}
void View::star_show()
{
 cout<<"\t\tКрестики-нолики на двоих!"<<endl;
 cout<<"Введите 1 или 'y' чтобы увидеть особенности игры,\n"
       "либо любую другую клавишу, если уже знаете, как играть.\n";
 char y;
 cin>>y;
 if(y=='1'||y=='y'){
  cout<<"Известнейшая игра, но кое что следует знать...\n";
  cout<<"Вот поле:\n";
  show();
  cout<<"Ячейки пронумерованы цифрами,\n"
        "вводите соответствующую цифру,\n"
        "и там появится ваш знак,\n"
        "так что разберитесь, кто крестик,\n"
        "а кто нолик, и вперед!\nУдачи!\n\n";
 }
 else
  show();
}
 
int View::sign=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
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

bool bot() // Исходный код бота
{
    if (numb < 9)
    {
        for (int i(0); i < 3; i++)
        {
            if ((table[i][0] == 'X' || table[i][0] == 'O') && (table[i][1] == 'X' || table[i][1] == 'O'))
            {
                if (table[i][2] != 'X' && table[i][2] != 'O')
                {
                    table[i][2] = 'O';
                    numb++;
                    step = true;
                    return true;
                }
            }
            if ((table[i][1] == 'X' || table[i][1] == 'O') && (table[i][2] == 'X' || table[i][2] == 'O'))
            {
                if (table[i][0] != 'X' && table[i][0] != 'O')
                {
                    table[i][0] = 'O';
                    numb++;
                    step = true;
                    return true;
                }
            }
            if ((table[i][0] == 'X' || table[i][0] == 'O') && (table[i][2] == 'X' || table[i][2] == 'O'))
            {
                if (table[i][1] != 'X' && table[i][1] != 'O')
                {
                    table[i][1] = 'O';
                    numb++;
                    step = true;
                    return true;
                }
            }
 
            //
            if ((table[0][i] == 'X' || table[0][i] == 'O') && (table[1][i] == 'X' || table[1][i] == 'O'))
            {
                if (table[2][i] != 'X' && table[2][i] != 'O')
                {
                    table[2][i] = 'O';
                    numb++;
                    step = true;
                    return true;
                }
            }
            if ((table[1][i] == 'X' || table[1][i] == 'O') && (table[2][i] == 'X' || table[2][i] == 'O'))
            {
                if (table[0][i] != 'X' && table[0][i] != 'O')
                {
                    table[0][i] = 'O';
                    numb++;
                    step = true;
                    return true;
                }
            }
            if ((table[0][i] == 'X' || table[0][i] == 'O') && (table[2][i] == 'X' || table[2][i] == 'O'))
            {
                if (table[1][i] != 'X' && table[1][i] != 'O')
                {
                    table[1][i] = 'O';
                    numb++;
                    step = true;
                    return true;
                }
            }
        }
 
        //
        if ((table[0][0] == 'X' || table[0][0] == 'O') && (table[1][1] == 'X' || table[1][1] == 'O'))
        {
            if (table[2][2] != 'X' && table[2][2] != 'O')
            {
                table[2][2] = 'O';
                numb++;
                step = true;
                return true;
            }
        }
 
        if ((table[0][0] == 'X' || table[0][0] == 'O') && (table[2][2] == 'X' || table[2][2] == 'O'))
        {
            if (table[1][1] != 'X' && table[1][1] != 'O')
            {
                table[1][1] = 'O';
                numb++;
                step = true;
                return true;
            }
        }
 
        if ((table[1][1] == 'X' || table[1][1] == 'O') && (table[2][2] == 'X' || table[2][2] == 'O'))
        {
            if (table[0][0] != 'X' && table[0][0] != 'O')
            {
                table[0][0] = 'O';
                numb++;
                step = true;
                return true;
            }
        }
 
        //
 
        if ((table[0][2] == 'X' || table[0][2] == 'O') && (table[1][1] == 'X' || table[1][1] == 'O'))
        {
            if (table[2][0] != 'X' && table[2][0] != 'O')
            {
                table[2][0] = 'O';
                numb++;
                step = true;
                return true;
            }
        
        }
 
        if ((table[0][2] == 'X' || table[0][2] == 'O') && (table[2][0] == 'X' || table[2][0] == 'O')) 
        {
            if (table[1][1] != 'X' && table[1][1] != 'O')
            {
                table[1][1] = 'O';
                numb++;
                step = true;
                return true;
            }
        }
        if ((table[2][0] == 'X' || table[2][0] == 'O') && (table[1][1] == 'X' || table[1][1] == 'O'))
        {
            if (table[0][2] != 'X' && table[0][2] != 'O')
            {
                table[0][2] = 'O';
                numb++;
                step = true;
                return true;
            }
        }
 
        int n = 1;
        int m = 0, j = 0;
 
        n = rand() % 10;
 
        if (n % 3 == 0)
        {
            m = (n / 3) - 1;
            j = 2;
        }
        else
        {
            m = n / 3;
            j = (n % 3) - 1;
        }
 
        if ((table[m][j] == 'O') || (table[m][j] == 'X'))
            return false;
        else
        {
            table[m][j] = 'O';
            numb++;
            step = true;
            return true;
        }
    }
}
0
cpp_developer
Эксперт
20123 / 5690 / 1417
Регистрация: 09.04.2010
Сообщений: 22,546
Блог
 22.05.2016, 22:00
Ответы с готовыми решениями:

Бред в крестиках ноликах
Проблема. Написал цикдические крестики нолики ( в конце игры спрашивает хотите сыгарть еще или нет?) и после этого происходит какой то...

Проверка на победу в крестиках-ноликах
Здраствуйте! Я сделал игру крестики-нолики на языке с++, но столкнулся с тем, что у меня нету проверки на победу. Используя разные сайты...

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

5
55 / 56 / 34
Регистрация: 29.12.2012
Сообщений: 478
22.05.2016, 22:59
Знакомый код))))))
Авторские права мои нарушаете)))))
Неужеле я так плохо раньше писал
0
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
22.05.2016, 23:29
Если имеется в виду игра человек-компьютер, то так можно.
Первая часть:
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
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409

#include <algorithm>
#include <cctype>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <random>
#include <set>
#include <string>
#include <utility>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
const   char    SPACE_SYMB  =   ' ';
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::default_random_engine      T_gen_type;
typedef std::string                     T_str;
typedef std::vector     < T_str     >   T_strings;
typedef std::set        < T_str     >   T_strings_set;
typedef T_strings                       T_field_matr;
typedef T_str                           T_position_str_min;
typedef T_strings                       T_position_strings;
 
typedef std::map
    <
        T_position_str_min,
        T_position_strings
    >
    T_position_strings_of_position_str_min;
/////////////////////////////////////////////////////////////////////////////////////////
enum    T_game_res
{
    GAME_RES_EMPTY,
    GAME_RES_LOSS,
    GAME_RES_DRAW,
    GAME_RES_WIN
};
/////////////////////////////////////////////////////////////////////////////////////////
T_game_res  operator!   ( T_game_res    game_res )
{
    switch( game_res )
    {
    case    GAME_RES_EMPTY  :   return  GAME_RES_EMPTY;
    case    GAME_RES_LOSS   :   return  GAME_RES_WIN;
    case    GAME_RES_DRAW   :   return  GAME_RES_DRAW;
    case    GAME_RES_WIN    :   return  GAME_RES_LOSS;
    default                 :   return  GAME_RES_EMPTY;
    }//switch
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_position
{
    //-----------------------------------------------------------------------------------
    T_str                   field_str_;
    bool                    made_computer_;
    mutable     T_game_res  res_for_computer_;
    mutable     bool        is_final_;
    //-----------------------------------------------------------------------------------
    T_position
        (
            T_str   const   &   field_str,
            bool                computer_symb_is_first
        )
        :
        field_str_          { field_str  },
        res_for_computer_   {},
        is_final_           {}
    {
        int     spaces_count            =   std::count
                                                (
                                                    field_str.begin     (),
                                                    field_str.end       (),
                                                    SPACE_SYMB
                                                );
 
        bool    spaces_count_is_even    =   spaces_count    %   2   ==  0;
 
        made_computer_                  =       spaces_count_is_even
                                            ==  computer_symb_is_first;
 
        if  (
                    spaces_count
                ==  0
            )
        {
            is_final_           =   true;
            res_for_computer_   =   GAME_RES_DRAW;
        }//if
    }
    //-----------------------------------------------------------------------------------
    bool    operator<   ( T_position    const   &   position )                  const
    {
        return      std::make_pair
                        (
                            field_str_,
                            made_computer_
                        )
 
                <   std::make_pair
                        (
                            position.field_str_,
                            position.made_computer_
                        );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::set    < T_position    >   T_positions;
typedef std::set    < T_game_res    >   T_results_set_for_computer;
/////////////////////////////////////////////////////////////////////////////////////////
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    MINUS_SYMB              =   '-';
    static  const   char    VERTICAL_LINE_SYMB      =   '|';
    static  const   int     SQUARE_CORNERS_TOTAL    =   4;
 
    bool                    computer_symb_is_first_;
    char                    computer_symb_;
    char                    player_symb_;
    T_positions             positions_;
    //-----------------------------------------------------------------------------------
 public:
    //-----------------------------------------------------------------------------------
    T_xs_and_os()
        :
        computer_symb_is_first_     {},
        computer_symb_              {},
        player_symb_                {}
    {}
    //-----------------------------------------------------------------------------------
    void    input_player_symb()
    {
        const   char    YES_SYMB    =   'Y';
        const   char    NO_SYMB     =   'N';
 
        std::cout   <<  "\n\n\n\n\n"
                    <<  "Want to play with "
                    <<  GAME_SYMB_FIRST
                    <<  " ("
                    <<  YES_SYMB
                    <<  "/"
                    <<  NO_SYMB
                    <<  "): ";
 
        char    YN_symb_for_player_symb_is_first{};
        std::cin    >>  YN_symb_for_player_symb_is_first;
 
        computer_symb_is_first_     =       std::toupper( YN_symb_for_player_symb_is_first )
                                        !=  std::toupper( YES_SYMB );
 
        computer_symb_              =   computer_symb_is_first_
                                            ?   GAME_SYMB_FIRST
                                            :   GAME_SYMB_SECOND;
 
        player_symb_                =   computer_symb_is_first_
                                            ?   GAME_SYMB_SECOND
                                            :   GAME_SYMB_FIRST;
    }
    //-----------------------------------------------------------------------------------
    void    play()
    {
        T_str   field_str_cur
                    (
                        FIELD_SIZE,
                        SPACE_SYMB
                    );
 
        for (
                bool
                cur_symb_is_first       { true  };
                !field_str_is_final     ( field_str_cur );
                cur_symb_is_first   =   !cur_symb_is_first
            )
        {
            bool    is_computer_move    =       computer_symb_is_first_
                                            ==  cur_symb_is_first;
 
            if( is_computer_move )
            {
                if  (
                        !successfully_make_computer_move( field_str_cur )
                    )
                {
                    return;
                }//if
            }
            else
            {
                input_player_move( field_str_cur );
            }//else
        }//for
 
        print_field                 ( field_str_cur );
        print_game_res_for_player   ( field_str_cur );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool    field_str_is_final( T_str   const  &   field_str )
    {
        return  get_position_for_field_str( field_str ).is_final_;
    }
    //-----------------------------------------------------------------------------------
    static
    void    print_field( T_str   const  &   field_str )
    {
        T_field_matr    field_matr;
 
        set_field_matr
            (
                field_str,
                field_matr
            );
 
        print_field_matr( field_matr );
    }
    //-----------------------------------------------------------------------------------
    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;
    }
    //-----------------------------------------------------------------------------------
    void    print_game_res_for_player( T_str    const    &   field_str )
    {
        auto    res_for_player
            =   !get_position_for_field_str( field_str ).res_for_computer_;
 
        std::cout   <<  game_res_message_for_player( res_for_player )
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    T_str   game_res_message_for_player( T_game_res     res_for_player )
    {
        switch( res_for_player )
        {
        case    GAME_RES_WIN    :   return  "You won.";
        case    GAME_RES_DRAW   :   return  "Draw.";
        case    GAME_RES_LOSS   :   return  "You lost.";
        default                 :   return  "Game result is unknown.";
        }//switch
    }
    //-----------------------------------------------------------------------------------
    static
    void    set_field_matr
        (
            T_str           const   &   field_str,
            T_field_matr            &   field_matr
        )
    {
        for( size_t  i{}; i < FIELD_DIM; ++i )
        {
            field_matr.push_back
                (
                    field_str.substr
                        (
                            FIELD_DIM   *   i,
                            FIELD_DIM
                        )
                );
        }//for
    }
    //-----------------------------------------------------------------------------------
    static
    bool    symb_won_in_matr
        (
            char                        game_symb,
            T_field_matr    const   &   field_matr
        )
    {
        T_field_matr    rotated_matr    { field_matr    };
        transp                          ( rotated_matr  );
        reverse_strings                 ( rotated_matr  );
 
        return      game_symb_won_in_row_or_main_diag_of_matr
                        (
                            game_symb,
                            field_matr
                        )
 
                ||  game_symb_won_in_row_or_main_diag_of_matr
                        (
                            game_symb,
                            rotated_matr
                        );
    }
    //-----------------------------------------------------------------------------------
    static
    bool    game_symb_won_in_row_or_main_diag_of_matr
        (
            char                        game_symb,
            T_field_matr    const   &   field_matr
        )
    {
        T_str   winning_str
                    {
                        T_str   (
                                    FIELD_DIM,
                                    game_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]
                                };
    }
    //-----------------------------------------------------------------------------------
1
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
22.05.2016, 23:30
Вторая часть:
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
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411

    void   input_player_move( T_str       &   field_str )
    {
        print_field     ( field_str );
        int     ind     {};
 
        do
        {
            input_field_str_ind( ind );
        }
        while   (
                         field_str[ ind ]
                     !=  SPACE_SYMB
                );
 
        field_str[ ind ]    =   player_symb_;
    }
    //-----------------------------------------------------------------------------------
    void    input_field_str_ind( int    &   ind )
    {
        int     move_cell_num   {};
        char    digit_symb      {};
 
        for(;;)
        {
            print_player_move_prompt();
            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;
 
        int     i               =       FIELD_DIM
                                    -   1
                                    -   i_from_num;
 
        int     j               =       ind_from_num
                                    %   FIELD_DIM;
 
        ind                     =   FIELD_DIM   *   i   +   j;
    }
    //-----------------------------------------------------------------------------------
    void    print_player_move_prompt()                                          const
    {
        std::cout   <<  std::endl
                    <<  "Your move by symbol "
                    <<  player_symb_
                    <<  "."
                    <<  std::endl
                    <<  "Enter cell number "
                    <<  FIRST_CELL_NUM
                    <<  ".."
                    <<  LAST_CELL_NUM
                    <<  " on numeric keypad: ";
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_make_computer_move( T_str       &   field_str )
    {
        bool    bool_res    =   false;
 
        T_position_strings_of_position_str_min
            win_position_strings_of_position_str_min;
 
        T_position_strings_of_position_str_min
            draw_position_strings_of_position_str_min;
 
        for( size_t  i{}; i < field_str.size(); ++i  )
        {
            if  (
                        field_str[i]
                    !=  SPACE_SYMB
                )
            {
                continue;
            }
 
            T_str       field_str_cur   { field_str };
            field_str_cur[i]    =   computer_symb_;
 
            auto    position_cur    =   get_position_for_field_str( field_str_cur );
 
            switch( position_cur.res_for_computer_ )
            {
            case    GAME_RES_WIN    :
                win_position_strings_of_position_str_min
                    [
                        get_position_str_min( field_str_cur )
                    ]
                    .push_back( field_str_cur );
 
                bool_res    =   true;
                break;
 
            case    GAME_RES_DRAW    :
                draw_position_strings_of_position_str_min
                    [
                        get_position_str_min( field_str_cur )
                    ]
                    .push_back( field_str_cur );
 
                bool_res    =   true;
                break;
 
            default:
                break;
            }//switch
        }//for
 
        if( bool_res )
        {
            set_rand_field_str
                (
                    !win_position_strings_of_position_str_min.empty()
                        ?   win_position_strings_of_position_str_min
                        :   draw_position_strings_of_position_str_min,
 
                    field_str
                );
        }
        else
        {
            print_field( field_str );
 
            std::cout   <<  "I give up!"
                        <<  std::endl;
        }//else
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    T_str   get_position_str_min( T_str     const   &   field_str )
    {
        T_strings_set   field_strings_set;
        T_field_matr    field_matr;
 
        set_field_matr
            (
                field_str,
                field_matr
            );
 
        for( int  i{}; ; ++i )
        {
            field_strings_set.insert
                (
                    get_field_str_of_fild_matr( field_matr )
                );
 
            if  (
                        i
                    ==  SQUARE_CORNERS_TOTAL * 2 - 1
                )
            {
                break;
            }
 
            i % 2   ==  0
                ?   transp              ( field_matr )
                :   reverse_strings     ( field_matr );
        }//for
 
        return  *field_strings_set.begin();
    }
    //-----------------------------------------------------------------------------------
    T_str   get_field_str_of_fild_matr( T_field_matr    &   field_matr )
    {
        T_str   res_str;
 
        for (
                auto    &   matr_row:
                field_matr
            )
        {
            res_str     +=  matr_row;
        }//for
 
        return  res_str;
    }
    //-----------------------------------------------------------------------------------
    T_position  get_position_for_field_str( T_str     const   &   field_str )
    {
        return  get_or_calc_position
                    (
                        T_position
                            (
                                field_str,
                                computer_symb_is_first_
                            )
                    );
    }
    //-----------------------------------------------------------------------------------
    T_position  get_or_calc_position( T_position    const   &   position )
    {
        auto    it  =   positions_.find( position );
 
        if  (
                it  !=  positions_.end()
            )
        {
            return  *it;
        }//if
 
        fill_position       ( position );
        positions_.insert   ( position );
        return  position;
    }
    //-----------------------------------------------------------------------------------
    void    fill_position( T_position   const   &   position )
    {
        calc_is_final_of_position( position );
 
        if( position.is_final_ )
        {
            return;
        }
 
        T_results_set_for_computer  children_results_for_computer;
 
        calc_children_and_set_their_results_for_computer
            (
                position,
                children_results_for_computer
            );
 
        position.res_for_computer_  =   position.made_computer_
                                            ?   *children_results_for_computer.begin    ()
                                            :   *children_results_for_computer.rbegin   ();
    }
    //-----------------------------------------------------------------------------------
    void    calc_is_final_of_position( T_position   const   &   position )
    {
        auto    cur_game_symb   =   position.made_computer_
                                        ?   computer_symb_
                                        :   player_symb_;
 
        if  (
                symb_won_in_field_str
                    (
                        cur_game_symb,
                        position.field_str_
                    )
            )
        {
            position.is_final_          =   true;
 
            position.res_for_computer_  =   position.made_computer_
                                                ?   GAME_RES_WIN
                                                :   GAME_RES_LOSS;
        }//if
    }
    //-----------------------------------------------------------------------------------
    bool    symb_won_in_field_str
        (
            char                symb,
            T_str   const   &   field_str
        )
    {
        T_field_matr    field_matr;
 
        set_field_matr
            (
                field_str,
                field_matr
            );
 
        return  symb_won_in_matr
                    (
                        symb,
                        field_matr
                    );
    }
    //-----------------------------------------------------------------------------------
    static
    void    set_rand_field_str
        (
            T_position_strings_of_position_str_min   const   &
                position_strings_of_position_str_min,
 
            T_str   &   field_str
        )
    {
        auto    rand_position_strings   =   get_rand_val_of_cont
                                                (
                                                    position_strings_of_position_str_min
                                                )
                                                .second;
 
        field_str                       =   get_rand_val_of_cont
                                                (
                                                    rand_position_strings
                                                );
    }
    //-----------------------------------------------------------------------------------
    template< typename    TT_cont >
    static
    typename    TT_cont::value_type     get_rand_val_of_cont
        (
            TT_cont     const   &   cont
        )
    {
        static  T_gen_type                          gen_( unsigned(time(0)) );
 
        std::uniform_int_distribution< size_t >     cont_ind_distr
                                                        (
                                                            0,
                                                            cont.size() - 1
                                                        );
 
        auto    it          =   cont.begin      ();
        size_t  it_shift    =   cont_ind_distr  ( gen_ );
 
        std::advance
            (
                it,
                it_shift
            );
 
        return  *it;
    }
    //-----------------------------------------------------------------------------------
    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    reverse_strings( T_field_matr    &   field_matr )
    {
        std::reverse
            (
                field_matr.begin    (),
                field_matr.end      ()
            );
    }
    //-----------------------------------------------------------------------------------
    void    calc_children_and_set_their_results_for_computer
        (
            T_position                  const   &   parent_position,
            T_results_set_for_computer          &   children_results_for_computer
        )
    {
        auto    parent_field_str   =   parent_position.field_str_;
 
        for( size_t  i{}; i < parent_field_str.size(); ++i )
        {
            if  (
                        parent_field_str[i]
                    !=  SPACE_SYMB
                )
            {
                continue;
            }
 
            auto    child_cur_field_str   ( parent_field_str );
 
            child_cur_field_str[i]  =   parent_position.made_computer_
                                            ?   player_symb_
                                            :   computer_symb_;
 
            children_results_for_computer.insert
                (
                    get_position_for_field_str( child_cur_field_str ).res_for_computer_
                );
        }//for
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_xs_and_os     xs_and_os;
 
    for(;;)
    {
        xs_and_os.input_player_symb     ();
        xs_and_os.play                  ();
    }//for
}
1
0 / 0 / 0
Регистрация: 08.04.2015
Сообщений: 10
23.05.2016, 19:39  [ТС]
Черный мечник,
прошу прощения, код то отменный, помогает в изучении языка, просто требуется именно человек против бота))

Добавлено через 14 минут
Mr.X, да, имеется ввиду игра человек-бот, а также использование ООП)
0
55 / 56 / 34
Регистрация: 29.12.2012
Сообщений: 478
24.05.2016, 15:40
Pliman, в ЮТУБЕ Лекториум -> Изучения С++ - Евгений Ленский
Но уже надо достаточно сного знать так как лекции обрезаные, качество видео плохое...
Но мне почемуто понравилась эти лекции(один курс который я просмотрел полностью) крестики были взяты с них там он расказывал структурно как их делать, а я уже реализуовавал как мог в то время
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
raxper
Эксперт
30234 / 6612 / 1498
Регистрация: 28.12.2010
Сообщений: 21,154
Блог
 24.05.2016, 15:40
Помогаю со студенческими работами здесь

Абстракция игрока в крестиках-ноликах
Я пишу крестики-нолики. хочу создать единый метод для проведения игры внезависимости от типа игроков(человек/компьютер) то есть должны...

Реализовать действие в крестиках ноликах
помогите реализовать так чтобы он выдовал кто победитель(или ничья) и когда закончина игра. Заранее благодарю. using System; ...

Определение победителя в крестиках ноликах
Не знаю как определять победителя в игре,принцип игры основан на кнопках(QPushButton),при нажатии на кнопку в зависимости от хода кнопка...

Очередность ходов в крестиках ноликах
Как сделать чтоб крестики и нолики ставились по очереди?

Сброс игры в крестиках-ноликах
Есть вот такой вот код. public partial class MainWindow : Window { public MainWindow() { new...


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

Или воспользуйтесь поиском по форуму:
6
Ответ Создать тему
Новые блоги и статьи
Ритм жизни
kumehtar 27.02.2026
Иногда приходится жить в ритме, где дел становится всё больше, а вовлечения в происходящее — всё меньше. Плотный график не даёт вниманию закрепиться ни на одном событии. Утро начинается с быстрых,. . .
SDL3 для Web (WebAssembly): Сборка SDL3 и Box2D из исходников с помощью CMake и Emscripten
8Observer8 27.02.2026
Недавно вышла версия 3. 4. 2 библиотеки SDL3. На странице официальной релиза доступны исходники, готовые DLL (для x86, x64, arm64), а также библиотеки для разработки под Android, MinGW и Visual Studio. . . .
SDL3 для Web (WebAssembly): Реализация движения на Box2D v3 - трение и коллизии с повёрнутыми стенами
8Observer8 20.02.2026
Содержание блога Box2D позволяет легко создать главного героя, который не проходит сквозь стены и перемещается с заданным трением о препятствия, которые можно располагать под углом, как верхнее. . .
Конвертировать закладки radiotray-ng в m3u-плейлист
damix 19.02.2026
Это можно сделать скриптом для PowerShell. Использование . \СonvertRadiotrayToM3U. ps1 <path_to_bookmarks. json> Рядом с файлом bookmarks. json появится файл bookmarks. m3u с результатом. # Check if. . .
Семь CDC на одном интерфейсе: 5 U[S]ARTов, 1 CAN и 1 SSI
Eddy_Em 18.02.2026
Постепенно допиливаю свою "многоинтерфейсную плату". Выглядит вот так: https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11617&stc=1&d=1771445347 Основана на STM32F303RBT6. На борту пять. . .
Камера Toupcam IUA500KMA
Eddy_Em 12.02.2026
Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .
И ясному Солнцу
zbw 12.02.2026
И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.
«Знание-Сила»
zbw 12.02.2026
«Знание-Сила» «Время-Деньги» «Деньги -Пуля»
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Условия использования - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2026, CyberForum.ru