Unity ile Mayın Tarlası: Grid Oluşturma ve Hücreleri Açığa Çıkarma

Mayın Tarlası (Minesweeper), basit kuralları ve derin stratejisiyle yıllardır popülerliğini koruyan klasik bir bulmaca oyunudur. Bu oyunu Unity ile geliştirmek, hem temel oyun mekaniklerini anlamak hem de C# programlama becerilerinizi pekiştirmek için harika bir başlangıç noktasıdır. Bu makalede, Mayın Tarlası'nın temel taşlarından ikisi olan mayın tarlası grid yapısını oluşturmayı ve hücreleri doğru bir şekilde açığa çıkarma mantığını adım adım inceleyeceğiz.

Mayın Tarlası Grid Yapısı ve Temelleri

Bir Mayın Tarlası oyunu, temelde bir ızgara (grid) üzerinde oynanır. Bu ızgara, her biri belirli bir duruma sahip hücrelerden oluşur. Unity'de bu ızgarayı temsil etmek için genellikle iki boyutlu bir dizi (array) veya liste kullanılır. Her hücre, içinde bir mayın olup olmadığını, çevresindeki mayın sayısını ve kendi durumunu (kapalı, açık, işaretli) bilmelidir.

Hücre (Cell) Sınıfı veya Yapısı

Oyunun her bir hücresini temsil etmek için özel bir C# sınıfı veya yapısı oluşturmak işimizi kolaylaştıracaktır. Bu yapı, her hücrenin özelliklerini barındırır:

public class Cell
{
    public int x; // Hücrenin X koordinatı
    public int y; // Hücrenin Y koordinatı
    public bool hasMine; // Mayın içeriyor mu?
    public int mineCountAround; // Çevresindeki mayın sayısı
    public bool isRevealed; // Açığa çıkarıldı mı?
    public bool isFlagged; // Bayrakla işaretlendi mi?

    public Cell(int x, int y)
    {
        this.x = x;
        this.y = y;
        hasMine = false;
        mineCountAround = 0;
        isRevealed = false;
        isFlagged = false;
    }
}

Bu `Cell` yapısı, oyunun mantıksal temelini oluşturur. Oyun tahtasını temsil eden ana sınıfımız (örneğin `Board` veya `GridManager`), bu `Cell` nesnelerinden oluşan bir 2D diziye sahip olacaktır.

Mayın Tarlası Grid Oluşturma ve Mayın Yerleştirme

Oyunun başlaması için öncelikle mayın tarlası grid yapısını oluşturmalı ve mayınları rastgele yerleştirmeliyiz. Bu süreç genellikle şu adımları içerir:

Grid Boyutlarını Belirleme: Kaç satır ve sütundan oluşacağını tanımlayın (örn: 9x9, 16x16).
Hücreleri Başlatma: Belirlenen boyutlarda boş `Cell` nesneleriyle bir 2D dizi doldurun.
Mayınları Yerleştirme: Belirli sayıda mayını rastgele, ancak benzersiz konumlara yerleştirin.
Komşu Mayın Sayılarını Hesaplama: Her mayınsız hücre için çevresindeki mayın sayısını hesaplayın.

Kod Örneği: Grid Başlatma ve Mayın Yerleştirme

Aşağıdaki kod bloğu, bir `Board` sınıfının bu adımları nasıl gerçekleştirebileceğini gösterir:

public class Board : MonoBehaviour
{
    public int rows = 9;
    public int cols = 9;
    public int totalMines = 10;
    public Cell[,] grid; // 2D hücre dizimiz

    void Start()
    {
        InitializeGrid();
        PlaceMines();
        CalculateNeighborMineCounts();
        // Gridin görsel temsilini burada oluşturabilirsiniz
    }

    void InitializeGrid()
    {
        grid = new Cell[rows, cols];
        for (int y = 0; y < rows; y++)
        {
            for (int x = 0; x < cols; x++)
            {
                grid[y, x] = new Cell(x, y);
            }
        }
    }

    void PlaceMines()
    {
        int minesPlaced = 0;
        while (minesPlaced < totalMines)
        {
            int randX = Random.Range(0, cols);
            int randY = Random.Range(0, rows);

            if (!grid[randY, randX].hasMine)
            {
                grid[randY, randX].hasMine = true;
                minesPlaced++;
            }
        }
    }

    void CalculateNeighborMineCounts()
    {
        for (int y = 0; y < rows; y++)
        {
            for (int x = 0; x < cols; x++)
            {
                if (!grid[y, x].hasMine)
                {
                    grid[y, x].mineCountAround = CountMinesAround(x, y);
                }
            }
        }
    }

    int CountMinesAround(int x, int y)
    {
        int count = 0;
        for (int i = -1; i <= 1; i++)
        {
            for (int j = -1; j <= 1; j++)
            {
                if (i == 0 && j == 0) continue; // Kendi hücresi değil

                int neighborX = x + i;
                int neighborY = y + j;

                // Dizi sınırları içinde mi kontrol et
                if (neighborX >= 0 && neighborX < cols && 
                    neighborY >= 0 && neighborY < rows)
                {
                    if (grid[neighborY, neighborX].hasMine)
                    {
                        count++;
                    }
                }
            }
        }
        return count;
    }
}

Hücreleri Açığa Çıkarma (Revealing Cells) Mantığı

Oyunun en kritik mekaniği, kullanıcının tıklamasıyla hücrelerin nasıl açığa çıktığıdır. Bu, hücre açma mantığı olarak da bilinen, farklı senaryolara göre değişen bir işlemdir:

Mayınlı Hücre: Eğer oyuncu mayın içeren bir hücreye tıklarsa, oyun biter.
Numaralı Hücre: Eğer oyuncu çevresinde mayın olan (yani `mineCountAround > 0`) bir hücreye tıklarsa, sadece o hücre açılır ve üzerindeki sayı gösterilir.
Boş Hücre (0 Komşu Mayın): Eğer oyuncu çevresinde hiç mayın olmayan (yani `mineCountAround == 0`) bir hücreye tıklarsa, bu hücre ve bitişiğindeki tüm boş hücreler (ve bu boş hücrelere bitişik numaralı hücreler) otomatik olarak açılır. Bu işlem, genellikle bir "flood fill" algoritması kullanılarak özyinelemeli (recursive) bir şekilde yapılır.

Kod Örneği: Hücre Açma Fonksiyonu

public void RevealCell(int x, int y)
{
    // Dizi sınırları kontrolü
    if (x < 0 || x >= cols || y < 0 || y >= rows)
        return;

    Cell cell = grid[y, x];

    // Zaten açılmışsa veya bayraklıysa işlem yapma
    if (cell.isRevealed || cell.isFlagged)
        return;

    cell.isRevealed = true;

    // Mayın varsa oyun biter
    if (cell.hasMine)
    {
        Debug.Log("Mayına bastın! Oyun bitti.");
        // Oyun sonu mantığını burada tetikle
        return;
    }

    // Çevresinde mayın yoksa komşuları da aç
    if (cell.mineCountAround == 0)
    {
        for (int i = -1; i <= 1; i++)
        {
            for (int j = -1; j <= 1; j++)
            {
                // Kendi hücresi değil ve sınırların içinde
                if (!(i == 0 && j == 0))
                {
                    RevealCell(x + i, y + j); // Özyinelemeli çağrı
                }
            }
        }
    }
    // Görsel güncellemeyi burada tetikle
    // Örneğin, hücrenin Sprite'ını veya rengini değiştir.
}

Bu `RevealCell` fonksiyonu, bir hücre tıklandığında ne olacağını belirler. Özellikle `mineCountAround == 0` durumu için özyinelemeli çağrı, Mayın Tarlası'nın karakteristik "boş alan açma" özelliğini sağlar. Bu algoritma, bir hücrenin çevresindeki tüm komşuları kontrol ederek, onların da boş olması durumunda onları açığa çıkarır ve bu işlemi zincirleme olarak devam ettirir.

Pratik İpuçları

Görsel Geribildirim ve Unity Objeleri: Mantıksal mayın tarlası grid yapısını oluşturduktan sonra, her `Cell` için bir Unity `GameObject`'i oluşturarak oyun alanını görselleştirebilirsiniz. Bu `GameObject`'ler, kullanıcının tıklamasını algılayacak `Collider`'lara ve hücre durumuna göre değişecek `SpriteRenderer`'lara sahip olabilir. `RevealCell` fonksiyonu çağrıldığında, ilgili `GameObject`'in görselini güncellemeyi unutmayın.
Bayrak Mekaniği: Oyuncuların potansiyel mayın konumlarını işaretlemesi için bir bayrak mekaniği ekleyin. Genellikle sağ tıklama ile tetiklenir. `Cell` sınıfına eklediğimiz `isFlagged` değişkeni bu iş için kullanılabilir. Bir hücre bayraklıysa, açığa çıkarılamaz ve mayın kontrolü yapılmaz.
Kullanıcı Girişi Yönetimi: Unity'nin `Input.GetMouseButtonDown(0)` (sol tık) ve `Input.GetMouseButtonDown(1)` (sağ tık) fonksiyonlarını kullanarak hücre tıklamalarını algılayın. Raycast kullanarak fare konumundan hangi hücreye tıklandığını tespit edebilirsiniz. Örneğin, bir `Camera.main.ScreenPointToRay(Input.mousePosition)` ile ışın gönderip, `Physics.Raycast` ile hücre `GameObject`'ine çarpıp çarpmadığına bakabilirsiniz.

