Qt迷宫实现简单的创建和寻路

已于 2022-11-03 16:28:36 修改
阅读量3.4k 收藏 79
点赞数 14
文章标签： qt
于 2020-12-13 00:58:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47667221/article/details/111086399
版权

一，问题描述

1，问题描述

迷宫实验是取自心理学的一个古典实验。在该实验中，把一只老鼠从一个无顶大盒子的门放入，在盒中设置了许多墙，对行进方向形成了多处阻挡。盒子仅有一个出口，在出口处放置一块奶酪，吸引老鼠在迷宫中寻找道路以到达出口。对同一只老鼠重复进行上述实验，一直到老鼠从入口到出口，而不走错一步。老鼠经多次试验终于得到它学习走迷宫的路线。

2，设计功能要求

迷宫由m行n列的二维数组设置，0表示无障碍，1表示有障碍。设入口为（1，1），出口为（m，n），每次只能从一个无障碍单元移到周围四个方向上任一无障碍单元。编程实现对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。

  • 算法输入：代表迷宫入口的坐标
  • 算法输出：穿过迷宫的结果。
  • 算法要点：创建迷宫，试探法查找路。

二，设计思路

1，迷宫的创建

  • 如何保存？
    使用二维数组进行保存，0代表路，1代表墙，2代表起点，3代表终点
  • 如何创建？
    1，手动创建：手动输入二维数组进行创建
    2，自动创建：通过使用自然分岔型1进行创建

2，如何寻路

  • BFS广度优先搜索
    通过创建栈进行寻路
  • DFS深度优先搜索
    通过创建队列进行寻路

3，如何展示及想要实现的效果

  • 使用Qt创建可视化的迷宫界面
  • 可直接在迷宫界面对迷宫进行修改
  • 将迷宫的通路可视化显示在迷宫界面上，并且有动画效果

三，效果展示

初始界面 自动创建迷宫（起点和终点须手动设置） DFS寻路 BFS寻路

四，部分代码细节

1，如何在界面上绘制迷宫

我使用maze_record保存迷宫原始数据，使用maze_data来保存迷宫的其他细节，如果某位置P(x，y)已经被访问，则将maze_data[x][y]设为-1，最后绘图时使用maze_data的数据

void MyWidget::paintEvent(QPaintEvent *event)
{
	// 迷宫的最大长度或宽度为500个像素
    Q_UNUSED(event);
    paint = new QPainter;
    paint->begin(this);
    paint->setPen(QPen(Qt::black, 1, Qt::SolidLine));//设置画笔形式
    // 得到迷宫中每个方块的大小
    int max_size = (this->row > this->col) ? this->row : this->col;
    int each_box_size = 500 / max_size;
    for (int i = 0; i < this->row; i++) {
        for (int j = 0; j < this->col; j++) {
            // 重复对每个方块进行绘制
            if (this->maze_data[i][j] == 0) {
                // 如果是路则将画笔设为白色
                paint->setBrush(QBrush(Qt::white, Qt::SolidPattern));//设置画刷形式
            }else if(this->maze_data[i][j] == -1) {
                // 如果是墙路径则将画笔设为黄色
                paint->setBrush(QBrush(Qt::yellow, Qt::SolidPattern));
            }else if (this->maze_data[i][j] == 1) {
                // 如果是墙则将画笔设为黑色
                paint->setBrush(QBrush(Qt::black, Qt::SolidPattern));
            } else if (this->maze_data[i][j] == 2) {
                // 如果是起点则将画笔设为绿色
                paint->setBrush(QBrush(Qt::green, Qt::SolidPattern));
            } else if (this->maze_data[i][j] == 3) {
                // 如果是终点则将画笔设为红色
                paint->setBrush(QBrush(Qt::red, Qt::SolidPattern));
            }
            paint->drawRect(240 + each_box_size * i, 70 + each_box_size * j, each_box_size, each_box_size);
        }
    }
    paint->end();
}

在其他地方只需调用repaint()函数即可重新绘制迷宫

2，如何手动创建迷宫

获取鼠标每次点击时的位置并判断点击到第几个迷宫的方块，然后改变该方块的状态并保存到maze_record中

void MyWidget::mousePressEvent(QMouseEvent *event)
{
    // 获取鼠标相对迷宫左上角的坐标
    int x = event->x() - 240;
    int y = event->y() - 70;
    if (x < 0 || y < 0 || this->maze_data == nullptr) {
        // 如果x，y小于0则直接跳出
        return;
    }
    // 得到迷宫中每个方块的大小
    int max_size = (this->row > this->col) ? this->row : this->col;
    int each_box_size = 500 / max_size;
    // 计算出鼠标点击的方块位置
    int click_row = x / each_box_size;
    int click_col = y / each_box_size;
    // 改变方块当前状态
    if (this->maze_record[click_row][click_col] == 0) {
        // 如果是路则变为墙
        this->maze_record[click_row][click_col] = 1;

    }else if (this->maze_record[click_row][click_col] == 1) {
        // 如果是墙则变为起点
        this->maze_record[click_row][click_col] = 2;
        if (this->start != nullptr) {
            // 如果已经有起点
            this->maze_record[this->start->x][this->start->y] = 0;
            this->start->x = click_row;
            this->start->y = click_col;
        }else {
            // 如果未设置起点则设为起点
            this->start = nullptr;

            this->start = new Point(click_row, click_col, 2);
        }
    }else if (this->maze_record[click_row][click_col] == 2) {
        // 如果是起点，则设置为终点
        delete this->start;
        this->start = nullptr;
        this->maze_record[click_row][click_col] = 3;
        if (this->end != nullptr) {
            // 如果终点已经存在
            this->maze_record[this->end->x][this->end->y] = 0;
            this->end->x = click_row;
            this->end->y = click_col;
        }else {
            this->end = new Point(click_row, click_col, 3);
        }

    }else if (this->maze_record[click_row][click_col] == 3) {
        // 如果是终点，则设置为路
        delete this->end;
        this->end = nullptr;
        this->maze_record[click_row][click_col] = 0;
    }
    this->resetMazeData();  // 就是把maze_record拷贝给maze_data
    this->repaint();

如果鼠标点击的位置在迷宫外面就直接退出该函数了，对其他操作没有影响

3，如何自动创建迷宫

参考自然分岔型1，思路说的很清楚，我感觉自己代码写的好乱。。。不建议参考

int **MyWidget::autoSetMaze(int row, int col)
{
    QList<Point*> path_list;
    int ** res = new int * [row];
    for (int i = 0; i < row; i++) {
        res[i] = new int[col];
    }
    for (int i = 0; i < row; i++) {
        int flag = i % 2;
        for (int j = 0; j < col; j++) {
            if (flag == 0) {
                // 单数行全为墙
                res[i][j] = 1;
            }else {
                // 偶数行墙和路依次分布
                if (j % 2 == 0) {
                    res[i][j] = 1;
                }else {
                    res[i][j] = 0;
                }
            }
        }
    }
    // 随机选取地图边缘的路
    int flag_xy = randomNumber(0, 10);
    int x = 0;
    int y = 0;
    if (flag_xy % 2 == 0) {
        x = 1;
        y = 2 * randomNumber(0, (col - 1) / 2) + 1;
    } else {
        y = 1;
        x = 2 * randomNumber(0, (row - 1) / 2) + 1;
    }
    // 将该点做标记
    res[x][y] = 10;
    // 将该点周围的墙加入数组中
    if (x != 1 && res[x - 1][y] != 10) {
        path_list.push_back(new Point(x - 1, y, 0));
    }
    if (x != row - 2 && res[x + 1][y] != 10) {
        path_list.push_back(new Point(x + 1, y, 0));
    }
    if (y != 1 && res[x][y - 1] != 10) {
        path_list.push_back(new Point(x, y - 1, 0));
    }
    if (y != col - 2 && res[x][y + 1] != 10) {
        path_list.push_back(new Point(x, y + 1, 0));
    }
    while (path_list.empty() == false) {
        // 数组中随机选取一个点
        int index = randomNumber(0, path_list.size());
        Point * ptr = path_list[index];
        int ptr_x = ptr->x;
        int ptr_y = ptr->y;
        // 从左到右
        if (res[ptr_x - 1][ptr_y] == 10 && res[ptr_x + 1][ptr_y] == 0) {
            res[ptr_x][ptr_y] = 10;
            res[ptr_x + 1][ptr_y] = 10;
            // 将周围的墙加入数组中
            if (ptr_x + 1 != row - 2 && res[ptr_x + 3][ptr_y] != 10) {
                path_list.push_back(new Point(ptr_x + 2, ptr_y, 0));
            }
            if (ptr_y != 1 && res[ptr_x + 1][ptr_y - 2] != 10) {
                path_list.push_back(new Point(ptr_x + 1, ptr_y - 1, 0));
            }
            if (ptr_y != col - 2 && res[ptr_x + 1][ptr_y + 2] != 10) {
                path_list.push_back(new Point(ptr_x + 1, ptr_y + 1, 0));
            }
        }
        // 从右到左
        if (res[ptr_x + 1][ptr_y] == 10 && res[ptr_x - 1][ptr_y] == 0) {
            res[ptr_x][ptr_y] = 10;
            res[ptr_x - 1][ptr_y] = 10;
            // 将周围的墙加入数组中
            if (ptr_x - 1 != 1 && res[ptr_x - 3][ptr_y] != 10) {
                path_list.push_back(new Point(ptr_x - 2, ptr_y, 0));
            }
            if (ptr_y != 1 && res[ptr_x - 1][ptr_y - 2] != 10) {
                path_list.push_back(new Point(ptr_x - 1, ptr_y - 1, 0));
            }
            if (ptr_y != col - 2 && res[ptr_x - 1][ptr_y + 2] != 10) {
                path_list.push_back(new Point(ptr_x - 1, ptr_y + 1, 0));
            }
        }
        // 从上到下
        if (res[ptr_x][ptr_y - 1] == 10 && res[ptr_x][ptr_y + 1] == 0) {
            res[ptr_x][ptr_y] = 10;
            res[ptr_x][ptr_y + 1] = 10;
            // 将周围的墙加入数组中
            if (ptr_x != row - 2 && res[ptr_x + 2][ptr_y + 1] != 10) {
                path_list.push_back(new Point(ptr_x + 1, ptr_y + 1, 0));
            }
            if (ptr_x != 1 && res[ptr_x - 2][ptr_y + 1] != 10) {
                path_list.push_back(new Point(ptr_x - 1, ptr_y + 1, 0));
            }
            if (ptr_y + 1!= col - 2 && res[ptr_x][ptr_y + 3] != 10) {
                path_list.push_back(new Point(ptr_x, ptr_y + 2, 0));
            }
        }
        // 从下到上
        if (res[ptr_x][ptr_y + 1] == 10 && res[ptr_x][ptr_y - 1] == 0) {
            res[ptr_x][ptr_y] = 10;
            res[ptr_x][ptr_y - 1] = 10;
            // 将周围的墙加入数组中
            if (ptr_x != row - 2 && res[ptr_x + 2][ptr_y - 1] != 10) {
                path_list.push_back(new Point(ptr_x + 1, ptr_y - 1, 0));
            }
            if (ptr_x != 1 && res[ptr_x - 2][ptr_y - 1] != 10) {
                path_list.push_back(new Point(ptr_x - 1, ptr_y - 1, 0));
            }
            if (ptr_y - 1 != 1 && res[ptr_x][ptr_y - 3] != 10) {
                path_list.push_back(new Point(ptr_x, ptr_y - 2, 0));
            }
        }
        path_list.removeAt(index);

    }

    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if (res[i][j] == 10) {
                res[i][j] = 0;
            }
        }
    }
	// 随机选取一些墙将其变为路，方法随意，这里仅供参考
    if (col > 20 || row > 20) {
        for (int i = 0; i < row * 5; i++) {
            int x = randomNumber(0, 100) % (row - 2) + 1;
            int y = randomNumber(0, 100) % (col - 2) + 1;
            if (res[x][y] == 1) {
            	// 这里是要判断这面墙的上下左右至少有2面都为墙
                int flag = 0;
                if (res[x - 1][y] == 1) {
                    flag++;
                }
                if (res[x + 1][y] == 1) {
                    flag++;
                }
                if (res[x][y - 1] == 1) {
                    flag++;
                }
                if (res[x][y + 1] == 1) {
                    flag++;
                }
                if (flag > 1) {
                    res[x][y] = 0;
                }
            }
        }
    }

    return res;
}

因为单纯使用自然分岔的方法产生的迷宫的通路很少，所以在行数或列数大于20的时候随机选取一些墙将其变为路，这样一个迷宫可以有好多条路可以走。

4，关于BFS寻路的细节

DFS寻路的路径直接保存到栈中，所以路径可以直接得出；而BFS寻路使用的是队列，无法直接保存路径，所以我自定义了队列MyQueue，使用线性结构，在Point类中添加pioneer属性，其值是该点在MyQueue中后继的点，最后寻路时直接通过不断访问MyQueue[Point.pioneer]就可以得到整个路径

class Point
{
public:
    Point();
    Point(int x, int y, int stat);

    bool operator!=(const Point & p);
public:
    int x;
    int y;
    int status;
    int pioneer;
};

class MyQueue
{
public:
    MyQueue();
    bool isEmpty();
    void push(Point * p);
    void pop();
    Point* frontPoint();
    Point ** queue;
    int front;
    int end;
};

5，寻路动画的实现

不管使用BFS或DFS寻路时最后都会用到栈，将通路节点依次出栈的同时将maze_data相应位置变为-1，然后进行repaint()并延时0.1s
这里给出我使用的延时函数

void MyWidget::sleep(int sec)
{
    QElapsedTimer t;
    t.start();
    while(t.elapsed()<sec);
}

