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

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

Войти
Регистрация
Восстановить пароль
 
Рейтинг: Рейтинг темы: голосов - 9, средняя оценка - 4.78
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
#1

Лабиринт - C++

11.02.2010, 13:05. Просмотров 1266. Ответов 8
Метки нет (Все метки)

Вообщем у меня 2 проблемы:
1) Либирнт генерирует 2 раза
2) '8' ходит как хочит
Поправте плз код
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
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
 
void Flip(char& x, char& y){
    char temp = x;
    x = y;
    y = temp;
}
 
 
 int main()
{
    int newX;
    const int N = 10;
    const int WALL = '#';
    char Map[N][N] = {{1,1,0,0,0,0,0,0,0,0},
                {0,1,0,0,0,0,0,0,0,0},
                {0,1,1,0,0,0,0,0,0,0},
                 {0,0,1,0,0,0,0,0,0,0},
                {0,0,1,1,1,1,1,0,0,0},
                {0,0,0,0,0,0,1,0,0,0},
                {0,0,0,0,0,0,1,0,0,0},
                {0,0,0,0,0,0,1,0,0,0},
                {0,0,0,0,0,0,1,1,1,1},
                 {0,0,0,0,0,0,0,0,0,0}};
    Map[0][0] = 8;
    int curX = 0, curY = 0;
    int grade;
 
    while ((grade = std::cin.get() ) != 69 ){
    for (int i = 0; i < N; i++){
        for (int j = 0; j < N; j++){
             std::cout << (int)Map[i][j];
        }
        std::cout << "\n";
    }
    switch (grade){
    
        case 'W' : case 'w' :{
        int newX = curX - 1;
         if ( ( newX >= 0 ) && ( newX < N ) )
            if ( Map[newX][curY] != WALL ){
                Flip(Map[newX][curY], Map[curX][curY]);
                curX = newX;
            }
        }
         break;
    
        case 'S' : case 's' :{
        int newX = curX + 1;
        if ( ( newX >= 0 ) && ( newX < N ) )
            if ( Map[newX][curY] != WALL ){
                Flip(Map[newX][curY], Map[curX][curY]);
                 curX = newX;
            }
        }
        break;
    
        case 'D' : case 'd' :{
        int newY = curY + 1;
        if ( ( newY >= 0 ) && ( newY < N ) )
             if ( Map[curX][newY] != WALL ){
                Flip(Map[curX][newY], Map[curX][curY]);
                curX = newX;
                }
        }
        break;
    
        case 'A' : case 'a' :{
         int newY = curY - 1;
        if ( ( newY >= 0 ) && ( newY < N ) )
            if ( Map[curX][newY] != WALL ){
                Flip(Map[curX][newY], Map[curX][curY]);
                curX = newX;
             }
        }
        break;
        default:
            std::cout << std::endl;
        
    }
    }
    return 0;
}
Добавлено через 1 час 16 минут
1) Осталося только сделать что б 0 это стенка а 1 это тунель
2) Что б лабиринт выводился 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
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
 
