迷宮生成及深度優先搜索遍歷迷宮(OpenGL)

 　　其實以前就寫過一個迷宮的程序和DFS遍歷，不過弄丟了，前幾天閑就重寫了一下。歡迎交流和拍磚。有很多不足的地方也希望大家多指正。

　　迷宮生成的算法來自《計算機圖形學》，也就是這本書：

　　生成迷宮的算法描述如下：

　　由於表示牆使用了up_wall和left_wall兩個矩陣，所以格子的數量要比能顯示出來的多一行一列，否則屏幕最下邊和最右邊是沒有牆的。雖然可以后面畫上，不過我選擇這樣。

 

　　對於迷宮的遍歷使用DFS，另外由於使用了一個visited矩陣表示每個格子是否已經訪問過，所以即使迷宮里存在環也沒有任何影響，不會死循環。

　　

　　另外當時不知道glutPostRedisplay()這玩意兒，所以很蠢的把遍歷的過程設成了DisplayFunc來看遍歷的過程。

　　生成迷宮及DFS遍歷的代碼如下：

 

#include <iostream>
#include <fstream>
#include <stack>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <cstdlib>
using namespace std;

/*Constant And Structures*/
const int SCREEN_WIDTH = 1200;
const int SCREEN_HEIGHT = 600;
const int BLOCK_SIZE = 10;

const int BLOCK_VER_NUM = (SCREEN_WIDTH / BLOCK_SIZE) + 1;
const int BLOCK_HOR_NUM = (SCREEN_HEIGHT / BLOCK_SIZE) + 1;

bool up_wall[BLOCK_VER_NUM][BLOCK_HOR_NUM];
bool left_wall[BLOCK_VER_NUM][BLOCK_HOR_NUM];
bool visited[BLOCK_VER_NUM][BLOCK_HOR_NUM];

const int wall_size = 1;

enum Dir
{
    _up = 0,
    _left = 1,
    _right = 2,
    _down = 3,
    _none = 4
};
const int DIR_SUM = 3;

struct Pos
{
    int x, y;
    Pos(int xx, int yy)
    {
        x = xx;
        y = yy;
    }
    Pos()
    {
        x = 0;
        y = 0;
    }
    Pos(const Pos& p)
    {
        x = p.x;
        y = p.y;
    }
    Pos& operator =(const Pos& p)
    {
        x = p.x;
        y = p.y;
    }

    bool operator ==(const Pos& p)
    {
        return (x == p.x) && (y == p.y);
    }
};

class Path : public stack<Pos>
{
public:
    Path() : stack<Pos>()
    {}
    const deque<Pos>& _Get_container()
    {
        return c;
    }
};

//For Build Puzzle
stack<Pos> pos;
stack<Pos> temp;

Path path;
Pos entryPuzzle;
Pos entrancePuzzle;
bool arrive;



/*Function*/
void myDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_POINTS);

    for(int i = 0; i < SCREEN_WIDTH; ++i)
    {
        for(int j = 0; j < SCREEN_HEIGHT; ++j)
        {
            int bx = i / BLOCK_SIZE;
            int by = j / BLOCK_SIZE;
          
            // //cout << "Opering Cell: " << bx << "," << by << endl;
            if(up_wall[bx][by])
            {
                if(j % BLOCK_SIZE < wall_size)
                {
                    ////cout << "Put Pix at " << i << "," << j << endl;;
                    glVertex2d(i, j);
                }
            }
            if(left_wall[bx][by])
            {
                if(i % BLOCK_SIZE < wall_size)
                {
                    // //cout << "Put Pix at " << i << "," << j << endl;
                    glVertex2d(i, j);
                }
            }
        }
    }
  
    glEnd();
    glFlush();
    //cout << "Render Over\n";
}

void DisplayTraverse()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_POINTS);

    glColor3f(0.0f, 0.0f, 0.0f);//Map Color Black
    //glPointSize(1.0);
    for(int i = 0; i < SCREEN_WIDTH; ++i)
    {
        for(int j = 0; j < SCREEN_HEIGHT; ++j)
        {
            int bx = i / BLOCK_SIZE;
            int by = j / BLOCK_SIZE;
          
            // //cout << "Opering Cell: " << bx << "," << by << endl;
            if(up_wall[bx][by])
            {
                if(j % BLOCK_SIZE < wall_size)
                {
                    ////cout << "Put Pix at " << i << "," << j << endl;;
                    glVertex2d(i, j);
                }
            }
            if(left_wall[bx][by])
            {
                if(i % BLOCK_SIZE < wall_size)
                {
                    // //cout << "Put Pix at " << i << "," << j << endl;
                    glVertex2d(i, j);
                }
            }
        }
    }
    glEnd();

    glColor3f(0.0f, 0.0f, 1.0f);//Map Color Black
    //glPointSize(2.0);
    glBegin(GL_LINE_STRIP);

    const int off = BLOCK_SIZE / 2;

    auto dq = path._Get_container();
    for(auto it : dq)
    {
        glVertex2d(it.x * BLOCK_SIZE + off, it.y * BLOCK_SIZE + off);
    }

    glEnd();
  
    
    glFlush();
}

