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

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

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 9, средняя оценка - 4.78
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
11.02.2010, 13:05     Лабиринт #1
Вообщем у меня 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 раза
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
11.02.2010, 13:05     Лабиринт
Посмотрите здесь:

Лабиринт C++
C++ Лабиринт
C++ лабиринт
Лабиринт с++ C++
Лабиринт с телепортами на C++ C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Зоти Сергей
 Аватар для Зоти Сергей
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";
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++ работаю, да и ещё б выход дорисовать было б не плохо)
Зоти Сергей
 Аватар для Зоти Сергей
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".. все время ввод жмете. а это тоже клавиша, которая обрабатывается в следующем цикле.
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;
}
Зоти Сергей
 Аватар для Зоти Сергей
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" как в этом примере.
ByHbKa
0 / 0 / 0
Регистрация: 27.10.2009
Сообщений: 29
11.02.2010, 16:10  [ТС]     Лабиринт #7
В смысле если достигнуть '9' на ввыдаст Поздравляем вы прошли лабиринт и закроет программу
Зоти Сергей
 Аватар для Зоти Сергей
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? или удалять ее на один елемент?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
11.02.2010, 17:20     Лабиринт
Еще ссылки по теме:

Лабиринт C++
C++ Игра Лабиринт
Лабиринт C++ C++

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

Или воспользуйтесь поиском по форуму:
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;
}
Yandex
Объявления
11.02.2010, 17:20     Лабиринт
Ответ Создать тему
Опции темы

Текущее время: 09:22. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru