我的游戏：走迷宫

大家好，其实我的迷宫早已经编好了。但是我一直很懒，没有时间把自己的迷宫程序给大家看看。这回我终于有时间了。我这回一定要给大家一个好的迷宫。

首先大家看看，这个迷宫怎么样？由于我的DirectX图形化编程技术还不过关，因此我只用自己熟悉的win32控制台程序来写迷宫，其中一个堆栈完全是我写的。整个工作都是我做的，我希望能够把它完成，并且最终成为一个DirectX图形化程序。

 首先介绍我的头文件JStackDefine.h，这个头文件定义了我的数据结构：堆栈。堆栈也称栈，是一种比较重要的数据结构，在走迷宫中尤以得到应用。由于考虑到了重用性，所以使用了模板。但是使用模板时会有一个问题，请大家继续往下看。

 

 

Code:

1. #ifndef _J_DEFINE_H_   
2. #define _J_DEFINE_H_   
3. //Using C++ style   
4. template<typename CustomType>//可将任意类型应用于此   
5. struct CustomStruct   
6. {   
7.  CustomType elem;   
8.  CustomStruct* link;   
9. };   
10. template<typename CustomType>   
11. class JStack   
12. {   
13. public:   
14.  JStack():base(NULL),top(NULL),JStackSize(NULL){}//默认构造函数   
15.  ~JStack(){}//默认析构函数   
16.  bool IsEmpty( void );//判断是否为空栈   
17.  CustomType GetTop( void );//取出栈顶的元素   
18.  CustomType Pop( void );//将元素从栈中弹出   
19.  bool Push(CustomType e);//将元素压入栈顶   
20. private:   
21.  CustomStruct<CustomType>* base;//栈底   
22.  CustomStruct<CustomType>* top;//栈顶   
23.  int JStackSize;//栈的元素个数   
24. };//栈结构的定义   
25. #endif   

接下来我要介绍的是JStackDefine.cpp文件。这个文件包含的是我的类的实现。这样做是为了满足定义和实现的分离，这是一种很好方式。以后希望大家能够使用。这个文件仅仅定义了三个函数模板：判断是否为空栈、将元素压入栈、将元素弹出栈和获取栈顶元素。

Code:

1. #include "JStackDefine.h"   
2.   
3. template<typename CustomType>   
4. bool JStack<CustomType>::IsEmpty( void )//判断是否为空栈   
5. {   
6.  if ( top == base )   
7.   return true;   
8.  return false;   
9. }   
10.   
11. template<typename CustomType>   
12. bool JStack<CustomType>::Push(CustomType e)//将元素压入栈顶   
13. {   
14.  CustomStruct<CustomType>* temp;   
15.  temp = top;   
16.  top = new CustomStruct<CustomType>;   
17.  if ( !top )   
18.   return false;   
19.  top->elem = e;   
20.  top->link = temp;   
21.  JStackSize++;   
22.  return true;   
23. }//此方法相当于头插法   
24.   
25. template<typename CustomType>   
26. CustomType JStack<CustomType>::Pop( void )//将元素从栈中弹出   
27. {   
28.  CustomStruct<CustomType> temp;   
29.  temp.elem = top->elem;   
30.  temp.link = top->link;   
31.  delete top;   
32.  top = temp.link;   
33.  JStackSize--;   
34.  return temp.elem;   
35. }   
36.   
37. template<typename CustomType>   
38. CustomType JStack<CustomType>::GetTop( void )//取出栈顶的元素   
39. {   
40.  return top->elem;   
41. }   
42.   

 

 使用这个cpp的时候注意，因为仅仅是定义的是函数模板，如果要进行实例化的话，你仍然要在使用的时候包含这个文件，因为系统不会一边寻找h文件对应cpp文件一边帮你实例化的，这一点我在论坛上也没有看到满意的解释。但是他们就是说必须这样的，这里我给的解释应该是合理的。待会儿我告诉大家怎样处理这样的情况。

 

 讲到这里，我觉得好像忘记了什么...对啦，原来我没有给大家介绍一个大体的框架，这怎么办...好吧，我把图截下来，给大家看看我这个程序总共有多少文件。

 大家看到了吧，我的这个项目有6个文件。如果你们喜欢的话，完全可以写在一个文件中。但是这样做是不符合软件工程的要求的。所以我就把它写在了六个文件中，这样的话，调用关系很清晰，也很容易找代码。

 

 

 那么接下来我要向大家介绍的是MazeDefine.h文件。这个文件很简单，只有一条包含语句。

Code:

1. #ifndef _J_MAZEDEFINE_H_   
2. #define _J_MAZEDEFINE_H_   
3.   
4. #include "MazeAutoCreate.h"   
5.   
6. #endif   
7.   

 

 那么它所包含的头文件是什么样子呢？让我们转到MazeAutoCreate.h文件中去。

Code:

1. #ifndef _J_MAZEAUTOCREATE_H_   
2. #define _J_MAZEAUTOCREATE_H_   
3.   
4. //M N must be odd numbers for it can be process correctly   
5. #define M 23   
6. #define N 39   
7.   
8. struct Maze   
9. {   
10.  int i, j;   
11.  int state;   
12. };   
13.   
14. void MazeAutoCreate( void );   
15. void MazeInitialize( void );   
16. void MazeShow( void );   
17.   
18. int GetRandom( int seed );   
19. void RandomPath( void );   
20. #endif   
21.   

 这个文件中有对迷宫的定义，其中横坐标M纵坐标N的值必须为奇数。这样做是为了显示的美观。然后定义了一个结构体Maze，这里有横坐标、纵坐标和状态。其中状态有1——走得通，0——走不通，2为入口和出口。然后在MazeAutoCreate()函数中我会对堆栈这个存储结构和数据进行频繁地调用我的堆栈成员函数。MazeInitialize()函数主要是初始化Maze对象的。如果你想再来一次的话，可以调用这个函数。MazeShow()函数主要是显示当前的迷宫。另外GetRandom()函数主要是模拟随机数的生成。这里优化的代码没有使用rand()和srand()函数，没有了这两个函数，我发现我的迷宫效率有着飞速的提高。RandomPath()函数主要处理的是自动走迷宫的问题。事实上，这个函数是最长的。

 自动创建的迷宫是怎么实现的呢？让我们来看看MazeAutoCreate.cpp。

Code:

1. #include <iostream>   
2. #include <ctime>   
3.   
4. #include "JStackDefine.h"   
5. #include "JStackDefine.cpp"//Essential because template function body needs calling.   
6. #include "MazeAutoCreate.h"   
7.   
8. using namespace std;   
9.   
10. //全局变量   
11. Maze g_m[M][N];   
12. JStack<Maze> g_mStack;   
13.   
14. void MazeAutoCreate( void )   
15. {   
16.  //首先选择一条路   
17.  MazeInitialize();   
18.  RandomPath();   
19.  MazeShow();   
20.   
21.  //MazeClear();//   
22. }   
23. void MazeShow( void )   
24. {   
25.  int i, j;   
26.  //Define the entry and exit   
27.  g_m[0][0].state = g_m[M-1][N-1].state = 2;   
28.   
29.  for (i = 0; i < M; i++)   
30.  {   
31.   for (j = 0; j <N; j++)   
32.    switch ( g_m[i][j].state )   
33.   { //0走不通，1走得通   
34.    case 0:cout<<"■";break;   
35.    case 1:cout<<"  ";break;   
36.    case 2:cout<<"↘";break;   
37.   }   
38.   cout<<'/n';   
39.  }   
40. }   
41.   
42. void MazeInitialize( void )   
43. {   
44.  int i, j;   
45.  for ( i = 0; i < M; i++)   
46.   for ( j = 0; j < N; j++)   
47.   {   
48.    g_m[i][j].i = i;   
49.    g_m[i][j].j = j;   
50.   }   
51.   
52. }   
53.   
54. int GetRandom( int seed )   
55. {   
56.  return time( NULL )/seed%4;   
57. }   
58.   
59. void RandomPath( void )   
60. {   
61.  int i = (M/3)*2, j = (N/3)*2;   
62.  int r = 3;   
63.  Maze temp = { i, j, 0 };//temporary Maze structure   
64.  bool lock[4] = { false, false, false, false };//Four direction lock variable   
65.   
66.  g_m[i][j].state = 1;   
67.  g_mStack.Push( temp );   
68.   
69.  while ( 1 )   
70.  {   
71.   temp.i = i, temp.j = j;   
72.   
73.   switch ( GetRandom( r++ ) )   
74.   {   
75.   case 0:   
76.    if ( lock[0] == false//是否被锁住   
77.     && i > 1 /*是否越界*/  
78.     && g_m[i-2][j].state != 1 /*隔一块是否为空*/  
79.     && g_mStack.GetTop().i != i-2 )/*是否走回头路*/  
80.    { g_mStack.Push( temp ); g_m[i-1][j].state = 1; g_m[i-2][j].state = 1; i-=2; lock[0] = false, lock[1] = false, lock[2] = false, lock[3] = false;/*Move back to false*/}   
81.    else lock[0] = true;   
82.    break;   
83.   
84.   case 1:   
85.    if ( lock[1] == false//是否被锁住   
86.     && i < M-2 /*是否越界*/  
87.     && g_m[i+2][j].state != 1 /*隔一块是否为空*/  
88.     && g_mStack.GetTop().i != i+2 )/*是否走回头路*/  
89.    { g_mStack.Push( temp ); g_m[i+1][j].state = 1; g_m[i+2][j].state = 1; i+=2; lock[0] = false, lock[1] = false, lock[2] = false, lock[3] = false;/*Move back to false*/}   
90.    else lock[1] = true;   
91.    break;   
92.   case 2:   
93.    if ( lock[2] == false//是否被锁住   
94.     && j > 1 /*是否越界*/  
95.     && g_m[i][j-2].state != 1 /*隔一块是否为空*/  
96.     && g_mStack.GetTop().j != j-2 )/*是否走回头路*/  
97.    { g_mStack.Push( temp ); g_m[i][j-1].state = 1; g_m[i][j-2].state = 1; j-=2; lock[0] = false, lock[1] = false, lock[2] = false, lock[3] = false;/*Move back to false*/}   
98.    else lock[2] = true;   
99.    break;   
100.   case 3:   
101.    if ( lock[3] == false//是否被锁住   
102.     && j < N-2 /*是否越界*/  
103.     && g_m[i][j+2].state != 1 /*隔一块是否为空*/  
104.     && g_mStack.GetTop().j != j+2 )/*是否走回头路*/  
105.    { g_mStack.Push( temp ); g_m[i][j+1].state = 1; g_m[i][j+2].state = 1; j+=2; lock[0] = false, lock[1] = false, lock[2] = false, lock[3] = false;/*Move back to false*/}   
106.    else lock[3] = true;   
107.    break;   
108.   }   
109.   
110.   if ( lock[0] == true && lock[1] ==true && lock[2] == true && lock[3] == true )   
111.   {   
112.    if ( g_mStack.IsEmpty() == true )   
113.     return;   
114.    else    
115.    {   
116.     i = g_mStack.GetTop().i;   
117.     j = g_mStack.GetTop().j;   
118.     g_mStack.Pop();   
119.     lock[0] = false, lock[1] = false, lock[2] = false, lock[3] = false;//Move back to false   
120.    }   
121.   }   
122.  }   
123. }   
124.   

 当然，作为自动生成迷宫，时间函数当然是要使用的。注意第五行，我特意加上了英文注释，因为这条语句正如我以前所说，是很有用的，在对类模板进行实例化后必须要包含函数模板，这样编译器才能顺利地通过。在这里我重点介绍RandomPath()这个函数。这个函数这一句“int i = (M/3)*2, j = (N/3)*2;”为的是让初始的元素在迷宫的中间处循环而不是在（0,0）处。这一句也是非常重要的“bool lock[4] = { false, false, false, false };//Four direction lock variable”，因为如果循环的时候向贪食蛇一样的撞向自己以前开辟的道路的话，那该怎么办呢？所以我们要避免这个情况。这里定义了四个方向的锁。如果一个方向走不通了，就必须将这个方向锁住，然后再选择走另一个方向。如果四个方向都走不通的话，就表明已经死锁了，这样如果不采取措施的话，就会陷入死循环，迷宫就再也不会出来了。所以要设一句条件句，如果发生了死锁的话，弹出栈顶元素，并且解除锁，再进行随机数的取值。这条语句就是