bool canbeDestroy(int x, int y)
{
    //cout << "Detect CanbeDestroy: " << x << "," << y << endl;
    bool succ = true;
    if(x < 0 || x >= BLOCK_VER_NUM - 1 || y < 0 || y >= BLOCK_HOR_NUM - 1)
    {
        return false;
    }

    succ = left_wall[x][y] && up_wall[x][y] && left_wall[x + 1][y] && up_wall[x][y + 1];
    //if(succ) //cout << "And Succ\n\n";
    //else //cout << "And False\n\n";
    return succ;
}

void Proc(Pos& position)
{
    //cout << "Procing" << position.x << "," << position.y << endl;
    if(position.x < 0 || position.x >= BLOCK_VER_NUM || position.y < 0 || position.y >= BLOCK_HOR_NUM)
        return;
    stack<Pos> temp;

    //Find Neighbour Who can be access
    for(int i = 0; i < 4; ++i)
    {
        switch(i)
        {
        case _up:
        {
            if(canbeDestroy(position.x, position.y - 1))
            {
                temp.emplace(position.x, position.y - 1);
            }
        }break;
        case _down:
        {
            if(canbeDestroy(position.x, position.y + 1))
            {
                temp.emplace(position.x, position.y + 1);
            }
        }break;
        case _left:
        {
            if(canbeDestroy(position.x - 1, position.y))
            {
                temp.emplace(position.x - 1, position.y);
            }
        }break;
        case _right:
        {
            if(canbeDestroy(position.x + 1, position.y))
            {
                temp.emplace(position.x + 1, position.y);
            }
        }break;
        default:break;
        }
    }

    if(temp.size() == 0)//No valid target
        return;
 
    //Have valid target, and random choose one
    int size = temp.size();
    int tar = rand() % size;
    //cout << "Select " << tar + 1 << " ops of " << size << endl;
    Pos next;
    /*int i = 0;
    while(!temp.empty())
    {
        if(i++ == tar)
        {
            next = temp.top();
            temp.pop();
        }

        //if(!visited[temp.top().x][temp.top().y])
        pos.push(temp.top());
        temp.pop();
    }*/
    for(int i = 0; i < size; ++i)
    {
        if(i == tar)
        {
            next = temp.top();
            temp.pop();
        }
        else
        {
            //if(!visited[temp.top().x][temp.top().y])
            //pos.push(temp.top());
            temp.pop();
        }
    }
    pos.push(position);
    
    if(next.y == position.y - 1)
        up_wall[position.x][position.y] = false;
    else if(next.y == position.y + 1)
        up_wall[position.x][position.y + 1] = false;
    else if(next.x == position.x - 1)
        left_wall[position.x][position.y] = false;
    else if(next.x == position.x + 1)
        left_wall[position.x + 1][position.y] = false;
    else
    {

    }
    
    //visited[next.x][next.y] = true;
    //cout << "Move To " << next.x << "," << next.y << endl;
    //myDisplay();
    Proc(next);
}

void MakePuzzle()
{
    while(!pos.empty())
    {
        Pos curpos = pos.top();
        pos.pop();
        //visited[curpos.x][curpos.y] = true;
        Proc(curpos);
    }


    cout << "MakePuzzle Over.\n";
}

