迷宫游戏（c++版）

已于 2024-08-30 09:40:46 修改
阅读量1k 收藏 20
点赞数 22
文章标签： c++
于 2024-08-30 09:39:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daivi_/article/details/141707127
版权

#include <stdio.h>
#include <iostream>
#include <conio.h>
#include <windows.h>
#include <time.h>
#include<bits/stdc++.h>
using namespace std;
#define Wall 1        //用1表示墙 
#define Road 0        //用0表示路 
#define Start 2
#define End 3
#define up 72          
#define down 80
#define left 75
#define right 78
#define flag 5        
int Height=0,Width=0,N; 
int x=2,y=1; //玩家当前位置，刚开始在入口处
  bool visited[100][100];
class Migong
{
public:
    int difficulty;
    int map[100][100];
    void gotoxy(int x,int y);    //移动坐标的函数声明
    void shengcheng(int x,int y);   //随机生成迷宫的函数声明
    void display(int x,int y);    //显示迷宫的函数声明 
    void chushi();   //初始化迷宫的函数声明
     void setDifficulty(int diff);
       void setExit(); // 新增设置出口位置的函数声明
};

class Wanjia:public Migong         //玩家类由迷宫类派生来 
{
public:
    void gonglue(int x,int y); 
    void shang(int x,int y);
    void xia(int x,int y);
    void zuo(int x,int y);
    void you(int x,int y); 
    void game();     //游戏运行包括移动的函数声明 
};
void Migong::setExit() {
    // 出口默认放置在迷宫的右下角
    map[Height - 1][Width] = End;
    // 可以在这里添加逻辑来根据难度或其他因素调整出口的位置
}
void Migong::gotoxy(int x,int y) //移动坐标                         这是使光标 到（x，y）这个位置的函数.调用 COORD 需要#include.
{
    COORD coord;
    coord.X=x;
    coord.Y=y;
    SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}

void Migong::shengcheng(int x,int y) //随机生成迷宫
{
    int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向                                //数组c 0  1   向右 
    //      1  0   向下 
    //     -1  0   向上 
    //      0 -1   向左 
    
    int i,j,t; 
    //将方向打乱
    for(i=0;i<4;i++)
    {
        j=rand()%4;                                //随机生成j 
        t=c[i][0];c[i][0]=c[j][0];c[j][0]=t;       //将c[i][0]和c[j][0]交换 
        t=c[i][1];c[i][1]=c[j][1];c[j][1]=t;       //类似上 
    }
    map[x][y]=Road;                                //当前位置设为路
    for(i=0;i<4;i++)                               //沿四个方向设置
        if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall)    //沿c[i][0]、c[i][1]方向前2步如果是墙
        {
            map[x+c[i][0]][y+c[i][1]]=Road;        //让该方向前一步设为路 
            shengcheng(x+2*c[i][0],y+2*c[i][1]);   //在该方向前两步继续生成地图        因为这里是递归函数，当执行到最后一点发现都不能走的时候，
            //会返回到上一个函数，也就是上一个点，再次判断是否可以产生地图 ，知道地图上所有点被遍历完。 
        }
}
void Migong::setDifficulty(int diff) {
    // 根据难度设置墙的比例
    int wallRatio;
    switch (diff) {
        case 1: wallRatio = 2; break; // 简单难度
        case 2: wallRatio = 40; break; // 中等难度
        case 3: wallRatio = 60; break; // 困难难度
        default: wallRatio = 20; break;
    }
    
    // 根据墙的比例初始化迷宫
    for (int i = 1; i <= Height; i++) {
        for (int j = 1; j <= Width; j++) {
            if (rand() % 100 < wallRatio) {
                map[i][j] = Wall;
            } else {
                map[i][j] = Road;
            }
        }
    }
    
    // 确保入口和出口是路
    map[1][1] = Start;
    map[Height - 1][Width] = End;
}

void Migong::display(int x,int y) //显示迷宫
{
    gotoxy(2*y-2,x-1);
    switch(map[x][y])
    {
    case Start:
        cout<<"入";break; //显示入口
    case End:
        cout<<"出";break; //显示出口
    case Wall:
        cout<<"■";break; //显示墙
    case Road:
        cout<<" ";break; //显示路
    case up:
        cout<<"↑";break;  //在攻略中的标记 下同 
    case down:
        cout<<"↓";break;
    case left:
        cout<<"←";break; 
    case right:
        cout<<"→";break;
        case flag:         
        cout<<" ";break;    //标记，防止攻略遍历时候无线循环 
    }
}
void shuru()
{
    cout<<"请输入您想创建的迷宫的N*N大小:"<<endl;
    cin>>N;
}
void Migong::chushi() {
    int i, j;
    srand((unsigned)time(NULL)); // 初始化随机种子
    for (i = 1; i <= Height + 1; i++)
        for (j = 1; j <= Width + 1; j++)
            if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) // 初始化迷宫       默认四周是路
                map[i][j] = Road;
    else map[i][j] = Wall;
    shengcheng(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); // 从随机一个点开始生成迷宫，该点行列都为偶数
    for (i = 0; i <= Height + 1; i++) // 边界处理      把最开始默认为路的堵上,以免跑出迷宫
    {
        map[i][0] = Wall;
        map[i][Width + 1] = Wall;
    }
    for (j = 0; j <= Width + 1; j++) // 边界处理
    {
        map[0][j] = Wall;
        map[Height + 1][j] = Wall;
    }
    map[2][1] = Start; // 给定入口
    setExit(); // 设置出口位置
    for (i = 1; i <= Height; i++)                // i初始为1,结束为height,以免画出外围
    {
        for (j = 1; j <= Width; j++) // 画出迷宫   同上
        {
            display(i, j);
        }
    }
}
void Wanjia::game()
{
    int x=2,y=1; //玩家当前位置，刚开始在入口处
    int c; //用来接收按键
    int score = 0; // 初始化得分
        clock_t startTime = clock();
    while(1)
    {
        gotoxy(2*y-2,x-1);
        cout << "☆"; //画出玩家当前位置
        if(map[x][y] == End) //判断是否到达出口
        {
            gotoxy(2*N-2, N-1); //到达此坐标
            cout << "恭喜你！成功走出迷宫！" << endl;
            switch(difficulty)
            {
                case 1: score = 10; break; // 简单难度
                case 2: score = 20; break; // 中等难度
                case 3: score = 30; break; // 困难难度
            }
            cout << "你的得分是：" << score <<"分！"<< endl;
            clock_t endTime = clock();
            double gameDuration = double(endTime - startTime) / CLOCKS_PER_SEC;
            
// 输出游戏用时
            cout << "游戏用时: " << gameDuration << " 秒" << endl;
            cout << "是否要打印走过的路径进行复盘？（Y/N）: ";
            char choice;
            cin >> choice;
            if(choice == 'Y' || choice == 'y') {
                // 打印玩家走过的路径
                for(int i=1;i<=Height;i++)                //i初始为1,结束为height,以免画出外围 
                {        for(int j=1;j<=Width;j++) //画出迷宫   同上 
                {if(visited[i][j]) {
                        gotoxy(2*j-2,i-1);
                    cout << "*"; // 打印走过的位置
                }
                else{
                    gotoxy(2*j-2,i-1);
                    switch(map[i][j])
                    {
                    case Start:
                        cout<<"入";break; //显示入口
                    case End:
                        cout<<"出";break; //显示出口
                    case Wall:
                        cout<<"■";break; //显示墙
                    case Road:
                        cout<<" ";break; //显示路
                    case up:
                        cout<<"↑";break;  //在攻略中的标记 下同 
                    case down:
                        cout<<"↓";break;
                    case left:
                        cout<<"←";break; 
                    case right:
                        cout<<"→";break;
                        case flag:         
                        cout<<" ";break;    //标记，防止攻略遍历时候无线循环 
                    }
                }
                
                }    
                }}
                getch();
                exit(0);
            break;
        }
        if(c != -32)
        {
            c = getch();
            switch(c)
            {
                case 72: // 向上走
                if(map[x-1][y] != Wall)
                {
                    display(x, y);
                    x--;
                }
                break;
                case 80: // 向下走
                if(map[x+1][y] != Wall)
                {
                    display(x, y);
                    x++;
                }
                break;
                case 75: // 向左走
                if(map[x][y-1] != Wall)
                {
                    display(x, y);
                    y--;
                }
                break;
                case 77: // 向右走
                if(map[x][y+1] != Wall)
                {
                    display(x, y);
                    y++;
                }
                break;
                case 112:    // 按下P
                gonglue(2,1);break;           //如果按下P执行攻略函数
            }
        }
        visited[x][y] = 1;
    }
}
void Wanjia::shang(int x,int y)
{
    if(map[x][y]==End) //判断是否到达出口
    {
        gotoxy(2*N-2,N-1);  //到达此坐标 
        cout<<"到达终点，按任意键结束";
        
        getch();
        exit(0);
    }
    if(map[x-1][y]!=Wall&&map[x-1][y]!=up&&map[x-1][y]!=down&&map[x-1][y]!=left&&map[x-1][y]!=right&&map[x-1][y]!=flag)   
    {                                           //当移动后的下一个位置没有被走过且不是墙                                                           
        
        map[x][y]=up;
        display(x,y);
        x--;
        gonglue(x,y);          //递归，攻略下一个点 
    }    
}
void Wanjia::xia(int x,int y)
{
    if(map[x][y]==End) //判断是否到达出口
    {
        gotoxy(2*N-2,N-1);  //到达此坐标 
        
        getch();
        exit(0);
    }
    if(map[x+1][y]!=Wall&&map[x+1][y]!=up&&map[x+1][y]!=down&&map[x+1][y]!=left&&map[x+1][y]!=right&&map[x+1][y]!=flag) //当移动后的下一个位置没有被走过且不是墙 
    {
        
        map[x][y]=down;
        display(x,y);
        x++;
        gonglue(x,y);            //递归，攻略下一个点
    }
}
void Wanjia::zuo(int x,int y)
{
    if(map[x][y]==End) //判断是否到达出口
    {
        gotoxy(2*N-2,N-1);  //到达此坐标 
        cout<<"到达终点，按任意键结束";         
        getch();
        exit(0);
    }
    if(map[x][y-1]!=Wall&&map[x][y-1]!=up&&map[x][y-1]!=down&&map[x][y-1]!=left&&map[x][y-1]!=right&&map[x][y-1]!=flag) //当移动后的下一个位置没有被走过且不是墙 
    {
        
        map[x][y]=left;
        display(x,y);
        y--;
        
        gonglue(x,y); //递归，攻略下一个点
    }
}
void Wanjia::you(int x,int y)
{
    if(map[x][y]==End) //判断是否到达出口
    {
        gotoxy(2*N-2,N-1);  //到达此坐标 
        cout<<"到达终点，按任意键结束";    
        getch();
        exit(0);
    }
    if(map[x][y+1]!=Wall&&map[x][y+1]!=up&&map[x][y+1]!=down&&map[x][y+1]!=left&&map[x][y+1]!=right&&map[x][y+1]!=flag) //当移动后的下一个位置没有被走过且不是墙 
    {
        
        map[x][y]=right;
        display(x,y);
        y++;
        gonglue(x,y); //递归，攻略下一个点
    }
}
void Wanjia::gonglue (int x,int y)
{
    gotoxy(2*y-2,x-1);
    cout<<"☆"; //画出玩家当前位置
    if(map[x][y]==End) //判断是否到达出口
    {
        gotoxy(2*N-2,N-1);  //到达此坐标 
        cout<<"到达终点，按任意键结束";
        getch();
        exit(0); 
    }
    shang(x,y);                 //上下左右 
    xia(x,y);
    zuo(x,y);
    you(x,y);
    map[x][y]=flag;             //当上下左右都无法走的时候，即为死路，因为递归函数开始向后，所以讲死路点值置为flag，变成无形之墙。 
    display(x,y);              
}
int main()
{Migong a;
    cout<<"      移动迷宫      "<<endl;
    cout<<"--------------------"<<endl; 
    cout<<"欢迎来到移动迷宫游戏"<<endl;
    cout<<"--------------------"<<endl;
    cout<<"游戏说明：给定一出口和入口"<<endl;
    cout<<"玩家控制一个五角星（☆）从入口走到出口"<<endl;
    cout<<"系统会记录你所走的步数"<<endl;
    cout<<"按回车进入游戏";
    cout<<"(按下P键可以获得攻略。)"; 
    getch();
    system("cls");      //清屏函数 ，清除开始界面 
    Wanjia w1;
    cout << "请选择难度等级（1-简单，2-中等，3-困难）: ";
    cin >> w1.difficulty;
    shuru();
    Width=N;
    Height=N;
    a.map[N][N];
    system("cls"); // 清屏，清除开始界面
    w1.chushi();
    w1.game(); //开始游戏
//    w1.gonglue(2,1);  //功略显示 
        getch();
    return 0;
}