五，其他

这次的程序写了好久。。。主要是不知道怎么使用Qt。
还有一种思路其实更节省空间，每走一步将maze_data该处的值减去已走过的步数，如[2,0,0,0,0,0,3]走完就变成[2,-1,-2,-3,-4,-5,3]，直到无路可走时直接原路返回，如果某处相邻点值为0，则走到该点处，并将该点数值设为已走过的步数，最后寻路时优先选择相邻位置差值最大的点。

  1. 自然分岔型：三套简单的迷宫地图生成方案 - 兔四的文章 - 知乎，这里介绍了几种自动生成迷宫的方法 ↩︎ ↩︎

莯风
关注
Qt实现的迷宫与魔塔游戏 源码（迷宫模式、魔塔模式、游戏素材、C++课程设计）
10-11
这是我C++课程设计用Qt做的一个小游戏，将迷宫与魔塔结合起来了，包含迷宫和地牢界面的生成+BFS寻路+布局管理器+动态效果实现+游戏音效实现，源码的注释很详细，博客描述的特别清楚，可作为C++课程设计，详情可以参考我的博客：https://blog.csdn.net/qq_43365825/article/details/102502082
基于QT实现dfs寻论算法的迷宫可视化
最新发布
03-06
在编程领域，迷宫寻路问题是一种常见的算法挑战，它可以帮助我们理解路径查找、图遍历等概念。本话题将详细讲解如何利用Qt框架实现深度优先搜索（DFS）算法，并将其可视化，以便更好地理解和展示算法的过程。Qt是一...
Qt图形化界面—迷宫最短路径问题
方寸间沧海桑田的博客
02-22 3174
这段时间为了日后的工作需要，遵循霍亚飞老师的《Qt Creator快速入门（第三版）》学了第一大章基础篇的知识，并根据所学的知识尝试性地将之前的迷宫最短路径问题进行了图形化界面的设计。由于本人学艺不精，暂时只能基本实现原函数的基本功能，日后若有时间再慢慢增补吧。 基本介绍 目前这个程序的功能主要有五个： （1）输入迷宫的尺寸：为便于调试，目前设计的为正方形的迷宫，即长宽尺寸相同。用户只需要输入...
用Qt实现一个迷宫
gaoyuelong的博客
09-19 2286
用qt实现一个迷宫，玩家通过键盘方向键移动，从左上角走到右下角即为成功。 先来看下最终实现效果： 其实重点在于随机迷宫的生成，而迷宫的生成靠的是并查集算法。 思路参考自bigsai（感谢授权）： 原文链接 游戏总结如下： 游戏规则为若两个小方块之间没有线，说明是互通的，可以移动，否则两个方块之间被“墙”阻隔不能移动。因此我们先画一个由多个小方块组成的初始地图，然后随机擦除其中的一些线，就可以生成一个迷宫了。就像这样： 而将两个方格之间的线擦除，是不是也就意味着这两个方格是一个集合了（他们是一家子了），所
游戏——Qt迷宫
Joey博客
06-26 2169
小游戏——Qt迷宫 源码 源码中有详细的注释，有空再把迷宫游戏的思路补充到博客中。 效果图
用Qt写一个迷宫游戏
qq_38501425的博客
07-05 2822
利用之前写的迷宫生成代码写个Qt小游戏 用到了Qt的一些知识。
数据结构实习-迷宫（基于Qt实现）
weixin_30612769的博客
01-19 673
预览效果： Maze.pro文件 1 #------------------------------------------------- 2 # 3 # Project created by QtCreator 2016-12-26T14:10:37 4 # 5 #------------------------------------------------...
Maze_qt迷宫_迷宫qt代码_qt生成迷宫_QT游戏_Qt；C++；迷宫；游戏_
10-03
在迷宫游戏中，Qt的QGraphicsView和QGraphicsScene模块是构建游戏场景的关键，它们允许开发者创建复杂的2D图形界面，并实现对象的动态交互。 迷宫生成算法是游戏的核心部分。本项目可能采用了经典的深度优先搜索...
C++基于搜索技术的迷宫寻路系统源码.zip
05-31
实现一个能展示深度优先、宽度优先、贪婪搜索、等代价搜索、采用欧氏距离、曼哈顿距离和切比雪夫距离的A*搜索的迷宫寻路系统。 要求在实现过程中能灵活运用队列、栈和图等各种结构，排序方法可使用堆排序，在实现...
qt实现老鼠走迷宫游戏（数据结构课设）
03-03
在本文中，我们将深入探讨如何使用Qt框架和C++编程语言来实现一个老鼠走迷宫的游戏，这通常是一项数据结构课程设计项目。我们将重点关注迷宫生成算法和两种寻路算法：深度优先搜索（DFS）与广度优先搜索（BFS）。让...
QT写的迷宫程序，支持自定义地图
07-11
QT写的迷宫程序，支持自定义地图，可以跨平台使用。新手学习的好东西
一个简单的迷宫游戏编程
11-24
这是一个相对简单低级的迷宫游戏，有C++语言编的程序。
Qt实现的迷宫与魔塔游戏 可执行程序（迷宫模式、魔塔模式、C++课程设计）
10-11
这个是我的另一个资源，Qt实现的迷宫与魔塔游戏，源码生成的_exe可执行程序，包含迷宫和地牢界面的生成+BFS寻路+布局管理器+动态效果实现+游戏音效实现，可做为C++课程设计，详情可以参考我的博客：https://blog.csdn.net/qq_43365825/article/details/10250208
Qt5-AStarPathfinding:在 Qt5 中使用 A* 搜索算法进行寻路
06-21
Qt5-AStar探路 Qt5中使用A*搜索算法的寻路 练习启发式搜索。 人工智能 - ULL
[Qt] 迷宫随机生成和寻路算法 - Qt实现的迷宫小游戏
热门推荐
RyuZhihao123 的博客
04-24 1万+
这是大二上学期做的一个小玩意儿，上传上来凑个数哈哈哈。 首先贴出下载链接： 1. 完整Qt源码：http://download.csdn.net/detail/mahabharata_/9824044 2. 发布的可执行程序：http://download.csdn.net/detail/mahabharata_/9824066   程序截图： 1. 动画演示自动寻路的过程（使用QSe...
【Qt编程】3D迷宫游戏
青峰碧陋室
10-18 7966
说起迷宫想必大家都很熟悉，个人感觉迷宫对人的方向感是很大的考验，至少我的方向感是不好的，尤其是在三维空间中。由于这段时间帮导师做项目用到了三维作图，便心血来潮想做个三维迷宫玩玩。要想画出三维的迷宫游戏，我们需要先从二维开始。 二维迷宫： 迷宫的程序描述：         现实生活中，我们经常将问题用数学的方法来描述并解决（数学建模）。同样的，我们想用程序来解决问题，就得把问题程序
基于C++QT开发的智能迷宫游戏系统
毕业作品网站
06-04 685
针对上述迷宫问题，作者采用深度优先搜索算法，迭代加深深度优先搜索算法，广度优先搜索算法，双向广度优先搜索算法，蒙特卡洛算法，启发式搜索算法，迭代加深启发式搜索算法以及遗传算法八种人工智能方法，实现系统在复杂的迷宫环境下，求解寻找路径问题，并比较了各种方法的优势和应用范围，针对具体问题的特征进行特定的优化，使得在求解问题时能达到最高的效率获得最好的结果，进而提升计算机游戏的智能化水平。文档+任务书+开题报告+开题答辩PPT+外文翻译及原文+项目源码及EXE可执行文件。4.1.1 唯一解迷宫生成算法 28。
[Qt] 迷宫随机生成和自动寻路算法、布局管理器、动态效果、界面切换、播放音频【迷宫、魔塔、超级玛丽】 -C++课程设计：Qt实现的迷宫与地牢游戏
qq_43365825的博客
10-11 3717
基于QT的迷宫与地牢小游戏开发 1. 系统结构及实现 游戏中有迷宫模式和地牢模式两种游戏模式，主要由5个类组成。主界面类包含其它4个类。迷宫类maze主要实现迷宫模式中，迷宫地图的随机生成，寻路算法存储的路径；地牢类Dungeon主要实现地牢地图的生成，初始化地图贴图资源字符串，地牢中角色信息的初始化，战斗伤害的计算；开始界面类interface主要实现开始界面的设置；商店类StoreWidge...
qt 3d迷宫游戏_六款优秀的高颜值游戏，伴你度过静谧时光
weixin_39692045的博客
12-20 2272
纪念碑谷纪念碑谷是一款3D 立体迷宫款游戏，它的每个闯关都是一个3D 建筑，你可以通过旋转并拖拽改变形状来帮助公主艾达走出迷宫。它的每个界面都像一个艺术品，背景音乐都是值得你扣着耳机去听的，它极简的 3D设计，建筑启发自世界各地的宫殿庙宇。它同是也 2014 年的苹果设计奖得主。Alto's Adventure(阿尔托的冒险)阿尔托的冒险是一款滑雪跑酷游戏，它的每个场景都像精美的画师画的画一样。在...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值