void Flip(char& x, char& y){
    char temp = x;
    x = y;
    y = temp;
}
 
 
int main()
{
    const int N = 10;
    const int WALL = '#';
    char Map[N][N] = {{1,1,0,0,0,0,0,0,0,0},
              {0,1,0,0,0,0,0,0,0,0},
              {0,1,1,0,0,0,0,0,0,0},
              {0,0,1,0,0,0,0,0,0,0},
              {0,0,1,1,1,1,1,0,0,0},
              {0,0,0,0,0,0,1,0,0,0},
              {0,0,0,0,0,0,1,0,0,0},
              {0,0,0,0,0,0,1,0,0,0},
              {0,0,0,0,0,0,1,1,1,1},
              {0,0,0,0,0,0,0,0,0,0}};
    Map[0][0] = 8;
    int curX = 0, curY = 0;
    int grade;
 
    while ((grade = std::cin.get() ) != 69 ){
            for (int i = 0; i < N; i++){
                for (int j = 0; j < N; j++){
                    std::cout << (int)Map[i][j];
                }
                std::cout << "\n";
            }
 
        switch (grade){
    
            case 'W' : case 'w' :{
            int newX = curX - 1;
            if ( ( newX >= 0 ) && ( newX < N ) )
                if ( Map[newX][curY] != WALL ){
                    Flip(Map[newX][curY], Map[curX][curY]);
                    curX = newX;
                }
            }
            break;
        
            case 'S' : case 's' :{
            int newX = curX + 1;
            if ( ( newX >= 0 ) && ( newX < N ) )
                if ( Map[newX][curY] != WALL ){
                    Flip(Map[newX][curY], Map[curX][curY]);
                    curX = newX;
                }
            }
            break;
        
            case 'D' : case 'd' :{
            int newY = curY + 1;
            if ( ( newY >= 0 ) && ( newY < N ) )
                if ( Map[curX][newY] != WALL ){
                    Flip(Map[curX][newY], Map[curX][curY]);
                    curY = newY;
                    }
            }
            break;
        
            case 'A' : case 'a' :{
            int newY = curY - 1;
            if ( ( newY >= 0 ) && ( newY < N ) )
                if ( Map[curX][newY] != WALL ){
                    Flip(Map[curX][newY], Map[curX][curY]);
                    curY = newY;
                }
            }
            break;
            default:
                std::cout << std::endl;
            
        }
    }
        return 0;
}
Добавлено через 21 минуту
Осталась только 1 проблема с печатанием лабиринта 2 раза
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
11.02.2010, 13:05
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Лабиринт (C++):

Лабиринт C++ - C++
я написал код лабиринта на c++, с помощью чего можно найти кратчайший путь выхода из лабиринта? #include &lt;iostream&gt; #include...

лабиринт - C++
Всем привет. У меня проблема. В игре лабиринт получается, что каждый ход открывается новый лабиринт, как сделать, что бы он был один и тот...

Лабиринт - C++
Всем привет. Подскажите, вот делаю игру (понятно какую) но проблема. Вот код #include &quot;stdafx.h&quot; #include &lt;iostream&gt; using namespace...

лабиринт - C++
Коридорами лабиринта разрешается двигаться только в направлениях, указанных стрелками. Человек вошел в комнату A и, выбирая случайным...

Лабиринт - C++
#include &lt;iostream&gt; #include &lt;fstream&gt; #include &lt;conio.h&gt; #include &lt;time.h&gt; #include &lt;cmath&gt; #include &lt;stdio.h&gt; using...

Лабиринт с++ - C++
Есть код. только мне не понятен алгоритм который работает в bool PathExists(Labyrinth&amp; lab, int y1, int x1, int y2, int x2) { и...

8
Зоти Сергей
228 / 226 / 13
Регистрация: 18.12.2009
Сообщений: 316
11.02.2010, 14:33 #2
Добавить только #include <conio.h>
нужно будет

C++
1
2
3
4
5
6
7
8
9
 while ((grade = getch()) != 27 ){              //27 - escape можете обратно на 67 поменять
        //clrscr(); я бы добавил еще очистку экрана....
                        for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout <<"\n";
                        }
                 std::cout <<"\n";
0
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
11.02.2010, 14:41  [ТС] #3
Цитата Сообщение от Зоти Сергей Посмотреть сообщение
Добавить только #include <conio.h>
нужно будет

C++
1
2
3
4
5
6
7
8
9
 while ((grade = getch()) != 27 ){              //27 - escape можете обратно на 67 поменять
        //clrscr(); я бы добавил еще очистку экрана....
                        for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout <<"\n";
                        }
                 std::cout <<"\n";
error: conio: No such file or directory
Я на g++ работаю, да и ещё б выход дорисовать было б не плохо)
0
Зоти Сергей
228 / 226 / 13
Регистрация: 18.12.2009
Сообщений: 316
11.02.2010, 15:17 #4
тоды оставляйте все как у вас было, просто, чтобы 2 раза не печаталось нужно очистить stdin
C++
1
2
3
4
5
6
7
8
 while ((grade = std::cin.get() ) != 69 ){
                        for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout << "\n";
                        }
