Форум программистов, компьютерный форум, киберфорум
Наши страницы

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

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

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

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

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

Базовый класс "Источник напряжения", производные классы "Цепь" и "Аккумулятор" - C++
Дали задачу по программированию: составить класс "Источник напряжения", для которого нужно реализовать два производных класса: "Цепь" и...

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

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

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

Надо написать программу (игру) "Кости". Где ошибка? - C++
Доброго времени. суток. Прошу помочь с решение "проблемы" по написанию программы (игры) в "Кости" на С++ Вот мой код: include...

Написать игру "Угадай число", используя цикл while - C++
ку,нужно написать игру где компьютер угадывает число допустим за 7 попыток,использовать while.

22
UFO94
264 / 253 / 13
Регистрация: 04.04.2012
Сообщений: 546
04.05.2015, 23:19 #16
Там вместо n должно быть size. Ошибочка вышла...
1
ZaDPoTT
0 / 0 / 0
Регистрация: 04.05.2015
Сообщений: 4
05.05.2015, 01:00 #17
ну а вместо столбца
int Pl=q.CheckTurn()+1;
что должно бить?

Добавлено через 3 минуты
[Error] 'class Field' has no member named 'CheckTurn'

Добавлено через 37 секунд
while((vert<1)||(vert>size)||(gor<1)||(gor>size)||(!q.Turn(Pl,vert,gor)))
здесь ошибка в инт мейне
[Error] 'size' was not declared in this scope

Добавлено через 1 минуту
а так замена n на size помогло спасибо

Добавлено через 3 минуты
заменил int Pl=q.CheckTurn()+1;
на int Pl=q.IsVictory()+1;
и добавил int size;
но после ввода размера поля пишет просто DRAW

Добавлено через 1 минуту
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
#include <stdio.h>
#include <conio.h>
 
class Field
{
private:
int size;
int* *f;
public:
Field(int n)
{
size=n;
f=new int*[n];
for(int i=0; i<n; i++)
{
f[i]=new int[n];
for(int j=0; j<n; j++)
f[i][j]=0;
}
}
void DrawF()
{
for(int i=0; i<size+2; i++)
printf("-");
printf("\n");
for(int i=0; i<size; i++)
{
printf("|");
for(int j=0; j<size; j++)
if(f[i][j]==0)
printf(" ");
else if(f[i][j]==1)
printf("X");
else printf("O");
printf("|\n");
}
for(int i=0; i<size+2; i++)
printf("-");
printf("\n");
}
bool Turn(int Player, int Vert, int Gor)
{
if(f[Vert][Gor]==0)
{
f[Vert][Gor]=Player;
return true;
}
return false;
}
int IsVictory()
{
bool IsChanges=false;
for(int i=0; i<size; i++)
{
for(int j=0; j<size; j++)
if(f[i][j]==0)
{
IsChanges=true;
break;
}
if(IsChanges==true)
break;
}
if(IsChanges==false)
return 3;
bool* *tmp=new bool*[size];
for(int i=0; i<size; i++)
{
tmp[i]=new bool[size];
for(int j=0; j<size; j++)
tmp[i][j]=false;
}
for(int i=0; i<size; i++)
if(f[0][i]==1)
tmp[0][i]=true;
IsChanges=false;
for(int i=0; i<size*size; i++)
{
IsChanges=false;
for(int j=1; j<size; j++)
{
for(int k=0; k<size; k++)
{
if((f[j][k]==1)&&((tmp[j-1][k]==true)||((k>0)&&(tmp[j][k-1]==true))||((k<size-1)&&(tmp[j][k+1]==true))||((j<size-1)&&(tmp[j+1][k]==true))))
{
tmp[j][k]=true;
IsChanges=true;
}
}
}
if(IsChanges==false)
break;
}
IsChanges=false;
for(int i=0; i<size; i++)
if(tmp[size-1][i]==true)
{
IsChanges=true;
break;
}
if(IsChanges==true)
return 1;
for(int i=0; i<size; i++)
for(int j=0; j<size; j++)
tmp[i][j]=false;
for(int i=0; i<size; i++)
if(f[i][0]==2)
tmp[i][0]=true;
for(int i=0; i<size*size; i++)
{
IsChanges=false;
for(int j=1; j<size; j++)
{
for(int k=0; k<size; k++)
{
if((f[k][j]==2)&&((tmp[k][j-1]==true)||((k>0)&&(tmp[k-1][j]==true))||((k<size-1)&&(tmp[k+1][j]==true))||((j<size-1)&&(tmp[k][j+1]==true))))
{
tmp[k][j]=true;
IsChanges=true;
}
}
}
if(IsChanges==false)
break;
}
IsChanges=false;
for(int i=0; i<size; i++)
if(tmp[i][size-1]==true)
{
IsChanges=true;
break;
}
if(IsChanges==true)
return 2;
return 0;
}
~Field()
{
delete f;
}
};
int main()
{
printf("Input size of gaming field\n");
int n;
scanf("%d",&n);
Field q(n);
while(q.IsVictory()!=0)
{
int Pl=q.IsVictory()+1;
printf("Player %d\n\n",Pl);
q.DrawF();
printf("\n");
printf("Input vertical and gorizontal coordinates\n");
int vert=0;
int gor=0;
int size=0;
while((vert<1)||(vert>size)||(gor<1)||(gor>size)||(!q.Turn(Pl,vert,gor)))
{
scanf("%d%d",&vert,&gor);
}
printf("\n");
q.DrawF();
printf("-------------------------\n");
}
if(q.IsVictory()==1)
printf("1-ST PLAYER WINS!\n");
else if(q.IsVictory()==2)
printf("2-ND PLAYER WINS!\n");
else
printf("DRAW\n");
getch();
return 0;
}
Добавлено через 8 минут
пробовал в OpenGL не получилось
0
UFO94
264 / 253 / 13
Регистрация: 04.04.2012
Сообщений: 546
05.05.2015, 01:38 #18
В мэйне: n и size обозначают одно и то же, это я по невнимательности. Так что или все n в мэйне надо переименовать в size, или все size в n.
По CheckTurn: эта (так и не написанная мною) функция должна возвращать 0, если сейчас должен ходить 1-й игрок (количество 0 и Х на поле одинаковое), и 1 -- если сейчас должен ходить 2-й игрок (Х на 1 больше, чем 0). Код примерно такой (в классе Field, после "public:"):
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int CheckTurn()
{
   int dif = 0;
   for(int i = 0; i < size; i++)
      for(int j = 0; j < size; j++)
         if(f[i][j] == 1)
            dif++;
         else if(f[i][j] == 2)
            dif--;
 
   if(dif == 0)
      return 0;
   if(dif == 1)
      return 1;
   return -1;//Ошибка! Невозможное состояние поля!
}
Добавлено через 4 минуты
Кажется, в мэйне еще ошибка в 10 строчке:
while(q.IsVictory()!=0) нужно заменить на while(q.IsVictory()==0)
1
ZaDPoTT
0 / 0 / 0
Регистрация: 04.05.2015
Сообщений: 4
05.05.2015, 17:31 #19
Опять ошибка после ввода поля и координат не работает

