Форум программистов, компьютерный форум CyberForum.ru

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 14, средняя оценка - 4.86
АндрейСГУПС
0 / 0 / 0
Регистрация: 21.05.2012
Сообщений: 14
#1

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

21.05.2012, 21:48. Просмотров 1752. Ответов 22
Метки нет (Все метки)

• Данное приложение является реализацией известной логической игры. В данной реализации предусматривается игра двух игроков на квадратном поле фиксированного размера. Цель игры - построить непрерывную линию, соединяющую горизонтальные или вертикальные (для каждого из игроков соответственно) стороны игрового поля, причем линия считается непрерывной, если фишки граничат друг с другом по горизонтали, вертикали или диагонали. Выигрывает тот игрок, который первым построит свою линию.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
21.05.2012, 21:48     Как написать игру "Цепь"?
Посмотрите здесь:

Подскажите как написать игру "жизнь" - C++
Собственно интересует каким методом должна осуществлястя проверка, нашёл в интернете готовые решения - не стал глядеть, хотел бы понять

Как написать игру "Кости" - C++
Подскажите как правильно написать игру кости.

Как написать игру "Кубики"? - C++
Условие: имеется два игральных кубика со значениями от 1 до 6. Игра происходит с компьютером, кубики бросаются поочередно.Побеждает тот, у...

Мне нужно написать игру "Шашки" - C++
Ребят, помогите, надо написать Шашки на Microsoft Visual C++, но я не знаю с чего начать. Я прочитал у вас почти все форумы по этой теме,...

Требуется написать игру "Лагерь". Число палаток должно равняться числу деревьев - C++
Нуждаюсь в вашей помощи. Лагерь ("Tents", "Tents and Trees") представляет собой прямоугольную сетку, некоторые клетки которой содержат...

Написать программу, моделирующую карточную игру "Пьяница" и определяющую, кто из двух игроков выигрывает - C++
помогите. Я не могу понять. Пжлст. С++ Игорь с Артуром играют в "Пьяницу". Это такая карточная игра, правила которой описаны ниже. В...

Написать игру на с++ "Балда" 5X5 - C++
Новичок. Не умею писать игры. Помогите написать игру. Или подскажите, что нужно для этого сделать, может похожие источники есть и пр. 1....

После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
ZaDPoTT
0 / 0 / 0
Регистрация: 04.05.2015
Сообщений: 4
05.05.2015, 20:34     Как написать игру "Цепь"? #21
Наконец эта адская головоломка заработала спасибо большое очень спас меня
Mr.X
Эксперт С++
3042 / 1687 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
06.05.2015, 15:14     Как написать игру "Цепь"? #22
Мой вариант шайтан-программы (первая часть):
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 );
    }
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
06.05.2015, 15:15     Как написать игру "Цепь"?
Еще ссылки по теме:

написать игру "кости" - C++
написать игру &quot;кости&quot; у компьютера и пользователя по 100 игровой валюты ставку делает компьютер потом пользователь

Как на C++ сделать игру "Нужна вода" (Need Water)? - C++
Хочу написать игру &quot;Нужна Вода&quot; http://onlinegamesfree.ru/game/need_water и возникло несколько вопросов 1. Какие игровые движки и...

Как можно реализовать на C++ "Игру жизни Конвея" (Conway's Game of Life)? - C++
как реализовать игру конвея жизнь в с++,подскажите какие-то треды посвященные этому и т.п

Пишу игру "змейка". Есть вопрос по ней - C++
Я сейчас пишу игру &quot;змейка&quot;. (в консоли), но возникла одна проблема. Направление движения от пользователя я принимаю так: раз в секунду...

Создать игру "Кто хочет стать миллионером" на языке С++ пожалуйста - C++
Создать игру &quot;Кто хочет стать миллионером&quot; на языке С++ пожалуйста


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

Или воспользуйтесь поиском по форуму:
Mr.X
Эксперт С++
3042 / 1687 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
06.05.2015, 15:15     Как написать игру "Цепь"? #23
Вторая часть:
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");
}
Yandex
Объявления
06.05.2015, 15:15     Как написать игру "Цепь"?
Ответ Создать тему
Опции темы

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