binary floor generator

#include <iostream>
#include <vector>
#include <ctime>
#include <queue>

using namespace std;

/*
 * Для матрицы определенно следующее
 * 1 - X комната
 * 2 - | коридор
 * 3 - - коридор
 *
 * Этот алгоритм (как мне кажется) удобнее будет использовать для спавна
 * ибо в анриле есть методы проверки, возможен ли спавн и т.д. Тем самым можно перестроить
 * этот алгоритм на блюпринты
 */

// Вариации путей при 4-х возможных направлениях (спавна)
const int rand_ways_four[6][4] =
        {
                {1, 1, 0, 0},
                {1, 0, 1, 0},
                {1, 0, 0, 1},
                {0, 1, 1, 0},
                {0, 1, 0, 1},
                {0, 0, 1, 1}
        };

// Вариации путей при 3-х возможных направлениях (спавна)
const int rand_ways_three[3][3] =
        {
                {1, 1, 0},
                {1, 0, 1},
                {0, 1, 1}
        };

// Процедура генерации матрицы (в анриле это канешна будет не матрица,
// спавн будет происходит в реалтайме без использоания матрицы
// матрица тут ток для показа нужна
vector<vector<int>> generate_matrix(int N, int size)
{
    // Генерируем матрицу и задаем начало генерации
    vector<vector<int>> matrix(size, vector<int>(size, 0));
    matrix[size / 2][size / 2] = 1;

    // Создаем очередь свободных ячеек (или же направлений спавна комнат/коридоров)
    queue<pair<int, int>> q;
    q.push(make_pair(size / 2, size / 2));

    // Ну тут поиск в ширину
    while (N > 0 && !q.empty())
    {
        // Получаем занесенные в очередь координаты
        pair<int, int> coords = q.front();
        q.pop();

        // подсчитываем количество путей, в которые НЕ можем пойти
        int count_cant =
                matrix[coords.first + 2][coords.second] +
                matrix[coords.first - 2][coords.second] +
                matrix[coords.first][coords.second + 2] +
                matrix[coords.first][coords.second - 2];

        // Если можем пойти хотя бы в два направления
        if (count_cant <= 2)
        {
            // Количество возможных путей
            int count_can = 4 - count_cant;

            // Список вохможных путей
            vector<pair<int, int>> possible;

            // Добавляем в этот список пути, в которые можем пойти
            // 0 в матрице - можем идти
            if (!matrix[coords.first + 2][coords.second])
                possible.emplace_back(coords.first + 2, coords.second);

            if (!matrix[coords.first - 2][coords.second])
                possible.emplace_back(coords.first - 2, coords.second);

            if (!matrix[coords.first][coords.second + 2])
                possible.emplace_back(coords.first, coords.second + 2);

            if (!matrix[coords.first][coords.second - 2])
                possible.emplace_back(coords.first, coords.second - 2);

            // Для двух возможных путей заносим их все
            if (count_can == 2)
            {
                for (auto c : possible)
                {
                    if (N > 0)
                    {
                        // Выставляем комнату
                        matrix[c.first][c.second] = 1;

                        // соединяем коридором
                        if (c.first == coords.first + 2)
                            matrix[coords.first + 1][coords.second] = 2;
                        if (c.first == coords.first - 2)
                            matrix[coords.first - 1][coords.second] = 2;
                        if (c.second == coords.second + 2)
                            matrix[coords.first][coords.second + 1] = 3;
                        if (c.second == coords.second - 2)
                            matrix[coords.first][coords.second - 1] = 3;

                        // уменьшаем количество комнат
                        N--;
                        //заносим в очередь
                        q.push(c);
                    }
                }
            }
            else if (count_can == 3)
            {
                // Вычисляем индекс путей пути нипутю
                int k = rand()%3;
                for (int i = 0; i < possible.size(); ++i)
                {
                    if (N > 0 && rand_ways_three[k][i])
                    {
                        // Выставляем комнату
                        matrix[possible[i].first][possible[i].second] = 1;

                        // Коридор (много т.к для массива (можно и в отдельную функцию вынести))
                        if (possible[i].first == coords.first + 2)
                            matrix[coords.first + 1][coords.second] = 2;
                        if (possible[i].first == coords.first - 2)
                            matrix[coords.first - 1][coords.second] = 2;
                        if (possible[i].second == coords.second + 2)
                            matrix[coords.first][coords.second + 1] = 3;
                        if (possible[i].second == coords.second - 2)
                            matrix[coords.first][coords.second - 1] = 3;

                        // уменьшаем количество путей
                        N--;
                        // заносим в очередь
                        q.push(possible[i]);
                    }
                }
            }
            else if (count_can == 4)
            {
                // Ну тут как в предыдущем
                int k = rand() % 6;
                for (int i = 0; i < possible.size(); ++i)
                {
                    if (N > 0 && rand_ways_four[k][i])
                    {
                        matrix[possible[i].first][possible[i].second] = 1;

                        if (possible[i].first == coords.first + 2)
                            matrix[coords.first + 1][coords.second] = 2;
                        if (possible[i].first == coords.first - 2)
                            matrix[coords.first - 1][coords.second] = 2;
                        if (possible[i].second == coords.second + 2)
                            matrix[coords.first][coords.second + 1] = 3;
                        if (possible[i].second == coords.second - 2)
                            matrix[coords.first][coords.second - 1] = 3;

                        N--;
                        q.push(possible[i]);
                    }
                }
            }
        }

    }

    return matrix;
}

int main()
{
    int n, seed;

    // колво комнат
    cout << "Num of rooms: " << endl;
    cin >> n; n--;

    // зерно
    cout << "Seed: " << endl;
    cin >> seed;

    // закладываем зерно
    srand(seed);

    // получаем матрицу
    vector<vector<int>> matrix = generate_matrix(n, 101);

    // вот ет большое вывод, советую окно консоли растянуть на весь экран для большого количества комнат
    for (int i = 0; i < matrix.size(); ++i)
    {
        for (int j = 0; j < matrix.size(); ++j)
        {
            if (matrix[i][j] == 1)
            {
                if (i == 50 && j == 50)
                    cout << 'X';
                else
                    cout << 'x';
            }
            else if (matrix[i][j] == 2)
                cout << '|';
            else if (matrix[i][j] == 3)
                cout << '-';
            else
                cout << ' ';
        }
        cout << endl;
    }

    return 0;
}