Добавлено через 2 минуты
Есть поле но оно не заполняется(

Добавлено через 1 минуту
После удаления
C++
1
2
3
4
5
6
if(q.IsVictory()==1)
printf("1-ST PLAYER WINS!\n");
else if(q.IsVictory()==2)
printf("2-ND PLAYER WINS!\n");
else
printf("DRAW\n");
выбывает второе поле но тоже ничего

Добавлено через 4 минуты
если не тяжело не могли бы вы скинуть образец который работает

Добавлено через 6 минут
вот что получилось
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
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
#include <stdio.h>
#include <conio.h>
 
class Field
{
private:
int size;
int* *f;
public:
    int CheckTurn()
{
   int dif = 0;
   for(int i = 0; i < size; i++)
      for(int j = 0; j < size; j++)
         if(f[i][j] == 1)
            dif++;
         else if(f[i][j] == 2)
            dif--;
 
   if(dif == 0)
      return 0;
   if(dif == 1)
      return 1;
   return -1;//??????! ??????????? ????????? ????!
}
Field(int n)
{
size=n;
f=new int*[n];
for(int i=0; i<n; i++)
{
f[i]=new int[n];
for(int j=0; j<n; j++)
f[i][j]=0;
}
}
void DrawF()
{
for(int i=0; i<size+2; i++)
printf("-");
printf("\n");
for(int i=0; i<size; i++)
{
printf("|");
for(int j=0; j<size; j++)
if(f[i][j]==0)
printf(" ");
else if(f[i][j]==1)
printf("X");
else printf("O");
printf("|\n");
}
for(int i=0; i<size+2; i++)
printf("-");
printf("\n");
}
bool Turn(int Player, int Vert, int Gor)
{
if(f[Vert][Gor]==0)
{
f[Vert][Gor]=Player;
return true;
}
return false;
}
int IsVictory()
{
bool IsChanges=false;
for(int i=0; i<size; i++)
{
for(int j=0; j<size; j++)
if(f[i][j]==0)
{
IsChanges=true;
break;
}
if(IsChanges==true)
break;
}
if(IsChanges==false)
return 3;
bool* *tmp=new bool*[size];
for(int i=0; i<size; i++)
{
tmp[i]=new bool[size];
for(int j=0; j<size; j++)
tmp[i][j]=false;
}
for(int i=0; i<size; i++)
if(f[0][i]==1)
tmp[0][i]=true;
IsChanges=false;
for(int i=0; i<size*size; i++)
{
IsChanges=false;
for(int j=1; j<size; j++)
{
for(int k=0; k<size; k++)
{
if((f[j][k]==1)&&((tmp[j-1][k]==true)||((k>0)&&(tmp[j][k-1]==true))||((k<size-1)&&(tmp[j][k+1]==true))||((j<size-1)&&(tmp[j+1][k]==true))))
{
tmp[j][k]=true;
IsChanges=true;
}
}
}
if(IsChanges==false)
break;
}
IsChanges=false;
for(int i=0; i<size; i++)
if(tmp[size-1][i]==true)
{
IsChanges=true;
break;
}
if(IsChanges==true)
return 1;
for(int i=0; i<size; i++)
for(int j=0; j<size; j++)
tmp[i][j]=false;
for(int i=0; i<size; i++)
if(f[i][0]==2)
tmp[i][0]=true;
for(int i=0; i<size*size; i++)
{
IsChanges=false;
for(int j=1; j<size; j++)
{
for(int k=0; k<size; k++)
{
if((f[k][j]==2)&&((tmp[k][j-1]==true)||((k>0)&&(tmp[k-1][j]==true))||((k<size-1)&&(tmp[k+1][j]==true))||((j<size-1)&&(tmp[k][j+1]==true))))
{
tmp[k][j]=true;
IsChanges=true;
}
}
}
if(IsChanges==false)
break;
}
IsChanges=false;
for(int i=0; i<size; i++)
if(tmp[i][size-1]==true)
{
IsChanges=true;
break;
}
if(IsChanges==true)
return 2;
return 0;
}
~Field()
{
delete f;
}
};
int main()
{
printf("Input size of gaming field\n");
int n;
scanf("%d",&n);
Field q(n);
while(q.IsVictory()==0);
{
int Pl=q.CheckTurn()+1;
printf("Player %d\n\n",Pl);
q.DrawF();
printf("\n");
printf("Input vertical and gorizontal coordinates\n");
int vert=0;
int gor=0;
int size=0;
while((vert<1)||(vert>size)||(gor<1)||(gor>size)||(!q.Turn(Pl,vert,gor)))
{
scanf("%d%d",&vert,&gor);
}
printf("\n");
q.DrawF();
printf("-------------------------\n");
}
if(q.IsVictory()==1)
printf("1-ST PLAYER WINS!\n");
else if(q.IsVictory()==2)
printf("2-ND PLAYER WINS!\n");
else
printf("DRAW\n");
getch();
return 0;
}
Добавлено через 1 минуту
БУДУ СИЛЬНО БЛАГОДАРЕН ЗА ОБРАЗЕЦ)