Yaygın Hatalar ve Çözümleri

Mayınların Üst Üste Gelmesi: Mayın yerleştirme döngüsünde `Random.Range` kullanırken, aynı hücreye birden fazla mayın yerleştirme riski vardır. Bunu önlemek için, mayın yerleştirmeden önce ilgili hücrenin zaten mayınlı olup olmadığını kontrol edin (`if (!grid[randY, randX].hasMine)` gibi). Alternatif olarak, tüm olası hücre konumlarını bir listeye atıp, rastgele seçimle bu listeden elemanları çıkararak mayın yerleştirebilirsiniz.
Özyinelemeli (Recursive) Flood Fill Sonsuz Döngüsü: `RevealCell` fonksiyonunda `cell.isRevealed` kontrolünü yapmamak, eğer bir hücre zaten açılmışsa bile tekrar işlemeye çalışarak sonsuz döngüye veya performans sorunlarına yol açabilir. Her özyinelemeli çağrıdan önce hücrenin zaten açık olup olmadığını kontrol ettiğinizden emin olun.
Dizi Sınırları Dışı Hatası (`IndexOutOfRangeException`): `CountMinesAround` veya `RevealCell` gibi fonksiyonlarda komşu hücreleri kontrol ederken, dizi sınırlarının dışına çıkmamak için her zaman `if (neighborX >= 0 && neighborX < cols && neighborY >= 0 && neighborY < rows)` gibi kontroller yapın. Bu, oyununuzun çökmesini engeller.

Performans ve Optimizasyon Notları

Mayın Tarlası gibi genellikle küçük veya orta boyutlu mayın tarlası grid'lere sahip oyunlarda performans genellikle büyük bir sorun teşkil etmez. Ancak, çok büyük gridler (örneğin 100x100 veya daha büyük) oluşturmayı planlıyorsanız şunları göz önünde bulundurabilirsiniz:

Object Pooling: Her hücre için ayrı bir `GameObject` oluşturmak yerine, hücre görsellerini bir havuzdan (object pool) alıp geri dönüştürmek, `Instantiate` ve `Destroy` çağrılarının getirdiği yükü azaltır.
Veri Odaklı Tasarım: Oyun mantığını (grid array'i) görsel temsilden (Unity `GameObject`'leri) mümkün olduğunca ayırmak, daha temiz kod ve potansiyel performans artışı sağlar. Görsel güncellemeleri yalnızca gerektiğinde tetikleyin.
Özyineleme Derinliği: `RevealCell` fonksiyonundaki özyineleme (recursion), çok büyük boş alanlarda yığın taşmasına (stack overflow) neden olabilir. C# varsayılan olarak belirli bir özyineleme derinliğine sahiptir. Eğer bu bir sorun olursa, "flood fill" algoritmasını özyinelemeli olmayan bir kuyruk (queue) tabanlı yaklaşımla (iterative approach) yeniden yazmayı düşünebilirsiniz.

Sonuç

Bu makalede, Unity ve C# kullanarak basit bir Mayın Tarlası oyununun temel mekaniklerini, özellikle mayın tarlası grid yapısını oluşturmayı ve hücreleri açığa çıkarma mantığını detaylıca inceledik. Bir `Cell` sınıfı oluşturarak, gridi başlatarak, mayınları yerleştirerek ve komşu mayın sayılarını hesaplayarak oyunun iskeletini kurduk. Ardından, bir hücreye tıklandığında ne olacağını belirleyen `RevealCell` fonksiyonunu ve onun "flood fill" özelliğini öğrendik. Bu temel bilgilerle, kendi Mayın Tarlası oyununuzu geliştirmeye başlayabilir, görsel öğeler ekleyebilir ve kullanıcı arayüzünü tasarlayarak oyununuzu tamamlayabilirsiniz.