sonsuz bir labirentte kaybolmak mümkün mü

korkunç bir cehennem senaryosu gibi görünüyor... her çıkmaz sokağa girdiğinizde içinde olduğunuz harita güncellenir, ve rastgele bir konumda yeniden çıkışı aramaya başlayıp, sonsuz bir döngüye girersiniz.
(video artık mevcut değil)
#include <SFML/Graphics.hpp>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <stack>
#include <iostream>
#include <string>
#include <algorithm>

// Sabitler
const int WINDOW_WIDTH = 1920; // Pencere genişliği
const int WINDOW_HEIGHT = 1080; // Pencere yüksekliği
const int CELL_SIZE = 20; // Hücre boyutu (piksel)
const int GRID_WIDTH = WINDOW_WIDTH / CELL_SIZE; // Izgara genişliği
const int GRID_HEIGHT = WINDOW_HEIGHT / CELL_SIZE; // Izgara yüksekliği

// Labirent hücre durumları
enum Cell {
WALL = 0,
PATH = 1,
VISITED = 2 // Sarı hücre
};

// DFS yığını hücreleri takip etmek için kullanılır
std::stack<std::pair<int, int>> dfsStack;

// Labirent oluşturma algoritması (Derinlik-Öncelikli Arama)
void createMaze(std::vector<std::vector<Cell>>& maze) {
int startX = 1, startY = 1;
maze[startX][startY] = PATH; // Başlangıç hücresini açık olarak işaretle
dfsStack.push({startX, startY});

while (!dfsStack.empty()) {
int x, y;
std::tie(x, y) = dfsStack.top();
std::vector<std::pair<int, int>> neighbors;

// Komşu hücreleri kontrol et
if (x > 1 && maze[x - 2][y] == WALL) neighbors.push_back({x - 2, y});
if (x < GRID_WIDTH - 2 && maze[x + 2][y] == WALL) neighbors.push_back({x + 2, y});
if (y > 1 && maze[x][y - 2] == WALL) neighbors.push_back({x, y - 2});
if (y < GRID_HEIGHT - 2 && maze[x][y + 2] == WALL) neighbors.push_back({x, y + 2});

if (!neighbors.empty()) {
// Rastgele bir komşu seç ve labirenti oluştur
int randIndex = std::rand() % neighbors.size();
int newX = neighbors[randIndex].first;
int newY = neighbors[randIndex].second;

maze[newX][newY] = PATH; // Yeni hücreyi açık olarak işaretle
maze[(x + newX) / 2][(y + newY) / 2] = PATH; // Duvarı kaldır
dfsStack.push({newX, newY}); // Yeni hücreyi yığına ekle
} else {
dfsStack.pop(); // Geriye doğru ilerle
}
}
}

// Şifreleme fonksiyonu (basit dönüşüm)
std::string encryptPath(const std::vector<std::pair<int, int>>& path) {
std::string encryptedMessage;
for (const auto& coord : path) {
// Her koordinatı alfanümerik formata dönüştür
encryptedMessage += std::to_string(coord.first) + "," + std::to_string(coord.second) + ";";
}
return encryptedMessage;
}

// Yürüyüşçünün geçerli bir hareket seçeneği olup olmadığını kontrol et
bool hasValidMoves(const std::vector<std::vector<Cell>>& maze, int x, int y) {
return (x > 1 && maze[x - 1][y] == PATH) ||
(x < GRID_WIDTH - 2 && maze[x + 1][y] == PATH) ||
(y > 1 && maze[x][y - 1] == PATH) ||
(y < GRID_HEIGHT - 2 && maze[x][y + 1] == PATH);
}

int main() {
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Labirentte Rastgele Yürüyüş");
std::srand(static_cast<unsigned>(std::time(nullptr)));

// Labirent verisi
std::vector<std::vector<Cell>> maze(GRID_WIDTH, std::vector<Cell>(GRID_HEIGHT, WALL));
createMaze(maze); // Labirenti oluştur

// Rastgele başlatılan yürüyüşçü için başlangıç noktası
int x = 1 + (std::rand() % (GRID_WIDTH - 2)); // Rastgele başlangıç noktası X
int y = 1 + (std::rand() % (GRID_HEIGHT - 2)); // Rastgele başlangıç noktası Y
maze[x][y] = VISITED; // ilk hücreyi ziyaret edildi olarak işaretle
std::vector<std::pair<int, int>> visitedCells; // Ziyaret edilen hücrelerin koordinatları

sf::RectangleShape cell(sf::Vector2f(CELL_SIZE, CELL_SIZE));
sf::RectangleShape walker(sf::Vector2f(CELL_SIZE, CELL_SIZE));
walker.setFillColor(sf::Color::Yellow); // Yürüyüşçü rengi sarı

sf::Clock clock;
while (window.isOpen()) {
sf::Event event;
while (window.pollEvent(event)) {
if (event.type == sf::Event::Closed)
window.close();
}

float dt = clock.restart().asSeconds();

// Yürüyüşçünün geçerli bir hareket seçeneği olup olmadığını kontrol et
if (!hasValidMoves(maze, x, y)) {
// Eğer yoksa, yürüyüşçüyü yeni bir rastgele konumdan başlat
x = 1 + (std::rand() % (GRID_WIDTH - 2));
y = 1 + (std::rand() % (GRID_HEIGHT - 2));
maze = std::vector<std::vector<Cell>>(GRID_WIDTH, std::vector<Cell>(GRID_HEIGHT, WALL));
createMaze(maze); // Yeni bir labirent oluştur
visitedCells.clear(); // Ziyaret edilen hücreleri temizle
}

// Rastgele yürüyüş algoritması ile sonraki adımı seç
int direction = std::rand() % 4;
switch (direction) {
case 0: if (maze[x - 1][y] == PATH) x--; break; // Sol
case 1: if (maze[x + 1][y] == PATH) x++; break; // Sağ
case 2: if (maze[x][y - 1] == PATH) y--; break; // Yukarı
case 3: if (maze[x][y + 1] == PATH) y++; break; // Aşağı
}

// Yürüyüşçü bir koridora girdiyse, o hücreyi sarıya çevir
if (maze[x][y] == PATH) {
maze[x][y] = VISITED; // Ziyaret edildi olarak işaretle
visitedCells.push_back({x, y}); // Ziyaret edilen hücreyi sakla
}

// Ekranı çiz
window.clear();
for (int i = 0; i < GRID_WIDTH; ++i) {
for (int j = 0; j < GRID_HEIGHT; ++j) {
if (maze[i][j] == WALL) {
cell.setFillColor(sf::Color(0, 100, 0)); // Koyu yeşil duvar
} else if (maze[i][j] == PATH) {
cell.setFillColor(sf::Color(0, 255, 0)); // Yeşil boş hücre
} else if (maze[i][j] == VISITED) {
cell.setFillColor(sf::Color::Yellow); // Sarı hücre (ziyaret edildi)
}

cell.setPosition(i * CELL_SIZE, j * CELL_SIZE);
window.draw(cell);
}
}

// Yürüyüşçüyü çiz
walker.setPosition(x * CELL_SIZE, y * CELL_SIZE);
window.draw(walker);
window.display();
}

// Ziyaret edilen hücrelerin koordinatlarını şifrele
std::string encryptedMessage = encryptPath(visitedCells);
std::cout << "Şifrelenmiş Yol: " << encryptedMessage << std::endl;

return 0;
}