Добавлено через 4 минуты
ТОКА РОБОЧИЙ

Добавлено через 2 часа 11 минут
С другими проектами у меня проблем нету но этот меня уже достал логику я понял но прописать ее в коде для меня большая проблема
0
UFO94
264 / 253 / 13
Регистрация: 04.04.2012
Сообщений: 546
05.05.2015, 19:05 #20
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
#include <stdio.h>
#include <conio.h>
 
class Field
{
private:
    int size;
    int* *f;
public:
    int CheckTurn()
    {
        int dif = 0;
        for(int i = 0; i < size; i++)
            for(int j = 0; j < size; j++)
                if(f[i][j] == 1)
                    dif++;
                else if(f[i][j] == 2)
                    dif--;
 
        if(dif == 0)
            return 0;
        if(dif == 1)
            return 1;
        return -1;//??????! ??????????? ????????? ????!
    }
    Field(int n)
    {
        size=n;
        f=new int*[n];
        for(int i=0; i<n; i++)
        {
            f[i]=new int[n];
            for(int j=0; j<n; j++)
                f[i][j]=0;
        }
    }
    void DrawF()
    {
        printf("/");
        for(int i=0; i<size-1; i++)
        {
            printf("X ");
        }
        printf("X\\");
        printf("\n");
        for(int i=0; i<size; i++)
        {
            printf("O");
            for(int j=0; j<size; j++)
            {
                if(f[i][j]==0)
                    printf(" ");
                else if(f[i][j]==1)
                    printf("X");
                else printf("O");
                if(j!=size-1)
                    printf(" ");
            }
            printf("O\n");
        }
        printf("\\");
        for(int i=0; i<size-1; i++)
        {
            printf("X ");
        }
        printf("X/");
    }
    bool Turn(int Player, int Vert, int Gor)
    {
        if(f[Vert-1][Gor-1]==0)
        {
            f[Vert-1][Gor-1]=Player;
            return true;
        }
        return false;
    }
    int IsVictory()
    {
        bool IsChanges=false;
        for(int i=0; i<size; i++)
        {
            for(int j=0; j<size; j++)
                if(f[i][j]==0)
                {
                    IsChanges=true;
                    break;
                }
                if(IsChanges==true)
                    break;
        }
        if(IsChanges==false)
            return 3;
        bool* *tmp=new bool*[size];
        for(int i=0; i<size; i++)
        {
            tmp[i]=new bool[size];
            for(int j=0; j<size; j++)
                tmp[i][j]=false;
        }
        for(int i=0; i<size; i++)
            if(f[0][i]==1)
                tmp[0][i]=true;
        IsChanges=false;
        for(int i=0; i<size*size; i++)
        {
            IsChanges=false;
            for(int j=1; j<size; j++)
            {
                for(int k=0; k<size; k++)
                {
                    if((f[j][k]==1)&&((tmp[j-1][k]==true)||((k>0)&&(tmp[j][k-1]==true))||((k<size-1)&&(tmp[j][k+1]==true))||((j<size-1)&&(tmp[j+1][k]==true))))
                    {
                        tmp[j][k]=true;
                        IsChanges=true;
                    }
                }
            }
            if(IsChanges==false)
                break;
        }
        IsChanges=false;
        for(int i=0; i<size; i++)
            if(tmp[size-1][i]==true)
            {
                IsChanges=true;
                break;
            }
            if(IsChanges==true)
                return 1;
            for(int i=0; i<size; i++)
                for(int j=0; j<size; j++)
                    tmp[i][j]=false;
            for(int i=0; i<size; i++)
                if(f[i][0]==2)
                    tmp[i][0]=true;
            for(int i=0; i<size*size; i++)
            {
                IsChanges=false;
                for(int j=1; j<size; j++)
                {
                    for(int k=0; k<size; k++)
                    {
                        if((f[k][j]==2)&&((tmp[k][j-1]==true)||((k>0)&&(tmp[k-1][j]==true))||((k<size-1)&&(tmp[k+1][j]==true))||((j<size-1)&&(tmp[k][j+1]==true))))
                        {
                            tmp[k][j]=true;
                            IsChanges=true;
                        }
                    }
                }
                if(IsChanges==false)
                    break;
            }
            IsChanges=false;
            for(int i=0; i<size; i++)
                if(tmp[i][size-1]==true)
                {
                    IsChanges=true;
                    break;
                }
                if(IsChanges==true)
                    return 2;
                return 0;
    }
    ~Field()
    {
        delete f;
    }
};
int main()
{
    printf("Input size of gaming field\n");
    int size;
    scanf("%d",&size);
    Field q(size);
    while(q.IsVictory()==0)
    {
        int Pl=q.CheckTurn()+1;
        printf("Player %d\n\n",Pl);
        q.DrawF();
        printf("\n");
        printf("Input vertical and gorizontal coordinates\n");
        int vert=0;
        int gor=0;
        while((vert<1)||(vert>size)||(gor<1)||(gor>size)||(!q.Turn(Pl,vert,gor)))
        {
            scanf("%d%d",&vert,&gor);
        }
        printf("\n");
        q.DrawF();
        printf("-------------------------\n");
    }
    if(q.IsVictory()==1)
        printf("1-ST PLAYER WINS!\n");
    else if(q.IsVictory()==2)
        printf("2-ND PLAYER WINS!\n");
    else
        printf("DRAW\n");
    getch();
    return 0;
}
1
ZaDPoTT
0 / 0 / 0
Регистрация: 04.05.2015
Сообщений: 4
05.05.2015, 20:34 #21
Наконец эта адская головоломка заработала спасибо большое очень спас меня
0
Mr.X
Эксперт С++
3051 / 1696 / 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 );
    }
0
Mr.X
Эксперт С++
3051 / 1696 / 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");
}
0
06.05.2015, 15:15
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
06.05.2015, 15:15
Привет! Вот еще темы с ответами:

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

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

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

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


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

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

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