走迷宫（未实现通关版）

已于 2024-03-07 16:42:57 修改
阅读量404 收藏
点赞数 13
文章标签： 深度优先 算法
于 2024-03-07 16:42:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxx_jsu/article/details/136538367
版权

本文改编自原作者：

【C / EasyX】随机迷宫生成和路径搜索(DFS)_easyx 路径搜索-CSDN博客

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <graphics.h>
using  namespace std;
clock_t Start_time;
clock_t End_time;
//以下是 宏定义参数 //
#define WIDTH 1280                      // 窗体宽度
#define HEIGHT 720                      // 窗体高度
#define MAZE_WIDTH 30*40                    // 迷宫宽度
#define MAZE_HEIGHT 40*40                   // 迷宫高度
#define B_WIDTH 10                          // 格子宽度
#define X 55                                // 迷宫列数 
#define Y 26                                // 迷宫行数 
#define N X*2+1                             // 迷宫数组列数 
#define M Y*2+1                             // 迷宫数组行数 
#define L (N-1)*(M-1)                       // 迷宫路径长度
#define LX 80                               // 起点坐标X
#define LY 50                               // 起点坐标Y
#define BLOCK RGB(255,194,76)             // 墙壁颜色
#define GRAY RGB(123,72,55)               // 阴影颜色
#define GROUND RGB(50,50,50)              // 地面颜色
#define ROOT RGB(235,51,36)             // 路径颜色
#define LINE WHITE        // 路径线颜色
//以下是  函数声明  //
float GetFPS();                             // 计算画面FPS(每秒帧数)
void Delay(DWORD ms);                       // 绝对延时
bool IsInRect(int x, int y, RECT r);          // 是否在矩形内
void InitMaze();                            // 初始化迷宫数组
void OutputMaze();                          // 输出迷宫
void CopyScreenBuffer();                    // 复制屏幕到缓存
void DrawScreenBuffer();                    // 绘制缓存到屏幕
void OutPutPath();                          // 输出路径连线
void DrawFPS();                             // 输出帧数
int Move(int d, int x, int y);                // 向指定方向移动,返回是否成功移动
void DFS_CreateMaze(int x, int y);           // 深度优先生成迷宫
void FindPath(int i, int j);                 // 深度优先搜索迷宫路径
void CreateMaze();                          // 创建迷宫
void DrawMenuItems();                       // 绘制菜单按钮
//以下是全局变量定义//
DWORD* p_Screen;                                // 显存指针
DWORD buff_Screen[WIDTH * HEIGHT];        // 显示缓存
int isShowFPS = 1;                                // 是否显示帧数
int isShowMazePath = 0;                           // 显示迷宫路径
int Maze[M][N];                                 // 迷宫数组   0 普通通路 1 墙 2 路径点 3 起点 4 终点
int path_x[10000][L], path_y[10000][L];            // 路径坐标
int length[L];                                  // 路径搜索长度
int lengtha, count;                              // 搜索计数
int mouseX;                                     // 鼠标位置坐标X
int mouseY;                                     // 鼠标位置坐标Y
bool isMouseDown;                               // 鼠标按下
int start_x, start_y, end_x, end_y;                // 起点坐标 终点坐标
int temp_d;                                     // 上一步走的方向
int Move_flag;                                  // 移动标记
int time_1;
char str[1000];
//以下是辅助功能函数
// 计算画面FPS(每秒帧数)
float GetFPS()
{
#define FPS_COUNT 8
    static int num = 0;
    static DWORD oldTime = GetTickCount();
    static float fps;
    if (num > FPS_COUNT)
    {
        num = 0;
        int newTime = GetTickCount();
        int elapsedTime = newTime - oldTime;
        fps = FPS_COUNT / (elapsedTime / 1000.0f);
        oldTime = newTime;
    }
    num++;
    return fps;
}

// 绝对延时
void Delay(DWORD ms)
{
    static DWORD oldTime = GetTickCount();
    while (GetTickCount() - oldTime < ms)
        Sleep(1);
    oldTime = GetTickCount();
}

// 是否在矩形内
bool IsInRect(int x, int y, RECT r)
{
    if ((x >= r.left && x <= r.right) && (y >= r.top && y <= r.bottom)) return true;
    else return false;
}

// 初始化迷宫数组 
void InitMaze() {
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            Maze[i][j] = 1;
        }
    }
    // 设置起点和终点
    Maze[1][0] = 3;
    Maze[M - 2][N - 1] = 4;
}

// 输出迷宫 
void OutputMaze() {
    // 清屏
    setcolor(RGB(255, 255, 255));
    setfillcolor(RGB(255, 255, 255));
    fillrectangle(0, 0, WIDTH, HEIGHT);
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++) {
            int xx = LX + j * B_WIDTH;
            int yy = LY + i * B_WIDTH;
            switch (Maze[i][j]) {
            case 0:
                setcolor(GROUND);
                setfillcolor(GROUND);
                fillrectangle(xx, yy, xx + B_WIDTH, yy + B_WIDTH);
                break;
            case 1:
                setcolor(BLOCK);
                setfillcolor(BLOCK);
                fillrectangle(xx, yy, xx + B_WIDTH, yy + B_WIDTH);
                if (Maze[i][j] == 1 && (i == M - 1 || Maze[i + 1][j] != 1))
                {
                    setcolor(GRAY);
                    setfillcolor(GRAY);
                    fillrectangle(xx, yy + B_WIDTH / 2, xx + B_WIDTH, yy + B_WIDTH);
                }
                break;
            case 2:
                setcolor(GROUND);
                setfillcolor(GROUND);
                fillrectangle(xx, yy, xx + B_WIDTH, yy + B_WIDTH);
                break;
            case 3:
                setcolor(GROUND);
                setfillcolor(GROUND);
                fillrectangle(xx, yy, xx + B_WIDTH, yy + B_WIDTH);
                break;
            case 4:
                setcolor(GROUND);
                setfillcolor(GROUND);
                fillrectangle(xx, yy, xx + B_WIDTH, yy + B_WIDTH);
                break;
            }
        }
    }


}

// 复制屏幕到缓存
void CopyScreenBuffer()
{
    for (int i = 0; i < WIDTH * HEIGHT; i++)
    {
        buff_Screen[i] = p_Screen[i];
    }
}

// 绘制缓存到屏幕
void DrawScreenBuffer()
{
    for (int i = 0; i < WIDTH * HEIGHT; i++)
    {
        p_Screen[i] = buff_Screen[i];
    }
    //计时器
    End_time = clock();
    time_1 = (int)((End_time - Start_time) / CLOCKS_PER_SEC);
    settextstyle(50, 0, "黑体");
    setcolor(BLACK);
    sprintf_s(str, "游戏时间：%d s", time_1);
    outtextxy(10, 10, str);


}

// 输出帧数
void DrawFPS()
{
    //输出帧数
    if (isShowFPS)
    {
        setcolor(RED);
        settextstyle(15, 0, _T("黑体"));
        TCHAR  s[5];
#if _MSC_VER > 1200
        _stprintf_s(s, _T("%.1f"), GetFPS());
#else
        _stprintf(s, _T("%.1f"), GetFPS());
#endif
        outtextxy(4, 2, _T("FPS:"));
        outtextxy(34, 2, s);
    }
}

// 输出路径连线
void OutPutPath()
{
    if (isShowMazePath)
    {
        for (int i = 0; i < length[0] - 1; i++)
        {
            setcolor(LINE);
            int x1 = path_x[0][i] * B_WIDTH + B_WIDTH / 2 + LX;
            int x2 = path_x[0][i + 1] * B_WIDTH + B_WIDTH / 2 + LX;
            int y1 = path_y[0][i] * B_WIDTH + B_WIDTH / 2 + LY;
            int y2 = path_y[0][i + 1] * B_WIDTH + B_WIDTH / 2 + LY;
            line(x1, y1, x2, y2);
        }
    }
}

// 向指定方向移动,返回是否成功移动
int Move(int d, int x, int y)
{
    switch (d)
    {
        // 向上
    case 0: {
        if (Maze[y - 3][x] > 0 && Maze[y - 2][x - 1] > 0 && Maze[y - 2][x + 1] > 0 && y - 2 > 0)
        {
            Maze[y - 2][x] = 0;
            Maze[y - 1][x] = 0;
            Move_flag = 1;
            temp_d = 0;
            DFS_CreateMaze(x, y - 2);
        }
        break;
    }
          // 向下
    case 1: {
        if (Maze[y + 3][x] > 0 && Maze[y + 2][x - 1] > 0 && Maze[y + 2][x + 1] > 0 && y + 2 < M)
        {
            Maze[y + 2][x] = 0;
            Maze[y + 1][x] = 0;
            Move_flag = 1;
            temp_d = 1;
            DFS_CreateMaze(x, y + 2);
        }
        break;
    }
          // 向左
    case 2: {
        if (Maze[y][x - 3] > 0 && Maze[y - 1][x - 2] > 0 && Maze[y + 1][x - 2] > 0 && x - 2 > 0)
        {
            Maze[y][x - 1] = 0;
            Maze[y][x - 2] = 0;
            Move_flag = 1;
            temp_d = 2;
            DFS_CreateMaze(x - 2, y);
        }
        break;
    }
          // 向右
    case 3: {
        if (Maze[y][x + 3] > 0 && Maze[y - 1][x + 2] > 0 && Maze[y + 1][x + 2] > 0 && x + 2 < N)
        {
            Maze[y][x + 1] = 0;
            Maze[y][x + 2] = 0;
            Move_flag = 1;
            temp_d = 3;
            DFS_CreateMaze(x + 2, y);
        }
        break;
    }
    }
    return Move_flag;
}// 深度优先生成迷宫
// 深度优先生成迷宫
void DFS_CreateMaze(int x, int y)
{
    //置通路
    Maze[y][x] = 0;
    //随机方向
    int d = rand() % 4;
    int direct = temp_d;
    int t[4] = { 0,0,0,0 };// 已走方向标记
    Move_flag = 0;// 重置移动标记
    // 保证随机性的同时走满地图
    while (t[0] != 1 || t[1] != 1 || t[2] != 1 || t[3] != 1)
    {
        int i = rand() % 4;
        if (t[i] != 1)
        {
            t[i] = 1;
            Move(i, x, y);
        }
    }
}
// 深度优先搜索迷宫路径
void FindPath(int x, int y)
{
    // 置路径
    Maze[y][x] = 2;
    path_x[count][lengtha] = x;
    path_y[count][lengtha] = y;
    lengtha++;
    // 搜索到目的地
    if (x == end_x && y == end_y)
    {
        //success=1;
        length[count] = lengtha;
        count++;
        if (count > 0)
        {
            // 复制上一次的路径到下一次待搜索路径中
            for (int i = 0; i < length[count - 1]; i++)
            {
                path_x[count][i] = path_x[count - 1][i];
                path_y[count][i] = path_y[count - 1][i];
            }
        }
    }
    else
    {
        // 搜索并回溯
        if (Maze[y][x + 1] == 0) { FindPath(x + 1, y); Maze[y][x + 1] = 0; lengtha--; }
        if (Maze[y + 1][x] == 0) { FindPath(x, y + 1); Maze[y + 1][x] = 0; lengtha--; }
        if (Maze[y][x - 1] == 0) { FindPath(x - 1, y); Maze[y][x - 1] = 0; lengtha--; }
        if (Maze[y - 1][x] == 0) { FindPath(x, y - 1); Maze[y - 1][x] = 0; lengtha--; }
    }
    //if(success!=1)
    //return success;
}
// 创建迷宫
void CreateMaze()
{
    // 初始化迷宫数组
    InitMaze();
    isShowMazePath = 0;
    // 从终点开始逆向生成迷宫
    start_x = 1;
    start_y = 1;
    end_x = N - 2;
    end_y = M - 2;
    DFS_CreateMaze(end_x, end_y);
    // 搜索路径
    lengtha = 0;
    count = 0;
    FindPath(start_x, start_y);
    // 结果路径复制到地图
    for (int i = 0; i < length[0]; i++)
    {
        Maze[path_y[0][i]][path_x[0][i]] = 2;
    }
}
// 绘制菜单按钮
void DrawMenuItems()
{
    RECT r;
    r.left = 860;
    r.top = 610;
    r.right = r.left + 90;
    r.bottom = r.top + 38;
    setcolor(RGB(50, 50, 50));
    if (IsInRect(mouseX, mouseY, r))
    {
        setfillcolor(RGB(220, 220, 220));
        // 生成迷宫按键响应
        if (isMouseDown)
        {
            // 创建迷宫
            CreateMaze();
            // 绘制一次到屏幕并复制到缓存
            OutputMaze();
            CopyScreenBuffer();
            isMouseDown = 0;
        }
    }
    else setfillcolor(RGB(240, 240, 240));
    fillrectangle(r.left, r.top, r.right, r.bottom);
    settextstyle(25, 9, _T("Verdana"));
    setcolor(RGB(60, 60, 60));
    outtextxy(r.left + 5, r.top + 5, _T(" 生成迷宫"));
    r.left = 1020;
    r.top = 610;
    r.right = r.left + 90;
    r.bottom = r.top + 38;
    setcolor(RGB(50, 50, 50));
    if (IsInRect(mouseX, mouseY, r))
    {
        setfillcolor(RGB(220, 220, 220));
        // 显示/隐藏路径
        if (isMouseDown)
        {
            isShowMazePath = !isShowMazePath;
            isMouseDown = 0;
        }
    }
    else setfillcolor(RGB(240, 240, 240));
    fillrectangle(r.left, r.top, r.right, r.bottom);
    settextstyle(25, 9, _T("Verdana"));
    setcolor(RGB(60, 60, 60));
    if (isShowMazePath) outtextxy(r.left + 5, r.top + 5, _T(" 隐藏路径"));
    else outtextxy(r.left + 5, r.top + 5, _T(" 显示路径"));
}
// 主函数
int main() {
    // 置随机数种子 
    srand(unsigned(time(NULL)));
    // 初始化设备，加载图片
    initgraph(WIDTH, HEIGHT);
    // 设置窗口标题
    SetWindowText(GetHWnd(), _T("Maze v0.9 By:ls9512"));
    cleardevice();
    // 设置黑色背景
    setbkmode(TRANSPARENT);
    settextcolor(BLACK);
    // 开启双缓冲,防止闪屏
    BeginBatchDraw();
    // 鼠标消息变量
    MOUSEMSG mmsg;
    // 获取显存指针
    p_Screen = GetImageBuffer();
    // 创建迷宫
    CreateMaze();
    // 绘制一次到屏幕并复制到缓存
    OutputMaze();
    CopyScreenBuffer();
    // 主循环
    Start_time = clock();
    while (true)
    {
        
        //处理鼠标消息
        while (MouseHit())
        {
            mmsg = GetMouseMsg();
            switch (mmsg.uMsg)
            {
            case WM_MOUSEMOVE:  mouseX = mmsg.x; mouseY = mmsg.y; break;
            case WM_LBUTTONDOWN: isMouseDown = true; break;
            case WM_LBUTTONUP: isMouseDown = false; break;
            }

        }
        
        // 绘制，将缓存数据复制到屏幕提速
        DrawScreenBuffer();
        OutPutPath();
        DrawMenuItems();
        DrawFPS();
      
        // 显示缓存的绘制内容
        FlushBatchDraw();
        // 延迟,帧数控制
        Sleep(5);
    }
    // 关闭
    EndBatchDraw();
    system("pause");
    return 0;
}

学会沉淀。
关注
  • 13
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C语言实现走迷宫
08-18
主要为大家详细介绍了C语言实现走迷宫，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
【python小游戏设计】走迷宫游戏设计与实现
caxiou的博客
12-28 1192
🔥 这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是🚩基于python的走迷宫游戏设计与实现🥇学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：3分简介Pygame是一系列专门为编写电子游戏而设计的Python模块(modules)。
走迷宫（详细分析）
2301_79532295的博客
12-07 1176
以一个 m*n 的方阵表示迷宫，0 和 1 分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的最短通路，或得出没有通路的结论。
【毕业设计】 python小游戏设计 - 走迷宫游戏设计与实现
HUXINY的博客
09-21 7880
🔥 这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是🚩基于python的走迷宫游戏设计与实现🥇学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：3分🧿简介Pygame是一系列专门为编写电子游戏而设计的Python模块(modules)。
我花了一夜用数据结构给女朋友写个H5走迷宫游戏
热门推荐
bigsai
09-21 46万+
起因 又到深夜了，我按照以往在csdn和公众号写着数据结构！这占用了我大量的时间！我的超越妹妹严重缺乏陪伴而 怨气满满！ 而女朋友时常埋怨，认为数据结构这么抽象难懂的东西没啥作用，常会问道：天天写这玩意，有啥作用。而我答道：能干事情多了，比如写个迷宫小游戏啥的！ 当我码完字准备睡觉时：写不好别睡觉！ 分析 如果用数据结构与算法造出东西来呢？ ...
c语言游戏实战（5）：走迷宫
weixin_58252863的博客
01-15 4332
制作一个迷宫游戏是一个有趣的编程挑战。首先，我们需要设计一个二维数组来表示迷宫的布局，其中每个元素代表迷宫中的一个格子。我们可以使用不同的值来表示空格、墙壁和起点/终点。接下来，我们需生成迷宫。在生成迷宫的过程中，我们需要确保迷宫中有足够的障碍物，以便玩家需要找到一条从起点到终点的路径。最后，我们需要编写代码来显示迷宫，接收用户的输入，更新迷宫的状态，判断游戏是否结束，并提供重新开始的选项。通过完成这个迷宫游戏项目，我们可以提高自己的编程能力和逻辑思维能力。
C++实现一个老鼠走迷宫游戏
Canger_的博客
08-07 6971
代码 由于C++面向对象的编程方式，注重于数据的处理，所以一个类的设计显得尤为重要。 这里我就设计了一个迷宫类，其属性有迷宫大小，空格(可行路径)的数目，入口坐标，出口坐标，以及主角老鼠的坐标，以及bool变量pass，表示判断此次生成的迷宫从入口到出口是否有通关路径。 private里的函数有构造迷宫(通过rand系函数随机生成路径，’#’代表路障，’ ‘代表可通过路径，’*’代表老鼠...
C++实现《走迷宫》小游戏
YeLuoSiLiuNian的博客
10-27 2230
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<windows.h> #include<conio.h> int main() { char a[50][50] = { "######", "#O # ", "# ## #", ...
数据结构课设-小老鼠走迷宫(JAVA版)
Haenu0317的博客
01-01 1843
题目内容:程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向健操纵老鼠在规定的时间内走到粮仓处。基本要求：⑴老鼠形象可以辨认，可用键盘操纵老鼠上下左右移动；⑵迷宫的墙足够结实，老鼠不能穿墙而过；⑶正确检测结果，若老鼠在规定时间内走到粮仓处，提示成功，并给出一条路径，否则提示失败。⑷添加编辑迷宫功能，可修改当前迷宫，修改内容：墙变路、路变墙。提高要求：⑴增加闯关和计分功能；⑵找出走出迷宫的所有路径及最短路径。
C++ 广度优先解决走迷宫问题
m0_62946761的博客
12-28 6693
C++学习Bfs算法并解决走迷宫问题
走迷宫问题栈实现.cpp
07-01
最近在leetcode上做到一个运用递归算法解决的...在此拿出三年前写的老鼠走迷宫案例来进行一个简单的分析铺垫，顺便附上完整代码，关于本资源的博客地址：https://blog.csdn.net/qq_34901049/article/details/94403330
C++实现走迷宫小游戏
08-19
主要为大家详细介绍了C++实现走迷宫小游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
莫烦老师 走迷宫 智能强化学习DQN算法实现，开箱即用
12-30
https://mofanpy.com/tutorials/machine-learning/reinforcement-learning/intro-DQN/
基于Python实现的机器人自动走迷宫.zip
06-13
实现基于基础搜索算法和 Deep QLearning 算法的机器人，使机器人自动走到迷宫的出口。 使用 Python 语言。 使用基础搜索算法完成机器人走迷宫。 使用 Deep QLearning 算法完成机器人走迷宫。 使用 Maze(maze_size=...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5102
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 428
【代码】力扣LCP 08.剧情触发时间。
【代码随想录】【算法训练营】【第35天】[134]加油站 [135]分发糖果 [860]柠檬水找零 [406]根据身高重建队列
weixin_54954007的博客
06-11 288
思路及算法思维，指路。题目来自。day 35，连休两天~
力扣416 分割等和子集 Java版本
最新发布
m0_47066863的博客
06-14 421
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
a*算法走迷宫 matlab实现
06-06
在Matlab中，我们可以按照以下步骤实现A*算法走迷宫： 1. 定义地图矩阵：用0表示可行的区域，用1表示障碍物或不可行区域。 2. 根据实际情况选择起点和终点，将它们的位置在地图矩阵中标记为2和3。 3. 定义open表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值