2. 程式人生 > 程式設計 >C++隨機生成迷宮演算法

C++隨機生成迷宮演算法

阿新 • • 發佈：2020-03-20

本文例項為大家分享了C++隨機生成迷宮的具體程式碼，供大家參考，具體內容如下

我們今天來做一個迷宮遊戲。在其中有幾個要領：

1.方向的控制

我們建立的迷宮是以座標的形式出現的，越往上x座標越小，越往左y座標越小，這雨平面直角座標系不同，要注意！

2.隨機生成演算法：

void init_maze(void); //初始化迷宮
void gotoxy(int x,int y); //移動游標
void path_up(int *x,int *y); //上構路徑
void path_down(int *x,int *y); //下構路徑
void path_left(int *x,int *y); //左構路徑
void path_right(int *x,int *y); //右構路徑
void setxy(int x,int y); //指定位打通路徑
void path_local(int x,int y); //本置路徑

這是我們需要的函式，主要功能呢在程式碼中有講到。如果大家自己在程式設計時需要自己生成迷宮，可以借鑑一下。

3.程式碼

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h>
#include<iostream>
#include<ctime>
#include <windows.h>
using namespace std;
#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
 
#define M 40 //迷宮長度
#define N 82 //迷宮寬度
 
char maze[M/2][N/2]; //定義迷宮陣列
char path[M-1][N-1]; //定義路徑陣列
 
void setview(void); //設定控制檯視窗資訊
int menu_maze(void); //主目錄
void startgame(void); //開始遊戲
void init_maze(void); //初始化迷宮
void gotoxy(int x,int y); //本置路徑
void go_up(int *x,int *y); //向上移動
void go_down(int *x,int *y); //向下移動
void go_left(int *x,int *y); //向左移動
void go_right(int *x,int *y); //向右移動
void HideCursor(void); //隱藏游標
void win(void);
 
int T;
int F;
int m;
int n;
int x;
int target;
int flag;
int local_x;
int local_y;
 
int main()
{
 setview();
 while(1)
 {
 switch(menu_maze())
 {
 case 49:
 system("cls");
 startgame();
 continue;
 case 50:exit(0);
 }
 }
}
 
void setview()
{
 HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); // 獲取標準輸出裝置控制代碼
 COORD size = {N*2+167,M*2+43};
 SetConsoleScreenBufferSize(hOut,size); //設定控制檯視窗緩衝區大小 
 SMALL_RECT rc = {0,167,43};
 SetConsoleWindowInfo(hOut,true,&rc); //設定視窗位置和大小
 
 SetConsoleTitle("迷宮"); //設定視窗標題
 
 HideCursor(); //隱藏游標
}
 
int menu_maze(void)
{
 char c;
 while(!(c>48&&c<51))
 {
 system("cls");
 printf("\n\n\n\n\n\n\n\n");
 printf(" ………………^歡迎使用DOS迷宮遊戲^……………\n");
 printf(" *******************************************\n");
 printf(" **************** 1.開始遊戲****************\n");
 printf(" **************** 2.退出遊戲****************\n");
 printf(" *******************************************\n");
 c=getch();
 }
 return c; 
}
 
void startgame() 
{ 
 char key;
 local_x=0;
 local_y=0;
 system("cls");
 init_maze();
 gotoxy(2,2);
 printf("");
 while(path[M-2][N-2]!='o')
 {
 key=getch();
 if(key==-32)
 {
 key=getch();
 switch(key)
 {
 case UP:
 if(path[local_x-1][local_y]!='t'&&path[local_x-1][local_y]!='o'||local_x-1<0) break; //路徑不通或越界
 go_up(&local_x,&local_y);
 break;
 case DOWN:
 if(path[local_x+1][local_y]!='t'&&path[local_x+1][local_y]!='o'||local_x+1>M-2) break;
 go_down(&local_x,&local_y);
 break;
 case LEFT:
 if(path[local_x][local_y-1]!='t'&&path[local_x][local_y-1]!='o'||local_y-1<0) break;
 go_left(&local_x,&local_y);
 break;
 case RIGHT:
 if(path[local_x][local_y+1]!='t'&&path[local_x][local_y+1]!='o'||local_y+1>N-2) break;
 go_right(&local_x,&local_y);
 break;
 }
 }
 }
 system("cls");
 win();
}
 
void init_maze()
{
 int i,j;
 
 T=1;
 F=1;
 m=0;
 n=0;
 x=0;
 flag=0;
 
 srand((unsigned)time(NULL));
 
 for(i=0;i<M/2;i++) //初始化迷宮陣列
 {
 for(j=0;j<N/2;j++)
 maze[i][j]='f';
 }
 
 for(i=0;i<M-1;i++) //初始化路徑陣列
 {
 for(j=0;j<N-1;j++)
 path[i][j]='f';
 }
 path[0][0]='t';
 
 for(i=0;i<N+1;i++) //邊框
 cout<<"**";
 cout<<endl;
 for(i=0;i<M+1;i++)
 {
 for(j=0;j<N+1;j++)
 {
 cout<<"■";
 }
 cout<<endl;
 
 }
 for(i=0;i<N+1;i++)
 cout<<"**";
 cout<<endl;
 
 while(F)//構建迷宮
 {
 if(T==0)
 {
 for(j=0;j<N/2;j++)
 {
 for(i=0;i<M/2;i++)
 {
 if(maze[i][j]=='f')
 {
 m=i;
 n=j;
 maze[m][n]='t';
 path_local(m,n);
 if(maze[m-1][n]==maze[0][0]) //向上有未打通路徑
 {
 path_up(&m,&n);
 m=i;
 n=j;
 flag--;
 break;
 }
 if(maze[m+1][n]==maze[0][0]) //向下有未打通路徑
 {
 path_down(&m,&n);
 m=i;
 n=j;
 flag--;
 break;
 }
 if(maze[m][n-1]==maze[0][0]) //向左有未打通路徑
 {
 path_left(&m,&n);
 m=i;
 n=j;
 flag--;
 break;
 }
 if(maze[m][n+1]==maze[0][0]) //向右有未打通路徑
 {
 path_right(&m,&n);
 m=i;
 n=j;
 flag--;
 break;
 }
 }
 }
 if(m==i&&n==j)
 break;
 }
 }
 T=1;
 while(T)
 {
 x++;
 if(m==0&&n==0)//游標在起始位置
 {
 maze[m][n]='t';
 path_local(m,n);
 switch(rand()%2)
 {
 case 0://向下
 path_down(&m,&n);
 break;
 case 1://向右
 path_right(&m,&n);
 }
 }
 if(m==M/2-1&&n==0)//游標在左下角
 {
 switch(rand()%2)
 {
 case 0://向上
 if(maze[m-1][n]==maze[0][0]) break; //已打通路徑
 path_up(&m,&n);
 break;
 case 1://向右
 if(maze[m][n+1]==maze[0][0]) break;
 path_right(&m,&n);
 }
 }
 if(m==0&&n==N/2-1)//游標在右上角
 {
 switch(rand()%2)
 {
 case 0://向下
 if(maze[m+1][n]==maze[0][0]) break;
 path_down(&m,&n);
 break;
 case 1://向左
 if(maze[m][n-1]==maze[0][0]) break;
 path_left(&m,&n);
 break;
 }
 }
 if(m==M/2-1&&n==N/2-1)//游標在右下角
 {
 switch(rand()%2)
 {
 case 0://向上
 if(maze[m-1][n]==maze[0][0]) break;
 path_up(&m,&n);
 break;
 }
 }
 if(m==0&&n!=0&&n!=N/2-1)//游標在第一行
 {
 switch(rand()%3)
 {
 case 0://向下
 if(maze[m+1][n]==maze[0][0]) break;
 path_down(&m,&n);
 break;
 case 2://向右
 if(maze[m][n+1]==maze[0][0]) break;
 path_right(&m,&n);
 }
 }
 if(m!=0&&m!=M/2-1&&n==0)//游標在第一列
 {
 switch(rand()%3)
 {
 
 case 0://向上
 if(maze[m-1][n]==maze[0][0]) break;
 path_up(&m,&n);
 break;
 case 1://向下
 if(maze[m+1][n]==maze[0][0]) break;
 path_down(&m,&n);
 }
 }
 if(m==M/2-1&&n!=0&&n!=N/2-1)//游標在最後一行
 {
 switch(rand()%3)
 {
 case 0://向上
 if(maze[m-1][n]==maze[0][0]) break;
 path_up(&m,&n);
 }
 }
 if(m!=0&&m!=M/2-1&&n==N/2-1)//游標在最後一列
 {
 switch(rand()%3)
 {
 case 0://向上
 if(maze[m-1][n]==maze[0][0]) break;
 path_up(&m,&n);
 break;
 case 2://向左
 if(maze[m][n-1]==maze[0][0]) break;
 path_left(&m,&n);
 }
 }
 if(m!=0&&m!=M/2-1&&n!=0&&n!=N/2-1)//游標在中間部分
 {
 switch(rand()%4)
 {
 case 0://向上
 if(maze[m-1][n]==maze[0][0]) break;
 path_up(&m,&n);
 break;
 case 3://向右
 if(maze[m][n+1]==maze[0][0]) break;
 path_right(&m,&n);
 }
 }
 if(x>M*N/4)
 {
 x=0;
 if(m==0&&n==0&&maze[m][n+1]==maze[0][0]&&maze[m+1][n]==maze[0][0]) T=0;//初始位置死路
 if(m==0&&n==N/2-1&&maze[m][n-1]==maze[0][0]&&maze[m+1][n]==maze[0][0]) T=0;//右上角死路
 if(m==M/2-1&&n==0&&maze[m][n+1]==maze[0][0]&&maze[m-1][n]==maze[0][0]) T=0;//左下角死路
 if(m==M/2-1&&n==N/2-1&&maze[m][n-1]==maze[0][0]&&maze[m-1][n]==maze[0][0]) T=0;//終點死路
 if(m==0&&n!=0&&n!=N/2-1&&maze[m][n-1]==maze[0][0]&&maze[m][n+1]==maze[0][0]&&maze[m+1][n]==maze[0][0]) T=0;//第一行死路
 if(m!=0&&m!=M/2-1&&n==0&&maze[m-1][n]==maze[0][0]&&maze[m][n+1]==maze[0][0]&&maze[m+1][n]==maze[0][0]) T=0;//第一列死路
 if(m!=0&&m!=M/2-1&&n==N/2-1&&maze[m-1][n]==maze[0][0]&&maze[m][n-1]==maze[0][0]&&maze[m+1][n]==maze[0][0]) T=0;//最後一列死路
 if(m==M/2-1&&n!=0&&n!=N/2-1&&maze[m-1][n]==maze[0][0]&&maze[m][n+1]==maze[0][0]&&maze[m][n-1]==maze[0][0]) T=0;//最後一行死路
 if(m>0&&m<M/2-1&&n>0&&n<N/2-1&&maze[m+1][n]==maze[0][0]&&maze[m-1][n]==maze[0][0]&&maze[m][n+1]==maze[0][0]&&maze[m][n-1]==maze[0][0]) T=0;//中間部分死路
 }
 }
 if(flag==M*N/4)
 F=0;
 }
/* i=M+3;
 gotoxy(0,i);
 for(i=0;i<M-1;i++)
 {
 for(j=0;j<N-1;j++)
 {
 if(path[i][j]=='f')
 printf("1");
 if(path[i][j]=='t')
 printf("0");
 }
 printf("\n");
 }
 getch();*/
}
 
void gotoxy(int x,int y)
{
COORD pos = {x,y};
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(hOut,pos);
}
 
void path_up(int *x,int *y)
{
 int i,j;
 maze[--(*x)][*y]=maze[0][0];
 path[2*(*x+1)-1][2*(*y)]=path[0][0];
 path_local(*x,*y);
 i=4*(*y)+2;
 j=2*(*x)+3;
 gotoxy(i,j);
 printf(" ");
}
 
void path_down(int *x,j;
 maze[++(*x)][*y]=maze[0][0];
 path[2*(*x-1)+1][2*(*y)]=path[0][0];
 path_local(*x,*y);
 i=4*(*y)+2;
 j=2*(*x)+1;
 gotoxy(i,j);
 printf(" ");
}
 
void path_left(int *x,j;
 maze[*x][--(*y)]=maze[0][0];
 path[2*(*x)][2*(*y+1)-1]=path[0][0];
 path_local(*x,*y);
 i=4*(*y)+4;
 j=2*(*x)+2;
 gotoxy(i,j);
 printf(" ");
}
 
void path_right(int *x,j;
 maze[*x][++(*y)]=maze[0][0];
 path[2*(*x)][2*(*y-1)+1]=path[0][0];
 path_local(*x,*y);
 i=4*(*y);
 j=2*(*x)+2;
 gotoxy(i,j);
 printf(" ");
}
 
void setxy(int x,int y)
{
 gotoxy(x,y);
 printf(" ");
}
 
void path_local(int x,int y)
{
 int i,j;
 i=4*y+2;
 j=2*x+2;
 gotoxy(i,j);
 printf(" ");
 path[2*x][2*y]=path[0][0];
 flag++;
}
 
void go_up(int *x,j;
 i=2*(*y)+2;
 j=(*x)+2;
 gotoxy(i,j);
 printf(" ");
 j-=1;
 gotoxy(i,j);
 printf("");
 (*x)--;
 path[*x][*y]='o';
}
 
void go_down(int *x,j);
 printf(" ");
 j+=1;
 gotoxy(i,j);
 printf("");
 (*x)++;
 path[*x][*y]='o';
}
void go_left(int *x,j);
 printf(" ");
 i-=2;
 gotoxy(i,j);
 printf("");
 (*y)--;
 path[*x][*y]='o';
}
 
void go_right(int *x,j);
 printf(" ");
 i+=2;
 gotoxy(i,j);
 printf("");
 (*y)++;
 path[*x][*y]='o';
}
 
void HideCursor()
{
CONSOLE_CURSOR_INFO cursor_info = {1,0}; 
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
}
 
void win()
{
 printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
 "   恭喜你，成功了！");
 getch();
}

怎麼樣，還是蠻簡單的吧？

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。

相關推薦

C++隨機生成迷宮演算法

本文例項為大家分享了C++隨機生成迷宮的具體程式碼，供大家參考，具體內容如下

C語言使用Bresenham演算法生成直線（easyx圖形庫）

Bresenham演算法是計算機圖形學領域使用最廣泛的直線掃描轉換方法。 其原理是：過各行、各列畫素中心構造一組虛擬網格線，按直線從起點到終點的順序計算直線各垂直網格線的交點，然後確定該列畫素中與此交點最近的畫

C語言隨機生成四則運算題目

一、基本功能 1.隨機產生含有“+”“-”“*”“/”中兩個運算子的四則運算題目，運算數在1-100之間。

C++ 隨機數字以及隨機數字加字母生成的案例

我就廢話不多說了，大家還是直接看程式碼吧~ #include <time.h> #include <sys/timeb.h>

Prime演算法生成迷宮

技術標籤：寫著玩（前端）js演算法 prime迷宮生成 結果展示演算法解析實現程式碼

C#實踐(二)--------隨機生成10個3位整數，找出其中的最大、最小數並輸出

技術標籤：C#資料結構c# 題目：隨機生成10個3位整數，找出其中的最大、最小數並輸出

生成樹演算法生成迷宮

生成迷宮的常見演算法有遞歸回溯、遞迴分治等等；生成樹演算法可以用來生成完美迷宮，即任何兩個可達點之間只有一條通路；本文采用`Kruskal最小生成樹演算法`來生成一個完美迷宮

c++隨機字串生成

#include <iostream> #include <random> #include <ctime> #include <chrono> namespace ShellRandom {

隨機化演演算法與素性測試

前言 大家好，這是上班以後的第一篇blog，預計後邊演演算法還有2篇。也就是說這是本人算法系列倒數第3篇，感謝大家的指正，今天是說明隨機化演演算法。

java 隨機生成6位簡訊驗證碼例項程式碼

生成6位隨機數字其實很簡單，只需一行程式碼，具體如下： String verifyCode = String.valueOf(new Random().nextInt(899999) + 100000);

Java如何隨機生成圖片驗證碼

本文例項為大家分享了Java隨機生成圖片驗證碼的具體程式碼，供大家參考，具體內容如下

java實現隨機生成驗證碼圖片

驗證碼 驗證碼（CAPTCHA）是“Completely Automated Public Turing test to tell Computers and Humans Apart”（全自動區分計算機和人類的圖靈測試）的縮寫。由於計算機無法解答CAPTCHA的問題，所以回答出問題的使用

隨機生成八位優惠碼並儲存至Mysql資料庫

目前很多商家通過優惠碼做活動，現在我們簡單的實現八位的優惠碼，並儲存在資料庫中。

python隨機生成庫faker庫api例項詳解

廢話不多說，直接上程式碼！ # -*- coding: utf-8 -*- # @Author : FELIX # @Date: 2018/6/30 9:49

C# 數獨求解演算法的實現

前言 數獨是一種有趣的智力遊戲，但是部分高難度數獨在求解過程中經常出現大量單元格有多個候選數字可以填入，不得不嘗試填寫某個數字然後繼續推導的方法。不幸的是這種方法經常出現填到一半才發現有單元格無數可填，

Python實現隨機生成任意數量車牌號

之前做課設的時候舍友遇到了需要生成500w量級車牌號的問題，於是我便寫了一個隨機生成車牌號的程式，希望各位採納。

python隨機生成大小寫字母數字混合密碼(僅20行程式碼)

用簡單的方法生成隨機性較大的密碼 僅用20行程式碼隨機生成密碼 核心思路:利用random模組

C++實現歸併排序演算法

歸併 歸併排序（MERGE-SORT）是建立在歸併操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使

C++實現走迷宮小遊戲

本文例項為大家分享了C++實現走迷宮小遊戲的具體程式碼，供大家參考，具體內容如下

Python 隨機生成測試資料的模組：faker基本使用方法詳解

本文例項講述了Python 隨機生成測試資料的模組：faker基本使用方法。分享給大家供大家參考，具體如下：