labirinto tunadasso

#include <iostream>
#include <vector>
#include <random>
#include <algorithm>
#include <fstream>
#include <stack>
#include <queue>

using namespace std;

void gerarCaminhoDFS(vector<vector<char>>& layout, int startX, int startY, ofstream& iterationFile) {
    vector<pair<int, int>> directions = {{-2, 0}, {2, 0}, {0, -2}, {0, 2}};
    random_device rd;
    mt19937 g(rd());

    stack<pair<int, int>> s;
    s.push({startX, startY});

    int largura, comprimento;

    largura = layout.size();
    comprimento = layout[1].size();

    while (!s.empty()) {
        auto [x, y] = s.top();
        s.pop();

        shuffle(directions.begin(), directions.end(), g);

        for (auto& dir : directions) {
            int nx = x + dir.first;
            int ny = y + dir.second;

            if (nx > 0 && nx < layout.size() - 1 && ny > 0 && ny < layout[0].size() - 1 && layout[nx][ny] == '|') {
                layout[nx][ny] = ' ';
                layout[x + dir.first / 2][y + dir.second / 2] = ' ';
                s.push({nx, ny});
            }

            // escreve as iterações da geração em outro txt
            for (int i = 0; i < largura; i++) {
                for (int j = 0; j < comprimento; j++) {
                    iterationFile << layout[i][j] << " ";
                }
                iterationFile << endl;
            }
            iterationFile << endl;
        }
    }
}

void gerarCaminhoBFS(vector<vector<char>>& layout, int startX, int startY, ofstream& iterationFile) {
    vector<pair<int, int>> directions = {{-2, 0}, {2, 0}, {0, -2}, {0, 2}};
    random_device rd;
    mt19937 g(rd());

    queue<pair<int, int>> q;
    q.push({startX, startY});

    int largura, comprimento;

    largura = layout.size();
    comprimento = layout[1].size();

    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        shuffle(directions.begin(), directions.end(), g);

        for (auto& dir : directions) {
            int nx = x + dir.first;
            int ny = y + dir.second;

            if (nx > 0 && nx < layout.size() - 1 && ny > 0 && ny < layout[0].size() - 1 && layout[nx][ny] == '|') {
                layout[nx][ny] = ' ';
                layout[x + dir.first / 2][y + dir.second / 2] = ' ';
                q.push({nx, ny});
            }

            // imprime as iterações
            for (int i = 0; i < largura; i++) {
                for (int j = 0; j < comprimento; j++) {
                    iterationFile << layout[i][j] << " ";
                }
                iterationFile << endl;
            }
            iterationFile << endl;
        }
    }
}

int main() {
    //altura e largura
    int largura = 59;
    int comprimento = 59;

    // enche de paredes
    vector<vector<char>> layoutBFS(largura, vector<char>(comprimento, '|'));
    vector<vector<char>> layoutDFS(largura, vector<char>(comprimento, '|'));

    random_device rd;
    mt19937 g(rd());
    int entrada = rand() % (comprimento - 2) + 1;
    int saida = rand() % (comprimento - 2) + 1;

    ofstream iterationFileBFS("iteracoes_gerarCaminhoBFS.txt");
    if (!iterationFileBFS.is_open()) {
        cout << "Faiô.txt" << endl;
        return 1;
    }

    ofstream iterationFileDFS("iteracoes_gerarCaminhoDFS.txt");
    if (!iterationFileDFS.is_open()) {
        cout << "Faiô.txt" << endl;
        return 1;
    }

    // definir o começo
    layoutBFS[0][entrada] = ' ';
    gerarCaminhoBFS(layoutBFS, 1, entrada, iterationFileBFS);
    iterationFileBFS.close();

    layoutDFS[0][entrada] = ' ';
    gerarCaminhoDFS(layoutDFS, 1, entrada, iterationFileDFS);
    iterationFileDFS.close();

    vector<int> possibilidades_saidaBFS;

    for (int i = 0; i < comprimento; i++) {
        if (layoutBFS[largura - 2][i] == ' ') {
            possibilidades_saidaBFS.push_back(i);
        }
    }

    if (!possibilidades_saidaBFS.empty()) {
        saida = possibilidades_saidaBFS[rand() % possibilidades_saidaBFS.size()];
        layoutBFS[largura - 1][saida] = ' ';
    }

    vector<int> possibilidades_saidaDFS;

    for (int i = 0; i < comprimento; i++) {
        if (layoutDFS[largura - 2][i] == ' ') {
            possibilidades_saidaDFS.push_back(i);
        }
    }

    if (!possibilidades_saidaDFS.empty()) {
        saida = possibilidades_saidaDFS[rand() % possibilidades_saidaDFS.size()];
        layoutDFS[largura - 1][saida] = ' ';
    }

    // ver o resultado
    for (int i = 0; i < largura; i++) {
        for (int j = 0; j < comprimento; j++) {
            cout << layoutBFS[i][j] << " ";
        }
        cout << endl;
    }

    cout<<endl;

    for (int i = 0; i < largura; i++) {
        for (int j = 0; j < comprimento; j++) {
            cout << layoutDFS[i][j] << " ";
        }
        cout << endl;
    }

    // Write the labyrinth layoutBFS to a file
    ofstream outputFileBFS("labirintoBFS.txt");
    if (outputFileBFS.is_open()) {
        for (int i = 0; i < largura; i++) {
            for (int j = 0; j < comprimento; j++) {
                outputFileBFS << layoutBFS[i][j] << " ";
            }
            outputFileBFS << endl;
        }
        outputFileBFS.close();
        cout << "Labirinto criado lá no labirinto.txt" << endl;
    } else {
        cout << "criacionismo falhou." << endl;
    }


    ofstream outputFileDFS("labirintoDFS.txt");
    if (outputFileDFS.is_open()) {
        for (int i = 0; i < largura; i++) {
            for (int j = 0; j < comprimento; j++) {
                outputFileDFS << layoutDFS[i][j] << " ";
            }
            outputFileDFS << endl;
        }
        outputFileDFS.close();
        cout << "Labirinto criado lá no labirinto.txt" << endl;
    } else {
        cout << "criacionismo falhou." << endl;
    }

    return 0;
}