fflush(stdin);
2 раза печатается, потому, что вы при после нажатия "a" "s" "d".. все время ввод жмете. а это тоже клавиша, которая обрабатывается в следующем цикле.
1
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
11.02.2010, 15:35  [ТС] #5
Во спс, а если я хочу сделать трудно проходимые месте, ну как бы стенка которую можно открыть если только пройти определённый квадрат. И как выход написать, а то я пытался, что то не выходит

Добавлено через 13 минут
Вообщем надо как то вписать что 3 открывает барьер, и 9 это выход.
Вот что мы имеем:
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
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
 
void Flip(char& x, char& y){
    char temp = x;
    x = y;
    y = temp;
}
 
 
int main()
{
    const int N = 20;
    const int WALL = 0;
    const int Sten = 5;
    char Map[N][N] = {{1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
              {0,1,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
              {0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
              {0,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0},
              {0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0},
              {0,0,1,1,1,1,1,1,5,3,1,1,1,1,0,0,0,0,0,0},
              {0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
              {0,0,3,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
              {0,0,5,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0},
              {0,0,1,1,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0},
              {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0},
              {1,1,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0},
              {1,0,1,0,0,1,1,1,1,1,1,5,3,1,1,0,0,0,0,0},
              {1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
              {1,0,1,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
              {1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1,0,0},
              {1,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,1,0,0},
              {1,0,0,0,0,0,0,1,1,1,5,3,1,0,0,1,0,1,0,0},
              {1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,3,5,1,9},
              {1,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0}};
    Map[0][0] = 8;
    int curX = 0, curY = 0;
    int grade;
 
    std::cout << "Что бы прерваться нажмите Esc и enter." << std::endl;
    std::cout << "'1' это тунель, '0' стенка, '5' барьер, '9' выход, 3 открыть барьер." << std::endl;
 
 
    while ((grade = std::cin.get() ) != 27 ){
            for (int i = 0; i < N; i++){
                for (int j = 0; j < N; j++){
                    std::cout << (int)Map[i][j];
                }
                std::cout << "\n";  
            }
                std::cout << "\n";
 
        switch (grade){
    
            case 'W' : case 'w' :{
            int newX = curX - 1;
            if ( ( newX >= 0 ) && ( newX < N ) )
                if ( ( Map[newX][curY] != WALL ) && ( Map[newX][curY] != Sten ) ){
                    Flip(Map[newX][curY], Map[curX][curY]);
                    curX = newX;
                }
            }
            break;
        
            case 'S' : case 's' :{
            int newX = curX + 1;
            if ( ( newX >= 0 ) && ( newX < N ) )
                if ( ( Map[newX][curY] != WALL ) && ( Map[newX][curY] != Sten ) ){
                    Flip(Map[newX][curY], Map[curX][curY]);
                    curX = newX;
                }
            }
            break;
        
            case 'D' : case 'd' :{
            int newY = curY + 1;
            if ( ( newY >= 0 ) && ( newY < N ) )
                if ( ( Map[curX][newY] != WALL ) && ( Map[curX][newY] != Sten ) ){
                    Flip(Map[curX][newY], Map[curX][curY]);
                    curY = newY;
                    }
            }
            break;
        
            case 'A' : case 'a' :{
            int newY = curY - 1;
            if ( ( newY >= 0 ) && ( newY < N ) )
                if ( ( Map[curX][newY] != WALL ) && ( Map[curX][newY] != Sten ) ){
                    Flip(Map[curX][newY], Map[curX][curY]);
                    curY = newY;
                }
            }
            break;
            default:
                std::cout << std::endl;
            
        }
 
    }
        return 0;
}
0
Зоти Сергей
228 / 226 / 13
Регистрация: 18.12.2009
Сообщений: 316
11.02.2010, 16:03 #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
#include <iostream.h>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
 
 
 
void Flip(char& x, char& y){
        char temp = x;
        x = y;
        y = temp;
}
 
 
int main()
{
 
        const int N = 20;
        const int WALL = 0;
        const int Sten = 5;
        char Map[N][N] = {{1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {0,1,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
                          {0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
                          {0,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0},
                          {0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0},
                          {0,0,1,1,1,1,1,1,5,3,1,1,1,1,0,0,0,0,0,0},
                          {0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {0,0,3,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {0,0,5,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0},
                          {0,0,1,1,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0},
                          {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0},
                          {1,1,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0},
                          {1,0,1,0,0,1,1,1,1,1,1,5,3,1,1,0,0,0,0,0},
                          {1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {1,0,1,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
                          {1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1,0,0},
                          {1,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,1,0,0},
                          {1,0,0,0,0,0,0,1,1,1,5,3,1,0,0,1,0,1,0,0},
                          {1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,3,5,1,9},
                          {1,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0}};
 
        Map[0][0] = 8;
        int curX = 0, curY = 0;
        int grade;
 
         for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout << "\n";
                        }
 
        while ((grade = getc(stdin))!='q'){
 
 
 
                switch (grade){
        
                        case 'W' : case 'w' :{
                        int newX = curX - 1;
                        if ( ( newX >= 0 ) && ( newX < N ) )
                                if ( Map[newX][curY] != WALL ){
                                        Flip(Map[newX][curY], Map[curX][curY]);
                                        curX = newX;
                                }
                        }
                        break;
                
                        case 'S' : case 's' :{
                        int newX = curX + 1;
                        if ( ( newX >= 0 ) && ( newX < N ) )
                                if ( Map[newX][curY] != WALL ){
                                        Flip(Map[newX][curY], Map[curX][curY]);
                                        curX = newX;
                                }
                        }
                        break;
                
                        case 'D' : case 'd' :{
                        int newY = curY + 1;
                        if ( ( newY >= 0 ) && ( newY < N ) )
                                if ( Map[curX][newY] != WALL ){
                                        Flip(Map[curX][newY], Map[curX][curY]);
                                        curY = newY;
                                        }
                        }
                        break;
                
                        case 'A' : case 'a' :{
                        int newY = curY - 1;
                        if ( ( newY >= 0 ) && ( newY < N ) )
                                if ( Map[curX][newY] != WALL ){
                                        Flip(Map[curX][newY], Map[curX][curY]);
                                        curY = newY;
                                }
                        }
                        break;
                        default:
                        break;
                                std::cout << std::endl;
 
                        
                }
                for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout << "\n";
                        }
                fflush(stdin);
        }
                return 0;
}
Сейчас посмотрю на счет барьера.. а что вы имеете ввиду под выходом?

Выход из программы?
Если да, то вам можно, например опрашивать нажатие клавиши "q" как в этом примере.
0
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
11.02.2010, 16:10  [ТС] #7
В смысле если достигнуть '9' на ввыдаст Поздравляем вы прошли лабиринт и закроет программу
0
Зоти Сергей
228 / 226 / 13
Регистрация: 18.12.2009
Сообщений: 316
11.02.2010, 17:09 #8
ну на счет 9
просто вставьте проверку, чему сейчас равно значение матрицы по curX,curY


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
switch (grade){
        
                        case 'W' : case 'w' :{
                        int newX = curX - 1;
                        if ( ( newX >= 0 ) && ( newX < N ) )
                                if ( Map[newX][curY] != WALL ){
                                    if((int)Map[newX][curY]==9)
                            {
                                   printf("perfect\n");                                
                                   return 0;
                            }
 
                                        Flip(Map[newX][curY], Map[curX][curY]);
                                        curX = newX;
                                }
                        }
                        break;
                
                        case 'S' : case 's' :{
                        int newX = curX + 1;
                        if ( ( newX >= 0 ) && ( newX < N ) )
                                if ( Map[newX][curY] != WALL ){
                                    if((int)Map[newX][curY]==9)
                            {
                                   printf("perfect\n");                               
                                   return 0;
                            }
                                        Flip(Map[newX][curY], Map[curX][curY]);
                                        curX = newX;
                                }
                        }
                        break;
 
                        case 'D' : case 'd' :{
                        int newY = curY + 1;
                        if ( ( newY >= 0 ) && ( newY < N ) )
                                if ( Map[curX][newY] != WALL ){
                                    if((int)Map[curX][newY]==9)
                            {
                                   printf("perfect\n");                                
                                   return 0;
                            }
                                        Flip(Map[curX][newY], Map[curX][curY]);
                                        curY = newY;
                                        }
                        }
                        break;
 
                        case 'A' : case 'a' :{
                        int newY = curY - 1;
                        if ( ( newY >= 0 ) && ( newY < N ) )
                                if ( Map[curX][newY] != WALL ){
                                    if(Map[curX][newY]==9)
                            {
                                   printf("perfect\n");                                
                                   return 0;
                            }
                                        Flip(Map[curX][newY], Map[curX][curY]);
                                        curY = newY;
                                }
                        }
                        break;
                        default:
                                 std::cout << std::endl;
                        break;
                }
а вот на счет стены... непонятно, куда ее удалять, влево, вправо, вверх, или вниз.
удалять стену полностью, пока не появится снова 1? или удалять ее на один елемент?
0
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
11.02.2010, 17:20  [ТС] #9
error: ‘getch’ was not declared in this scope

Добавлено через 8 минут
Вообщем я додел с твоей помощь спс тебе
Вот образец как все вышло если интересует
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
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
 
 
 
void Flip(char& x, char& y){
        char temp = x;
        x = y;
        y = temp;
}
 
 
int main()
{
 
        const int N = 20;
        const int WALL = 0;
        int Sten = 5;
    const int Open = 3;
    const int Zakr = 2;
    const int Exit = 9;
 
        char Map[N][N] = {{1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {0,1,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
                          {0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
                          {0,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0},
                          {0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0},
                          {0,0,1,1,1,1,1,2,5,3,1,1,1,1,0,0,0,0,0,0},
                          {0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {0,0,3,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {0,0,5,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0},
                          {0,0,2,1,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0},
                          {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0},
                          {1,1,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0},
                          {1,0,1,0,0,1,1,1,1,1,2,5,3,1,1,0,0,0,0,0},
                          {1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                          {1,0,1,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
                          {1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1,0,0},
                          {1,0,1,1,1,1,0,0,0,0,2,0,0,0,0,1,0,1,0,0},
                          {1,0,0,0,0,0,0,1,1,1,5,3,1,0,0,1,0,1,0,0},
                          {1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,1,3,5,2,9},
                          {1,1,1,1,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0}};
 
        Map[0][0] = 8;
        int curX = 0, curY = 0;
        int grade;
 
    std::cout << "'1' это тунель, '0' стенка, '5' барьер, '9' выход, '3' открывает барьер, '2' закрыть барьер." << std::endl;
 
         for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout << "\n";
                        }
 
        while ((grade = getc(stdin))!='q'){
     std::cout << "\n"  << "\n"  << "\n";
 
 
                switch (grade){
        
                        case 'W' : case 'w' :{
                        int newX = curX - 1;
                        if ( ( newX >= 0 ) && ( newX < N ) )
                if ( Map[newX][curY] != Open){
                    Sten -= 4;
                }
                    if ( Map[newX][curY] != Zakr ){
                        Sten += 4;
                                    
                    }
                                if ( ( Map[newX][curY] != WALL ) && ( Map[newX][curY] != Sten ) ){
                    if ( Map[newX][curY] == 9)
                                        {
                                               std::cout << "Поздравляем вы прошли лабиринт!" << std::endl;
                                               return 0;
                                        }
                                        Flip(Map[newX][curY], Map[curX][curY]);
                                        curX = newX;
                                }
                        }
                        break;
                
                        case 'S' : case 's' :{
                        int newX = curX + 1;
                        if ( ( newX >= 0 ) && ( newX < N ) )
                if ( Map[newX][curY] != Open){
                    Sten -= 4;
                }
                    if ( Map[newX][curY] != Zakr ){
                        Sten += 4;
                    }
                                if ( ( Map[newX][curY] != WALL ) && ( Map[newX][curY] != Sten ) ){
                    if ( Map[newX][curY] == 9 )
                                        {
                                               std::cout << "Поздравляем вы прошли лабиринт!" << std::endl;
                                               return 0;
                                        }
                                        Flip(Map[newX][curY], Map[curX][curY]);
                                        curX = newX;
                                }
                        }
                        break;
                
                        case 'D' : case 'd' :{
                        int newY = curY + 1;
                        if ( ( newY >= 0 ) && ( newY < N ) )
                if (  Map[curX][newY] != Open){
                    Sten -= 4;
                }
                    if (  Map[curX][newY] != Zakr ){
                        Sten += 4;
                                    
                    }
                                if ( ( Map[curX][newY] != WALL ) && ( Map[curX][newY] != Sten ) ){
                    if ( Map[curX][newY] == 9 )
                                        {
                                               std::cout << "Поздравляем вы прошли лабиринт!" << std::endl;
                                               return 0;
                                        }
                                        Flip(Map[curX][newY], Map[curX][curY]);
                                        curY = newY;
                                        }
                        }
                        break;
                
                        case 'A' : case 'a' :{
                        int newY = curY - 1;
                        if ( ( newY >= 0 ) && ( newY < N ) )
                if ( Map[curX][newY] != Open){
                    Sten -= 4;
                }
                    if ( Map[curX][newY] != Zakr ){
                        Sten += 4;
                                    
                    }
                                if ( ( Map[curX][newY] != WALL ) && ( Map[curX][newY] != Sten ) ){
                                        if ( Map[curX][newY] == 9 )
                                        {
                                               std::cout << "Поздравляем вы прошли лабиринт!" << std::endl;
                                               return 0;
                                        }
                                        Flip(Map[curX][newY], Map[curX][curY]);
                                        curY = newY;
 
                                }
                        }
                        break;
                        default:
                        break;
                                std::cout << std::endl;
 
                        
                }
                for (int i = 0; i < N; i++){
                                for (int j = 0; j < N; j++){
                                        std::cout << (int)Map[i][j];
                                }
                                std::cout << "\n";
                        }
                fflush(stdin);
        }
                return 0;
}
0
11.02.2010, 17:20
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
11.02.2010, 17:20
Привет! Вот еще темы с ответами:

Лабиринт - C++
Помогите пожалуйста: Создать игру «Лабиринт». Игра состоит из 2 уровней (лабиринтов), отличающихся по сложности. Лабиринты появляются...

Лабиринт - C++
Народ помогите! есть задание: Лабиринт представляет собой квадрат, состоящий из NxN сегментов. Каждый из сегментов может быть либо...

Двумерный лабиринт - C++
Всем здраствуйте. Пожалуйста посоветуйте что-нибудь). Так же как и автор этой темы начал учить C++. Сам по книгам, это мой первый язык...

игра лабиринт - C++
Есть код игры Смайлик движется по лабиринту с помощью нажатия клавиш, есть два смайлика врага (один движется по вертикали, второй по...


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

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

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