Как написать игру "Цепь"?

@АндрейСГУПС · Регистрация: 21.05.2012

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

• Данное приложение является реализацией известной логической игры. В данной реализации предусматривается игра двух игроков на квадратном поле фиксированного размера. Цель игры - построить непрерывную линию, соединяющую горизонтальные или вертикальные (для каждого из игроков соответственно) стороны игрового поля, причем линия считается непрерывной, если фишки граничат друг с другом по горизонтали, вертикали или диагонали. Выигрывает тот игрок, который первым построит свою линию.

@ZaDPoTT · 05.05.2015, 20:34

Наконец эта адская головоломка заработала спасибо большое очень спас меня

@Mr.X · 06.05.2015, 15:14

Мой вариант шайтан-программы (первая часть):

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
/////////////////////////////////////////////////////////////////////////////////////////
//Данное приложение является реализацией известной логической игры. В данной реализации 
//предусматривается игра двух игроков на квадратном поле фиксированного размера. Цель игры - 
//построить непрерывную линию, соединяющую горизонтальные или вертикальные (для каждого 
//из игроков соответственно) стороны игрового поля, причем линия считается непрерывной, 
//если фишки граничат друг с другом по горизонтали, вертикали или диагонали. Выигрывает 
//тот игрок, который первым построит свою линию.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <map>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
enum    T_player_type
{
    player_empty,
    player_horiz,
    player_vert
};
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_cell
{
    //-----------------------------------------------------------------------------------
    static  const   char    EMPTY_CELL_SYMB             =   '*';
    static  const   char    HORIZ_CHAIN_CELL_SYMB       =   '=';
    static  const   char    HORIZ_NOT_CHAIN_CELL_SYMB   =   '-';
    static  const   char    VERT_CHAIN_CELL_SYMB        =   'П';
    static  const   char    VERT_NOT_CHAIN_CELL_SYMB    =   '|';
 
    static  const   int     DISTANCE_EMPTY              =   0;
    static  const   int     DISTANCE_START              =   1;
    //-----------------------------------------------------------------------------------
    T_player_type   player_type_;
    int             distance_front_;
    int             distance_back_;
    //-----------------------------------------------------------------------------------
    T_cell
        (
            T_player_type   player_type     =   player_empty,
            int             distance_front  =   DISTANCE_EMPTY,
            int             distance_back   =   DISTANCE_EMPTY
        )
        :
        player_type_        ( player_type       ),
        distance_front_     ( distance_front    ),
        distance_back_      ( distance_back     )
    {}
    //-----------------------------------------------------------------------------------
    void    print_for_shortest_chain_dist_sum( int  shortest_chain_distances_sum )
    {
        std::cout   <<  get_cell_symb_for_shortest_chain_dist_sum( shortest_chain_distances_sum );
    }
    //-----------------------------------------------------------------------------------
    bool    empty()
    {
        return  player_type_    ==  player_empty;
    }
    //-----------------------------------------------------------------------------------
    char    get_cell_symb_for_shortest_chain_dist_sum( int  shortest_chain_distances_sum )
    {
        if  (
                player_type_    ==  player_empty
            )
        {
            return  EMPTY_CELL_SYMB;
        }
        else
        {
            if  (
                    is_shortest_chain( shortest_chain_distances_sum )
                )
            {
                return  (
                            player_type_    ==  player_horiz
                                ?   HORIZ_CHAIN_CELL_SYMB
                                :   VERT_CHAIN_CELL_SYMB
                        );
            }
            else
            {
                return  (
                            player_type_    ==  player_horiz
                                ?   HORIZ_NOT_CHAIN_CELL_SYMB
                                :   VERT_NOT_CHAIN_CELL_SYMB
                        );
            }//else
        }//else
    }
    //-----------------------------------------------------------------------------------
    bool    is_shortest_chain( int   shortest_chain_distances_sum )
    {
        return      distance_front_     !=   DISTANCE_EMPTY
                &&  distance_back_      !=   DISTANCE_EMPTY
 
                &&          distance_front_
                        +   distance_back_
                    ==  shortest_chain_distances_sum;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_hex
{
    //-----------------------------------------------------------------------------------
    static  const   char    SPACE           =   ' ';
    static  const   char    HORIZ_DELIM     =   SPACE;
    //-----------------------------------------------------------------------------------
    typedef std::pair   < int,  int             >   T_coords;
    typedef std::map    < T_coords,     T_cell  >   T_cell_of_coords;
    //-----------------------------------------------------------------------------------
    int                 board_dim_;
    bool                move_of_horiz_;
    T_player_type       winner_;
    int                 shortest_chain_distances_sum_;
    T_cell_of_coords    cell_of_coords_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_hex( int  board_dim )
        :
        board_dim_                      ( board_dim                 ),
        move_of_horiz_                  ( true                      ),
        winner_                         ( player_empty              ),
        shortest_chain_distances_sum_   ( board_dim * board_dim     )
    {}
    //-----------------------------------------------------------------------------------
    void    play()
    {
        print_format_message();
 
        for(;;)
        {
            print_board();
 
            if  (
                    game_over()
                )
            {
                break;
            }
 
            make_move       ();
            check_cells     ();
        }//for
 
        print_result();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void    check_cells()
    {
        bool    cell_was_changed    =   false;
 
        do
        {
            cell_was_changed    =   false;
 
            for (
                    auto
                    coords_and_cell_it  =   cell_of_coords_.begin   ();
                    coords_and_cell_it  !=  cell_of_coords_.end     ();
                    ++coords_and_cell_it
                )
            {
                auto        i_cur           =   coords_and_cell_it->first.first;
                auto        j_cur           =   coords_and_cell_it->first.second;
                auto    &   cell_cur_ref    =   coords_and_cell_it->second;
 
                for( auto  i = i_cur - 1; i <= i_cur + 1; ++i )
                {
                    for( auto  j = j_cur - 1; j <= j_cur + 1; ++j )
                    {
                        auto    adjacent_coords_and_cell_it     =   cell_of_coords_.find
                                                                        (
                                                                            T_coords( i, j  )
                                                                        );
 
                        if  (
                                adjacent_coords_and_cell_it     ==  cell_of_coords_.end()
                            )
                        {
                            continue;
                        }
 
                        auto    &   adjacent_cell_ref   =   adjacent_coords_and_cell_it->second;
 
                        if  (
                                        i   -   i_cur
                                    ==  j   -   j_cur//Не та диагональ.
 
                                ||      cell_cur_ref        .player_type_
                                    !=  adjacent_cell_ref   .player_type_//фишки разных цветов
                            )
                        {
                            continue;
                        }
 
                        if  (
                                    adjacent_cell_ref.distance_front_       !=  T_cell::DISTANCE_EMPTY
 
                                &&  (
                                            cell_cur_ref.distance_front_    ==  T_cell::DISTANCE_EMPTY
                                        ||      cell_cur_ref.distance_front_
                                            >   adjacent_cell_ref.distance_front_   +   1
                                    )
                            )
                        {
                            cell_cur_ref.distance_front_    =   adjacent_cell_ref.distance_front_ + 1;
                            cell_was_changed                =   true;
                        }
 
                        if  (
                                    adjacent_cell_ref.distance_back_        !=  T_cell::DISTANCE_EMPTY
 
                                &&  (
                                            cell_cur_ref.distance_back_     ==  T_cell::DISTANCE_EMPTY
                                        ||      cell_cur_ref.distance_back_
                                            >   adjacent_cell_ref.distance_back_    +   1
                                    )
                            )
                        {
                            cell_cur_ref.distance_back_    =   adjacent_cell_ref.distance_back_     +   1;
                            cell_was_changed                =   true;
                        }
 
                        if  (
                                    cell_cur_ref.distance_front_    !=  T_cell::DISTANCE_EMPTY
                                &&  cell_cur_ref.distance_back_     !=  T_cell::DISTANCE_EMPTY
                            )
                        {
                            winner_     =   cell_cur_ref.player_type_;
 
                            if  (
                                            cell_cur_ref.distance_front_
                                        +   cell_cur_ref.distance_back_
                                    <   shortest_chain_distances_sum_//
                                )
                            {
                                shortest_chain_distances_sum_
                                    =       cell_cur_ref.distance_front_
                                        +   cell_cur_ref.distance_back_;
 
                                cell_was_changed    =   true;
                            }//if
                        }//if
                    }//for
                }//for
            }//for
        }
        while( cell_was_changed );
    }

@Mr.X · 06.05.2015, 15:15

Вторая часть:

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
    //-----------------------------------------------------------------------------------
    bool    game_over()
    {
        return  winner_     !=  player_empty;
    }
    //-----------------------------------------------------------------------------------
    void    make_move()
    {
        do
        {
            print_prompt_for_move();
        }
        while   (
                    !successfully_input_move()
                );
    }
    //-----------------------------------------------------------------------------------
    void    print_format_message()
    {
        std::cout   <<  std::endl
                    <<  "Вводите координаты клеток в виде двузначного числа:"
                    <<  std::endl
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    void    print_board()
    {
        print_coord_row();
 
        for( int  i = 0; i < board_dim_; ++i )
        {
            print_row_with_ind(i);
        }//for
    }
    //-----------------------------------------------------------------------------------
    void    print_coord_row()
    {
        std::cout   <<  std::endl
                    <<  SPACE
                    <<  HORIZ_DELIM;
 
        for( int  i = 0; i < board_dim_; ++i )
        {
            std::cout   <<  i + 1
                        <<  HORIZ_DELIM;
        }//for
 
        std::cout   <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    void    print_row_with_ind( int     i )
    {
        std::cout   <<  i + 1
                    <<  HORIZ_DELIM;
 
        for( int  j = 0; j < board_dim_; ++j )
        {
            auto    it  =   cell_of_coords_.find
                                (
                                    T_coords( i, j )
                                );
 
            if  (
                    it  ==  cell_of_coords_.end()
                )
            {
                std::cout   <<  T_cell::EMPTY_CELL_SYMB;
            }
            else
            {
                it->second.print_for_shortest_chain_dist_sum( shortest_chain_distances_sum_ );
            }
 
            std::cout   <<  HORIZ_DELIM;
        }//for
 
        std::cout   <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    void    print_prompt_for_move()
    {
        std::cout   <<  std::endl
                    <<  std::endl
 
                    <<  (
                            move_of_horiz_
                                ?   T_cell::HORIZ_NOT_CHAIN_CELL_SYMB
                                :   T_cell::VERT_NOT_CHAIN_CELL_SYMB
                        )
 
                    <<  ": ";
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_input_move()
    {
        static  const   char    DIGIT_MIN   =   '0';
        T_str                   move_str;
 
        std::cin    >>  move_str;
 
        bool    bool_res    =       move_str.size()     >=  2
                                &&  isdigit( move_str[0] )
                                &&  isdigit( move_str[1] );
 
        if( bool_res )
        {
            int     i   =   move_str[0]     -   DIGIT_MIN   -   1;
            int     j   =   move_str[1]     -   DIGIT_MIN   -   1;
 
            bool_res    =       coord_is_correct(i)
                            &&  coord_is_correct(j)
 
                            &&      cell_of_coords_.find
                                        (
                                            T_coords( i, j)
                                        )
                                ==  cell_of_coords_.end();
 
            if( bool_res )
            {
                auto    cell    =   move_of_horiz_
                                        ?   T_cell  (
                                                        player_horiz,
 
                                                        j   ==  0
                                                            ?   T_cell::DISTANCE_START
                                                            :   T_cell::DISTANCE_EMPTY,
 
                                                        j   ==  board_dim_ - 1
                                                            ?   T_cell::DISTANCE_START
                                                            :   T_cell::DISTANCE_EMPTY
                                                    )
 
                                        :   T_cell  (
                                                        player_vert,
 
                                                        i   ==  0
                                                            ?   T_cell::DISTANCE_START
                                                            :   T_cell::DISTANCE_EMPTY,
 
                                                        i   ==  board_dim_ - 1
                                                            ?   T_cell::DISTANCE_START
                                                            :   T_cell::DISTANCE_EMPTY
                                                    );
 
                cell_of_coords_.insert
                    (
                        std::make_pair
                            (
                                T_coords( i, j ),
                                cell
                            )
                    );
 
                move_of_horiz_  =   !move_of_horiz_;
            }
        }//if
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    coord_is_correct( int   coord )
    {
        return      coord   >=  0
                &&  coord   <   board_dim_;
    }
    //-----------------------------------------------------------------------------------
    void    print_result()
    {
        std::cout   <<  std::endl
                    <<  "Игра окончена."
                    <<  std::endl
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    const   int     BOARD_DIM_MIN   =   2;
    const   int     BOARD_DIM_MAX   =   9;
 
    int     board_dim   =   0;
 
    do
    {
        std::cout   <<  "Введите размер игрового поля (2..9): ";
        std::cin    >>  board_dim;
    }
    while   (
                    board_dim   <   BOARD_DIM_MIN
                ||  board_dim   >   BOARD_DIM_MAX
            );
 
    T_hex   hex( board_dim );
    hex.play();
    system("pause");
}

Новые блоги и статьи Все статьи Все блоги /
Генератор паролей (вариант №3) Maks 30.10.2026 Финальная версия генератора паролей 1С. Доработка решения в этот раз коснулась только визуальной части, а именно, добавлен реквизит ДопПараметры (тип Булево), который скрывает/ отображает реквизиты:. . .	Магическое мышление и магия, современная наука не отличима от магии (говорит ИИ Джемени) zorxor 30.10.2026 Джемени, расскажи, пожалуйста, что такое магическое мышление, что такое магия, почему современная наука чем-то напоминает магию? Фраза «Любая достаточно развитая технология неотличима от магии». . .	За какое время ИИ может подобрать пароль по хешу (рассказывает Джемени ИИ) zorxor 30.10.2026 Расскажи, Джемени, если известен хэш МД5, например, за сколько ИИ сможет подобрать соответствующий пароль? Искусственный интеллект (ИИ) может подобрать простой или средний по сложности пароль по. . .	Кто убил Suno? Почему наше солнышко погасло? (диалог с ИИ Джемени) zorxor 30.10.2026 Как убивали Suno. Хронология. «Убийство» музыкальной нейросети Suno — это затяжной процесс, в котором технологический хайп стартапа разбился о жесткую реальность судебных исков от гигантов. . .
Генератор паролей (вариант №2) Maks 30.10.2026 Обновленная версия ранее созданной обработки. Добавлены следующие реквизиты типа Булево: - Буквы; - Цифры; - Символы. Изменена логика команды "Сгенерировать" и процедуры "ПриОткрытии":. . .	Генератор паролей (вариант №1) Maks 29.10.2026 Реализация из решения ниже выполнена исключительно по моей инициативе, дабы облегчить себе работу в создании паролей для администрируемых мною сервисов и пользователей. Самым главным критерием для. . .	Установка ChatGPT (Codex) на Windows без использования Microsoft Store Fabien159 28.10.2026 Здравствуйте всем читающим! Опишу процесс установки ChatGPT (Codex) на Windows, если по каким-то причинам у вас не получается устанавить его через Microsoft Store. И так: 1. Скачиваем с. . .	Программное добавление префикса в нумерацию документов Maks 27.10.2026 Реализация из решения ниже выполнена в самописной конфигурации на БСП (помощь начинающему коллеге). Задача: Программно добавить префикс в нумерацию документов. Решение: В модуле объекта. . .

@АндрейСГУПС 0 / 0 / 0 Регистрация: 21.05.2012 Сообщений: 14

	Как написать игру "Цепь"? 21.05.2012, 21:48. Показов 3743. Ответов 22 Метки нет (Все метки) • Данное приложение является реализацией известной логической игры. В данной реализации предусматривается игра двух игроков на квадратном поле фиксированного размера. Цель игры - построить непрерывную линию, соединяющую горизонтальные или вертикальные (для каждого из игроков соответственно) стороны игрового поля, причем линия считается непрерывной, если фишки граничат друг с другом по горизонтали, вертикали или диагонали. Выигрывает тот игрок, который первым построит свою линию. 0

@ZaDPoTT 0 / 0 / 0 Регистрация: 04.05.2015 Сообщений: 4
	05.05.2015, 20:34
	Наконец эта адская головоломка заработала спасибо большое очень спас меня 0