void myInit()
{
    /*
    Output Info
    */
    //cout << "Screen Size: " << SCREEN_WIDTH << "*" << SCREEN_HEIGHT << endl;
    //cout << "Block Size: " << BLOCK_SIZE << endl;
    //cout << "Puzzle Size: " << BLOCK_VER_NUM << "*" << BLOCK_HOR_NUM << endl;
    //cout << "Wall Size: " << wall_size << endl;


    glClearColor((float)0x66 / 0x100, (float)0xcc / 0x100, 1.0, 0.0);
    glColor3f(0.0f, 0.0f, 0.0f);//Map Color Black
    //glPointSize(1.0);
    glMatrixMode(GL_PROJECTION);
    
    glLoadIdentity();
    gluOrtho2D(0.0, (GLdouble)SCREEN_WIDTH, 0.0, (GLdouble)SCREEN_HEIGHT);
    glViewport(0.0, SCREEN_WIDTH, 0.0, SCREEN_HEIGHT);
  
    for(int i = 0; i < BLOCK_VER_NUM; ++i)
    {
        for(int j = 0; j <  BLOCK_HOR_NUM; ++j)
        {
            up_wall[i][j] = true;
            left_wall[i][j] = true;
            visited[i][j] = false;
        }
    }

    cout << "Display after init\n";
    myDisplay();

    pos.emplace(BLOCK_VER_NUM / 2, BLOCK_HOR_NUM / 2);
    cout << "myInit Over.\n";
}

void TraverseDFS(const Pos& p)
{
    cout << "Travering " << p.x << ", " << p.y << endl;
    path.push(p);
    visited[p.x][p.y] = true;
    DisplayTraverse();
    if(entrancePuzzle == p)
    {
        arrive = true;
        return;
    }

    if((p.x > 0) && !left_wall[p.x][p.y] && !visited[p.x - 1][p.y])//left
    {
        Pos next(p.x - 1, p.y);
        TraverseDFS(next);
        return;
    }
    if((p.x < BLOCK_VER_NUM - 1) && !left_wall[p.x + 1][p.y] && !visited[p.x + 1][p.y])//right
    {
        Pos next(p.x + 1, p.y);
        TraverseDFS(next);
        return;
    }
    if((p.y > 0) && !up_wall[p.x][p.y] && !visited[p.x][p.y - 1])//up
    {
        Pos next(p.x, p.y - 1);
        TraverseDFS(next);
        return;
    }
    if((p.y < BLOCK_HOR_NUM - 1) && !up_wall[p.x][p.y + 1] && !visited[p.x][p.y + 1])//down
    {
        Pos next(p.x, p.y + 1);
        TraverseDFS(next);
        return;
    }

    path.pop();
}

void TraverseInit()
{
    entryPuzzle.x = 0;
    entryPuzzle.y = rand() % (BLOCK_HOR_NUM - 1);
    entrancePuzzle.x = BLOCK_VER_NUM - 2;
    entrancePuzzle.y = rand() % (BLOCK_HOR_NUM - 1);

    cout << "Generated\nEntry: " << entryPuzzle.x << ", " << entryPuzzle.y << endl;
    cout << "Entrance: " << entrancePuzzle.x << ", " << entrancePuzzle.y << endl;

    path.push(entryPuzzle);
    visited[entryPuzzle.x][entryPuzzle.y] = true;
    arrive = false;
}

void Traverse()
{
    while(!path.empty() && !arrive)
    {
        Pos& cur = path.top();
        path.pop();
        TraverseDFS(cur);
    }
    if(arrive)
        cout << "Arrived.\n";
    else
        cout << "Something Wrong, Not arrive.";
}

int main(int argc, char* argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("Puzzle");
    glutDisplayFunc(Traverse);
  
    myInit();
    MakePuzzle();
    TraverseInit();
    glutMainLoop();

    return 0;
}

　　　代碼中myInit函數用來初始化各個矩陣。之后是MakePuzzle構造迷宮。構造迷宮的過程使用了一個棧並且是用Proc函數遞歸調用來生成迷宮的。現在想想其實可以寫成完全的遞歸或者迭代的，不過當時寫着順手就這么寫了。canbeDestroy函數即是判斷一個格子是否有四堵完整的牆，同時考慮了邊界。

　　之后就是DFS遍歷了，TraverseInit函數在迷宮最左邊隨機選取一點作為起點，最右邊隨機選擇一點作為終點。然后起點壓棧，進入主循環也就是Traverse函數開始遍歷。Traverse還是使用了遞歸+迭代的方式，不斷遞歸直到進入死路，然后彈棧重新遞歸。

　　最后，最上面倆函數myDisplay和DisplayTraverse，前者是用來畫迷宮的，后者則是迷宮+DFS的路徑。另外我畫迷宮是一個像素一個像素去判斷是否在迷宮的牆上，是就畫不是就不畫，這樣其實效率很低，完全可以遍歷每行每列用GL_LINES去畫的。人懶沒葯醫啊。

 

運行情況（由於寬度1200截圖出來顯示效果不好所以我改成了800）：

 

　　另外至於生成迷宮是叫MakePuzzle，完全是因為我英語不好並且寫這東西的時候完全是在無網絡的情況下所以隨便想了個單詞。