sonsuz bir labirentte kaybolmak mümkün mü

entry5 galeri
    1.
  1. 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.


    #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;
    }
    1 ...
  1. henüz yorum girilmemiş
© 2025 uludağ sözlük