if ( lock[0] == true && lock[1] ==true && lock[2] == true && lock[3] == true )
  {
   if ( g_mStack.IsEmpty() == true )
    return;
   else
   {
    i = g_mStack.GetTop().i;
    j = g_mStack.GetTop().j;
    g_mStack.Pop();
    lock[0] = false, lock[1] = false, lock[2] = false, lock[3] = false;//Move back to false
   }
  }
 可能大家还是不明白我的思想，我其实是这样想的。首先我们走的是一条全是墙的空迷宫，然后又计算机自己随便选择上下左右地走两格，并把自己的足迹设为可走，如果要往前可走的路不能走的话，那么就重新地去随机数。不要看“if ( lock[1] == false//是否被锁住
    && i < M-2 /*是否越界*/
    && g_m[i+2][j].state != 1 /*隔一块是否为空*/
    && g_mStack.GetTop().i != i+2 )/*是否走回头路*/”这些判断句子很简单，其实这些都是我的优化算法。它们的排列顺序的不同是影响到执行的效率的（因为与&&运算规则是如果前面一个是假，那么后面的判断将不会执行了。）。随机取道路函数结束后，最后就要显示迷宫的内容了，这个很简单，是什么状态就显示什么的符号。

 

 最后我就要介绍的是我的主函数MainFrame.cpp了。

Code:

1. #include <cstdlib>   
2. #include "MazeDefine.h"   
3.   
4. //主函数   
5. int main( int argc, char** argv )   
6. {   
7.  MazeAutoCreate();   
8.  system("pause");   
9.  return 0;   
10. }   
11.   

 这个函数很简单吧，我就不再介绍了。

 最后希望大家能够支持我的工作，如果大家觉得好的话，不忘给我表个态。当然我还是希望自己的迷宫能够成功地移植到win32应用程序中。这样我的第一个像样的DirectX也总算有个雏形了。

更新于10月22日：在ubuntu操作系统下（我使用的ubuntu操作系统的版本是9.10），使用终端（terminal），再使用gcc对这些程序进行编译，也可以显示迷宫。这说明这个迷宫的雏形是可以跨平台的。