C++写简单的迷宫

文章基于C++和操作系统等方面的基础知识，迷宫程序有些不太完善，欢迎各位大佬提建议哦

编译器DEV-C++ 5.11

#include <iostream>
#include <vector>
#include <stack>
#include <stdlib.h>
#include <time.h>
#include <conio.h> // 用于_getch()
#include <thread> // 用于线程
#include <chrono> // 用于时间操作
#include <atomic> // 用于原子操作

using namespace std;

const char WALL = '#';
const char PATH = ' ';
const char START = 'S';
const char END = 'E';
const char PLAYER = 'P';
const char VISITED = '.'; // 表示玩家访问过的路径

struct Position {
    int x, y;
};

class Maze {
private:
    int size;
    vector<vector<char>> grid;
    Position start, end, player;
    int moves;
    int difficulty;
    vector<Position> path; // 存储玩家走过的路径
    atomic<int> countdown; // 倒计时秒数，使用原子操作以确保线程安全
    atomic<bool> gameFinished; // 标记游戏是否结束
    int score; // 玩家的分数

public:
    Maze(int n, int diff) : size(n), difficulty(diff), moves(0), countdown(60), gameFinished(false), score(0) {
        srand(time(NULL));
        generateMaze();
    }
    void calculateScore() {
        // 分数计算公式可以根据需要调整
        int timeBonus = countdown; // 剩余时间作为时间奖励
        int difficultyBonus = difficulty; // 难度奖励
        score = timeBonus * difficultyBonus;
    }
    
    void generateMaze() {
        grid.resize(size, vector<char>(size, WALL));

        // 初始化起点
        start = {1, 1};
        grid[start.x][start.y] = PATH;

        // 使用回溯算法生成迷宫
        stack<Position> positions;
        positions.push(start);
        while (!positions.empty()) {
            Position current = positions.top();
            positions.pop();
            vector<Position> neighbors = getUnvisitedNeighbors(current);
            if (!neighbors.empty()) {
                positions.push(current);
                int randIndex = rand() % neighbors.size();
                Position next = neighbors[randIndex];
                grid[next.x][next.y] = PATH;
                grid[(current.x + next.x) / 2][(current.y + next.y) / 2] = PATH;
                positions.push(next);
            }
        }

        // 设置终点
        end = {size - 2, size - 2};
        grid[end.x][end.y] = PATH;

        player = start;
    }

    vector<Position> getUnvisitedNeighbors(Position p) {
        vector<Position> neighbors;
        vector<Position> directions = {{0, 2}, {2, 0}, {0, -2}, {-2, 0}};
        for (auto& d : directions) {
            Position next = {p.x + d.x, p.y + d.y};
            if (next.x > 0 && next.x < size - 1 && next.y > 0 && next.y < size - 1 && grid[next.x][next.y] == WALL) {
                neighbors.push_back(next);
            }
        }
        return neighbors;
    }
    void printMazeWithCountdown() {
        system("cls"); // 清屏
        cout << "倒计时: " << countdown << "秒   分数: " << score << endl; // 显示倒计时和分数
        for (int i = 0; i < size; ++i) {
            for (int j = 0; j < size; ++j) {
                if (player.x == i && player.y == j) {
                    cout << PLAYER; // 显示玩家位置
                } else if (end.x == i && end.y == j) {
                    cout << END; // 显示终点位置
                } else {
                    cout << grid[i][j]; // 显示迷宫的其他部分
                }
            }
            cout << endl;
        }
    }
   void printMaze() {
        system("cls"); // 清屏
        cout << "倒计时: " << countdown << "秒" << endl; // 显示倒计时
        for (int i = 0; i < size; ++i) {
            for (int j = 0; j < size; ++j) {
                if (player.x == i && player.y == j) {
                    cout << PLAYER; // 显示玩家位置
                } else if (end.x == i && end.y == j) {
                    cout << END; // 显示终点位置
                } else {
                    cout << grid[i][j]; // 显示迷宫的其他部分
                }
            }
            cout << endl;
        }
    }

     void outputPath() {
        // 将走过的路径标记在迷宫上
        for (const auto& pos : path) {
            grid[pos.x][pos.y] = VISITED;
        }
        printMaze();
    }
   void playMaze() {
        auto startTime = clock();
        thread timerThread(&Maze::startCountdown, this); // 创建一个线程来处理倒计时

        char move;
        bool moved = false;
        while (!gameFinished) {
            if (_kbhit()) {
                move = _getch();
                if (makeMove(move)) {
                    gameFinished = true; // 玩家到达终点，游戏结束
                    break;
                }
                moved = true;
            } else {
                printMazeWithCountdown(); // 时间不依赖于玩家移动而刷新
                moved = false;
            }
            this_thread::sleep_for(chrono::milliseconds(100)); // 暂停100毫秒以减少CPU使用率
        }

        timerThread.join(); // 等待倒计时线程结束

        if (gameFinished) {
            clock_t endTime = clock();
            double timeTaken = double(endTime - startTime) / CLOCKS_PER_SEC;
            calculateScore(); // 计算分数
            cout << "游戏结束! 总移动次数: " << moves << " 用时: " << timeTaken << "秒   分数: " << score << endl;
            if (player.x == end.x && player.y == end.y) {
                cout << "恭喜你到达终点!" << endl;
            } else {
                cout << "时间耗尽，游戏失败!" << endl;
            }
            
        // 询问用户是否输出路径
        char output;
        cout << "是否输出走过的路径？(y/n): ";
        cin >> output;
        if (output == 'y' || output == 'Y') {
            outputPath();
          } 
        }
    }

    void startCountdown() {
        while (countdown > 0 && !gameFinished) {
            this_thread::sleep_for(chrono::seconds(1)); // 暂停1秒
            countdown--;
        }
        if (countdown <= 0) {
            gameFinished = true; // 时间耗尽，游戏结束
        }
    }

    bool makeMove(char move) {
        int newX = player.x, newY = player.y;
        switch (move) {
            case 'w': newX--; break;
            case 's': newX++; break;
            case 'a': newY--; break;
            case 'd': newY++; break;
            default: return false;
        }

        if (newX >= 0 && newX < size && newY >= 0 && newY < size && grid[newX][newY] != WALL) {
            // 记录路径
            path.push_back({newX, newY});
            player.x = newX;
            player.y = newY;
            moves++;
            return player.x == end.x && player.y == end.y;
        }
        return false;
    }

};
int main() {
    int n, difficulty;
    cout << "请输入迷宫的大小N（奇数，例如5）: ";
    cin >> n;
    cout << "请选择迷宫难度（1-简单，2-中等，3-困难）: ";
    cin >> difficulty;
    while (difficulty < 1 || difficulty > 3) {cout << "无效的难度级别，请重新输入（1-简单，2-中等，3-困难）: ";
        cin >> difficulty;
    }

    Maze maze(n, difficulty);
    maze.playMaze();

    return 0;
}

注意：这里输入迷宫大小为奇数，偶数有点问题。