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

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

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Описать структуру с именем Znak http://www.cyberforum.ru/cpp-beginners/thread581885.html
Здравствуйте. Помогите пожалуйста изменить сортировку а коде. С сортировки по фамилии на сортировку по дате. Заранее спасибо. Вот условие http://www.cyberforum.ru/attachment.php?attachmentid=154076&stc=1&d=1337622184 Код #include "iostream" #include "time.h" #include "conio.h" using namespace std; struct ZNAK {
C++ Задана строка символов. Строка содержит символы английского алфавита, пробелы, точку и запятые. Напишите программу, которая отразит зеркально заданное Задана строка символов. Строка содержит символы английского алфавита, пробелы, точку и запятые. Напишите программу, которая отразит зеркально заданное предложение. Для решения задачи используйте класс string Помогите пожалуйста! Очень нужно :)) Спасибо Вам большое заранее)) http://www.cyberforum.ru/cpp-beginners/thread581881.html
C++ Нет звука в audiere
Добро всем времени суток. Прошу помочь в освоении Audiere, а точнее решить небольшую проблемку. Вот код: AudioDevicePtr soundDevice(OpenDevice()); OutputStreamPtr ourSong(OpenSound(soundDevice,"\Sounds/HbeatN.wav",false)); ourSong->setVolume(0.3f); ourSong->play(); Код взят на этом сайте, компилится все нормально, но при нажатии кнопки, в которой этот код написан, ничего не...
найдите ошибку, программа переворачивающая изображение на 90 градусов C++
класс содержит конструкторы: по умолчанию, с параметром, копировщик; функцию, переворачивающую изображение на 90 градусов по часовой стрелке, и перегруженные операторы записи и считывания BMP.h #pragma once #include <iostream> #include <fstream> using namespace std; typedef unsigned short int word; typedef unsigned int dword;
C++ Найти те члены последовательности, которые при делении на 5 дают остаток 1 http://www.cyberforum.ru/cpp-beginners/thread581858.html
Даны натуральные числа n , g1 , ... ,gn. Найти те члены gi последовательности g1 , ... , gn ,которые при делении на 5 дают остаток 1. Вот в чем у меня ошибка в коде? понять не могу(( Меня еще интересует, правильно ли я написала заполнение массива случайными числами? #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <time.h> int main()
C++ Написать программу, которая выводит все числа Мерсенна Написать программу, которая выводит все числа Мерсенна от 1 до n. Простое число называется числом Мерсенна, если его можно представить в виде {2}^{p}-1, где p - тоже простое число. подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
3048 / 1693 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
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 );
    }
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru