开源软件：devc++5.9.2

祝大家玩的开心

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <iostream>
using namespace std;
// 定义迷宫元素
#define WALL '#'
#define PATH ' '
#define PLAYER 'P'
#define EXIT 'E'
int VIEW_SIZE=0,MAZE_SIZE,VIEW_HALF;
// 玩家结构体
typedef struct {
    int x;
    int y;
} Player;

// 深度优先搜索生成迷宫
void dfsMazeGenerator(char maze[100][100], int x, int y) {
    // 定义四个方向：上、右、下、左
    int dirs[4][2] = {{-2, 0}, {0, 2}, {2, 0}, {0, -2}};
    int i, j, tempX, tempY;
    int nx, ny;
    
    // 随机打乱方向顺序
    for (i = 0; i < 4; i++) {
        j = rand() % 4;
        // 交换方向
        tempX = dirs[i][0];
        tempY = dirs[i][1];
        dirs[i][0] = dirs[j][0];
        dirs[i][1] = dirs[j][1];
        dirs[j][0] = tempX;
        dirs[j][1] = tempY;
    }
    
    // 尝试每个方向
    for (i = 0; i < 4; i++) {
        nx = x + dirs[i][0];
        ny = y + dirs[i][1];
        
        // 检查是否在迷宫内且未访问过
        if (nx > 0 && nx < MAZE_SIZE - 1 && ny > 0 && ny < MAZE_SIZE - 1 && maze[nx][ny] == WALL) {
            // 打通当前位置与新位置之间的墙
            maze[nx][ny] = PATH;
            maze[x + dirs[i][0]/2][y + dirs[i][1]/2] = PATH;
            
            // 递归生成
            dfsMazeGenerator(maze, nx, ny);
        }
    }
}

// 生成迷宫（修复出口位置）
void generateMaze(char maze[100][100]) {
    int i, j;
    
    // 初始化迷宫为墙
    for (i = 0; i < MAZE_SIZE; i++) {
        for (j = 0; j < MAZE_SIZE; j++) {
            maze[i][j] = WALL;
        }
    }
    
    // 随机数种子
    srand(time(NULL));
    
    // 从中心开始生成（确保是奇数坐标）
    int startX = (MAZE_SIZE / 2) % 2 == 0 ? MAZE_SIZE / 2 + 1 : MAZE_SIZE / 2;
    int startY = (MAZE_SIZE / 2) % 2 == 0 ? MAZE_SIZE / 2 + 1 : MAZE_SIZE / 2;
    maze[startX][startY] = PATH;
    
    // 使用DFS算法生成迷宫
    dfsMazeGenerator(maze, startX, startY);
    
    // 修复：确保出口与内部路径连通
    int exitX, exitY;
    int exitSide = rand() % 4;
    
    // 尝试生成出口，直到找到与内部路径相邻的位置
    do {
        switch (exitSide) {
            case 0: // 上边
                exitX = 0;
                exitY = rand() % (MAZE_SIZE - 2) + 1;
                break;
            case 1: // 右边
                exitX = rand() % (MAZE_SIZE - 2) + 1;
                exitY = MAZE_SIZE - 1;
                break;
            case 2: // 下边
                exitX = MAZE_SIZE - 1;
                exitY = rand() % (MAZE_SIZE - 2) + 1;
                break;
            case 3: // 左边
                exitX = rand() % (MAZE_SIZE - 2) + 1;
                exitY = 0;
                break;
        }
        
        // 如果出口旁边不是路径，就换一个边尝试
        if (exitSide == 0 && maze[1][exitY] != PATH) exitSide = (exitSide + 1) % 4;
        if (exitSide == 1 && maze[exitX][MAZE_SIZE - 2] != PATH) exitSide = (exitSide + 1) % 4;
        if (exitSide == 2 && maze[MAZE_SIZE - 2][exitY] != PATH) exitSide = (exitSide + 1) % 4;
        if (exitSide == 3 && maze[exitX][1] != PATH) exitSide = (exitSide + 1) % 4;
        
    } while (
        (exitSide == 0 && maze[1][exitY] != PATH) ||
        (exitSide == 1 && maze[exitX][MAZE_SIZE - 2] != PATH) ||
        (exitSide == 2 && maze[MAZE_SIZE - 2][exitY] != PATH) ||
        (exitSide == 3 && maze[exitX][1] != PATH)
    );
    
    // 设置出口
    maze[exitX][exitY] = EXIT;
    
    // 确保出口与内部路径连通（打通最后一道墙）
    if (exitSide == 0) maze[1][exitY] = PATH;      // 上边出口，打通下方的墙
    if (exitSide == 1) maze[exitX][MAZE_SIZE - 2] = PATH;  // 右边出口，打通左方的墙
    if (exitSide == 2) maze[MAZE_SIZE - 2][exitY] = PATH;  // 下边出口，打通上方的墙
    if (exitSide == 3) maze[exitX][1] = PATH;      // 左边出口，打通右方的墙
}