可实现难度选择，迷宫大小的创建：

走过路径的打印：

以及攻略的获取（按p键即可）：

daivi_
关注
迷宫(c++)
qq_41572774的博客
11-13 1962
/* 作者：史松岩 （失落之风） 说明：自动生成随机迷宫，并且玩家可以操作走到终点 */ #include &lt;stdio.h&gt; #include &lt;iostream&gt; #include &lt;conio.h&gt; #include &lt;windows.h&gt; #include &lt;time.h&gt; using namespace std; ...
C++EGE版迷宫游戏
03-12
【C++ EGE版迷宫游戏】是一款基于C++编程语言开发的游戏，它利用了EGE（可能是指Extended Graphics Engine，一个图形库）来实现游戏的视觉效果和交互功能。这个游戏的核心是迷宫，玩家需要在虚拟迷宫中寻找出路。...
C语言迷宫游戏（二维数组）C-mazeGame-master.zip
03-24
C语言迷宫游戏（二维数组）C_mazeGame-master.zip
c++简单迷宫游戏
05-06
建立一个窗口（一个资源文件，一个头文件，两个类）。导入图片（将图片从外部文件——内存——缓冲区——窗口）。开辟缓冲区 建立画架，将图放入画架。图片动态化（将键盘与程序挂钩——建立Windows message KEYDOWN.)清除残影（SRCCOPY---------WHITENESS). 建立迷宫(建一个二维数组，1代表墙，0代表通道，2代表入口，3代表出口，将图片墙导入窗口测试修改
C++迷宫求解算法实现与优化
最新发布
weixin_28968525的博客
09-25 952
本文还有配套的精品资源，点击获取 简介：在C++中，迷宫求解算法是编程学习的重要课题，涉及搜索算法、图论和路径查找技术。迷宫通常被抽象为二维矩阵，算法包括深度优先搜索（DFS）、广度优先搜索（BFS）和A*算法等。文章将详细介绍这些方法在C++中的实现，并强调如何通过数据结构和优先级队列来优化搜索效率，实现路径回溯。最终目标是创建一个 MazeSolver 类...
c语言迷宫游戏源代码
11-29
c语言实现的迷宫游戏完整源代码，界面友好美观，很适合c语言源码的学习！
C++迷宫游戏
11-13
C++迷宫游戏，供初学者学习MAC游戏开发参考，实现了多关卡，攻击怪兽，难度提升，传送门等功能
迷宫游戏 c++版
12-29
玩家可以进行迷宫游戏。具有创建迷宫，修改迷宫，走迷宫，退出游戏功能。
C++ 迷宫游戏
热门推荐
麦迪儿的博客
12-26 1万+
介绍 本程序是根据广度优先遍历算法的思想设计的一款迷宫游戏，游戏设计了两种模式一种自动游戏模式，一种手动模式。因为项目在 Linux 开发，需要在 Windows 开发的，请查看源代码中需要修改地方的备注。 代码 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;cstdlib&amp;amp;gt; //标准库 #include &amp;amp;lt;unistd.h&amp;
使用C++编写简单的迷宫游戏
qq_18352005的博客
02-28 1万+
迷宫游戏就是玩家在地图中移动，移动至终点则游戏结束。自己用文本文档手打了个小地图，0表示空白，1表示墙，文件名随意，我改成了map.MapData。然后程序里定义一个全局变量char Map[MapLenX][MapLenY];(长宽自定义)行为X，列为Y。定义char型常量RoadSymbol = '0', WallSymbol = '1', PlayerSymbol = '+'。本游戏为面向对...
【C++】迷宫
None
05-16 3887
C++实现迷宫
基于QT+C++开发的迷宫游戏+源码（毕业设计&课程设计&项目开发）
05-01
基于QT+C++开发的迷宫游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于QT+C++开发的迷宫游戏+源码，适合毕业设计、课程设计、项目开发。项目源码...
VC.rar.rar_luck_vc 动画_迷宫游戏_迷宫游戏 c++
09-20
【标题】"VC.rar.rar_luck_vc 动画_迷宫游戏_迷宫游戏 c++" 描述了一个基于C++编程语言开发的迷宫游戏项目，其中包含了启动画面以及一个图形化显示的“LUCK”字样。这个项目可能是一个学生作品或者编程爱好者的练习...
migong.rar_迷宫游戏 c++
09-23
【迷宫游戏 C++ 实现详解】 在编程领域，C++是一种强大且广泛使用的编程语言，尤其适合开发高性能的应用程序，包括游戏。本项目“migong.rar”提供了一个使用C++实现的迷宫游戏，这是一份很好的学习资源，让我们...
C++实现迷宫游戏
01-20
本文实例为大家分享了C++实现迷宫游戏的具体代码，供大家参考，具体内容如下 #include using namespace std; //点为2表示迷宫图为█，点为0表示迷宫图为 int migo[9][9]= { {2, 2, 2, 2, 2, 2, 2, 2, 2}, {2, 0,...
c++迷宫小游戏
11-16
无聊的小游戏
C++迷宫问题完全详解
weixin_42163707的博客
12-20 3517
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
c++迷宫游戏
m0_64990369的博客
12-07 231
#include <conio.h> #include <windows.h> #include <bits/stdc++.h> using namespace std; void SetPos(COORD a) { HANDLE out=GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleCursorPosition(out, a); } void SetPos(int i, int j) { COORD pos= {i, j}.
迷宫游戏C++代码
08-06
华南理工大学计算机专业，C++作业，大一写的，共享一下，慎下。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值