// 显示视野范围内的迷宫
void displayView(char maze[100][100], Player player) {
    int i, j, x, y;
    
    // 清屏
    system("cls");
    
    printf("移动迷宫游戏 - 视野范围: %dx%d\n", VIEW_SIZE, VIEW_SIZE);
    printf("使用方向键移动，ESC键退出\n");
    printf("made by Gang\n");
    printf("当前位置: (%d, %d)\n\n", player.x, player.y);
    
    // 显示视野范围内的内容
    for (i = 0; i < VIEW_SIZE; i++) {
        for (j = 0; j < VIEW_SIZE; j++) {
            // 计算实际迷宫坐标
            x = player.x - VIEW_HALF + i;
            y = player.y - VIEW_HALF + j;
            
            // 检查是否在迷宫内
            if (x >= 0 && x < MAZE_SIZE && y >= 0 && y < MAZE_SIZE) {
                // 如果是玩家位置，显示玩家
                if (x == player.x && y == player.y) {
                    printf("%c ", PLAYER);
                } else {
                    printf("%c ", maze[x][y]);
                }
            } else {
                // 迷宫外部显示为墙
                printf("%c ", WALL);
            }
        }
        printf("\n");
    }
}

// 检查移动是否有效
int isValidMove(char maze[100][100], Player player, int dx, int dy) {
    int newX = player.x + dx;
    int newY = player.y + dy;
    
    // 检查是否在迷宫范围内且不是墙
    return (newX >= 0 && newX < MAZE_SIZE && newY >= 0 && newY < MAZE_SIZE && 
           (maze[newX][newY] == PATH || maze[newX][newY] == EXIT));
}

// 检查是否到达出口
int hasReachedExit(char maze[100][100], Player player) {
    return maze[player.x][player.y] == EXIT;
}

int main() {
    char maze[100][100];
    Player player;
    int key;
    int dx, dy;
    while(VIEW_SIZE%2==0){
        cout<<"input size:";
        cin>>MAZE_SIZE;
        cout<<"input the size of see(单数):";
        cin>>VIEW_SIZE;
    }
    VIEW_HALF=VIEW_SIZE/2;
    // 生成迷宫
    generateMaze(maze);
    
    // 初始化玩家位置（迷宫中心）
    player.x = MAZE_SIZE / 2;
    player.y = MAZE_SIZE / 2;
    
    // 确保玩家初始位置在路径上
    if (maze[player.x][player.y] == WALL) {
        // 如果中心是墙，寻找附近的路径
        for (dx = -1; dx <= 1; dx++) {
            for (dy = -1; dy <= 1; dy++) {
                if (maze[player.x + dx][player.y + dy] == PATH) {
                    player.x += dx;
                    player.y += dy;
                    break;
                }
            }
        }
    }
    
    // 游戏主循环
    while (1) {
        // 显示视野
        displayView(maze, player);
        
        // 检查是否到达出口
        if (hasReachedExit(maze, player)) {
            printf("\n恭喜你找到出口，成功逃离迷宫！\n");
            break;
        }
        
        // 等待按键
        key = _getch();
        
        // 处理方向键（方向键会产生两个字符，第一个是0xE0）
        if (key == 0xE0) {
            key = _getch();
            dx = 0;
            dy = 0;
            
            switch (key) {
                case 72:  // 上
                    dx = -1;
                    break;
                case 80:  // 下
                    dx = 1;
                    break;
                case 75:  // 左
                    dy = -1;
                    break;
                case 77:  // 右
                    dy = 1;
                    break;
            }
            
            // 检查移动是否有效，如果有效则移动
            if (isValidMove(maze, player, dx, dy)) {
                player.x += dx;
                player.y += dy;
            }
        }
        // 处理ESC键退出
        else if (key == 27) {
            printf("\n游戏已退出。\n");
            break;
        }
    }
    
    return 0;
}