Unity Platformer Oyunlarında Can, Skor ve Seviye İlerleme Arayüzü

Platformer oyunları, oyuncuların reflekslerini ve stratejik düşünme yeteneklerini test eden, eğlenceli ve sürükleyici deneyimler sunar. Bu deneyimin önemli bir parçası da oyuncuya anlık geri bildirim sağlayan kullanıcı arayüzüdür (UI). Canlar, skor ve seviye ilerlemesi gibi temel Unity Platformer UI öğeleri, oyuncunun oyun durumunu anlaması ve motive olması için kritik öneme sahiptir. Bu makalede, Unity'de bu UI elemanlarını nasıl kuracağınızı, yöneteceğinizi ve optimize edeceğinizi adım adım öğreneceksiniz.

Giriş: Platformer UI Neden Önemli?

Bir platformer oyununda, oyuncunun ne kadar canı kaldığını, ne kadar skor topladığını veya bir sonraki seviyeye ne kadar yaklaştığını bilmesi, oyun deneyiminin ayrılmaz bir parçasıdır. Gözle görülür ve anlaşılır bir Unity Platformer UI, oyuncunun oyuna olan bağlılığını artırır, hedeflerini netleştirir ve başarı hissini pekiştirir. Karmaşık görünen bu sistemler, Unity'nin güçlü UI araçları sayesinde oldukça basit bir şekilde hayata geçirilebilir.

Temeller: Canvas ve UI Elemanları Kurulumu

Unity'de UI oluşturmanın ilk adımı bir `Canvas` nesnesi eklemektir. `Canvas`, tüm UI elemanlarınızın üzerinde çizildiği bir alandır.

Canvas Oluşturma ve Ayarları

Bir `Canvas` oluşturmak için:

Hierarchy penceresine sağ tıklayın.
`UI` > `Canvas` seçeneğini seçin.

Oluşturulan `Canvas` nesnesinin `Rect Transform` bileşenine dikkat edin. Ayrıca, `Canvas Scaler` bileşeni, UI'nizin farklı ekran çözünürlüklerinde doğru şekilde ölçeklenmesini sağlar. Genellikle `UI Scale Mode` olarak `Scale With Screen Size` seçeneği, platformer oyunları için iyi bir başlangıç noktasıdır.

Text ve Slider Elemanlarını Ekleme

Can ve skor için `Text` elemanları, seviye ilerlemesi için ise `Slider` elemanı kullanacağız.

`Canvas` altına sağ tıklayın.
`UI` > `Text - TextMeshPro` seçeneğini seçin. (TextMeshPro, standart `Text` bileşenine göre daha iyi performans ve daha fazla özelleştirme sunar. İlk kez kullanıyorsanız, gerekli TMPro import pencerelerini onaylayın.)
Aynı şekilde, seviye ilerlemesi için `UI` > `Slider` seçeneğini seçin.

Bu elemanları sahnenizde istediğiniz konumlara yerleştirin ve boyutlarını ayarlayın. Örneğin, canları sol üste, skoru sağ üste, seviye ilerlemesini ise ekranın altına yerleştirebilirsiniz.

Can Sistemi (Lives System) Uygulaması

Can sistemi, oyuncunun oyunda ne kadar hata yapma hakkı olduğunu gösterir.

Can Değerini Gösterme

Can değerini yönetmek için basit bir C# betiği oluşturacağız. Bu betik, UI üzerindeki `TextMeshProUGUI` elemanını güncelleyecek.

Öncelikle, bir `UIManager` betiği oluşturun ve `Canvas` nesnesine ekleyin.


using UnityEngine; 
using TMPro; // TextMeshPro kullanıyorsanız

public class UIManager : MonoBehaviour
{
    [SerializeField] private TextMeshProUGUI livesText;
    private int currentLives;

    public void SetLives(int lives)
    {
        currentLives = lives;
        livesText.text = "Can: " + currentLives.ToString();
        if (currentLives <= 0)
        {
            // Oyun bitti logic'i
            Debug.Log("Oyun Bitti!");
        }
    }

    // Diğer UI elemanları için metotlar buraya gelecek
}

Unity Editor'da `UIManager` betiğine, sahnedeki canları gösterecek `TextMeshProUGUI` elemanını sürükleyip bırakın.

Can Kaybını Yönetme

Oyuncu bir düşmana çarptığında veya bir tuzaktan hasar aldığında can kaybetmelidir. Bu, genellikle oyuncu karakterinin betiğinde veya bir `GameManager` betiğinde yönetilir. `UIManager`'daki `SetLives` metodunu çağırarak UI'yi güncelleyebilirsiniz.


// Örneğin, PlayerController betiğinizde:
public class PlayerController : MonoBehaviour
{
    private UIManager uiManager;
    private int playerLives = 3;

    void Start()
    {
        uiManager = FindObjectOfType<UIManager>();
        if (uiManager != null)
        {
            uiManager.SetLives(playerLives);
        }
    }

    public void TakeDamage(int damageAmount)
    {
        playerLives -= damageAmount;
        if (uiManager != null)
        {
            uiManager.SetLives(playerLives);
        }
        if (playerLives <= 0)
        {
            // Oyuncu öldü, yeniden başla veya Game Over ekranı göster
            Debug.Log("Player has no lives left!");
        }
    }

    // Diğer oyun mantığı...
}

Skor Sistemi (Score System) Uygulaması

Skor sistemi, oyuncunun oyundaki başarısını ölçer.

Skor Değerini Gösterme

`UIManager` betiğimize skor için bir `TextMeshProUGUI` referansı ve bir metot ekleyelim:


// UIManager betiğine ekleyin:
    [SerializeField] private TextMeshProUGUI scoreText;
    private int currentScore;

    public void SetScore(int score)
    {
        currentScore = score;
        scoreText.text = "Skor: " + currentScore.ToString();
    }

Yine, Unity Editor'da `scoreText` alanına ilgili `TextMeshProUGUI` elemanını sürükleyin.

Skor Kazanmayı Yönetme

Oyuncu, toplanabilir öğeleri (paralar, yıldızlar vb.) topladığında skor kazanır. Bu toplanabilir nesnelerin betiklerinde, `UIManager`'daki `SetScore` metodunu çağırabiliriz.


// Örneğin, bir Coin betiği:
public class Coin : MonoBehaviour
{
    [SerializeField] private int scoreValue = 10;

    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.CompareTag("Player"))
        {
            UIManager uiManager = FindObjectOfType<UIManager>();
            if (uiManager != null)
            {
                uiManager.SetScore(uiManager.GetCurrentScore() + scoreValue); // UIManager'a GetCurrentScore eklemelisiniz
            }
            Destroy(gameObject); // Toplandıktan sonra coini yok et
        }
    }
}

`UIManager`'a `GetCurrentScore()` metodunu eklemeyi unutmayın:


// UIManager betiğine ekleyin:
    public int GetCurrentScore()
    {
        return currentScore;
    }

Seviye İlerleme (Level Progression) Arayüzü

Seviye ilerlemesi, oyuncunun bir seviyeyi tamamlama yüzdesini veya bir hedefe ne kadar yaklaştığını gösterir. Bu, genellikle bir `Slider` UI elemanı ile yapılır.

Slider Kullanımı

Slider, minimum ve maksimum değerler arasında bir ilerlemeyi görselleştirmek için idealdir. `Slider` bileşeninin `Min Value` ve `Max Value` özelliklerini ayarlayabilirsiniz. Genellikle `Min Value` 0, `Max Value` ise 1 olarak ayarlanır ve ilerleme 0 ile 1 arasında normalleştirilmiş bir `float` değerle ifade edilir.

İlerleme Değerini Güncelleme

`UIManager` betiğimize `Slider` için bir referans ve bir metot ekleyelim:


// UIManager betiğine ekleyin:
    [SerializeField] private Slider levelProgressSlider;

    public void SetLevelProgress(float progress)
    {
        // progress 0 ile 1 arasında olmalı
        levelProgressSlider.value = progress;
    }

Unity Editor'da `levelProgressSlider` alanına ilgili `Slider` elemanını sürükleyin.

Seviye ilerlemesini güncellemek, oyunun tasarımına bağlıdır. Örneğin, seviyedeki toplanabilir öğelerin yüzdesini veya oyuncunun başlangıç noktasından bitiş noktasına olan mesafesini kullanabilirsiniz. Bir platformer oyununda, genellikle seviye sonu hedefine olan mesafeye göre ilerleme gösterilir.


// Örneğin, GameManager veya bir LevelManager betiğinde:
public class LevelManager : MonoBehaviour
{
    [SerializeField] private Transform startPoint;
    [SerializeField] private Transform endPoint;
    [SerializeField] private Transform playerTransform;

    private UIManager uiManager;
    private float totalDistance;

    void Start()
    {
        uiManager = FindObjectOfType<UIManager>();
        totalDistance = Vector3.Distance(startPoint.position, endPoint.position);
    }

    void Update()
    {
        if (playerTransform != null && uiManager != null)
        {
            float currentDistance = Vector3.Distance(playerTransform.position, startPoint.position);
            // İlerleme yüzdesini hesapla (0-1 arası)
            float progress = Mathf.Clamp01(currentDistance / totalDistance);
            uiManager.SetLevelProgress(progress);
        }
    }
}

Bu şekilde, oyuncunun ilerlemesi dinamik olarak `Slider` üzerinde gösterilir. Bu, etkileşimli bir Unity Platformer UI deneyimi sunar.

Pratik İpuçları

1. UI Elemanlarını Dinamik Olarak Güncellemek İçin Olaylar (Events) Kullanın

`FindObjectOfType` kullanmak, özellikle `Update` içinde sık sık çağrıldığında performansı etkileyebilir. Daha iyi bir yaklaşım, olay tabanlı bir sistem kullanmaktır. Örneğin, bir `GameManager` veya `Player` betiği bir can kaybı olayını tetikleyebilir ve `UIManager` bu olayı dinleyerek UI'yi güncelleyebilir. Bu, bileşenler arasındaki bağımlılığı azaltır ve kodu daha modüler hale getirir.


// GameManager veya Player betiğinde:
public static event Action<int> OnLivesChanged; // using System;

public void TakeDamage(int damageAmount)
{
    playerLives -= damageAmount;
    OnLivesChanged?.Invoke(playerLives); // Olayı tetikle
}

// UIManager betiğinde:
void OnEnable()
{
    PlayerController.OnLivesChanged += SetLives; // Olayı dinle
}

void OnDisable()
{
    PlayerController.OnLivesChanged -= SetLives; // Olayı dinlemeyi bırak
}

2. Canvas Scaler ile Ekran Çözünürlüğü Desteği

`Canvas` üzerindeki `Canvas Scaler` bileşeni, UI'nizin farklı ekran boyutlarına ve oranlarına uyum sağlaması için çok önemlidir. `UI Scale Mode` olarak genellikle `Scale With Screen Size` seçeneği ve `Reference Resolution` olarak da oyununuzun hedef çözünürlüğü (örneğin 1920x1080) kullanılır. `Match` ayarı ile genişlik veya yüksekliğe göre ölçeklemeyi dengeleyebilirsiniz.

3. ScriptableObjects ile UI Verilerini Yönetme

Sabit skor değerleri, can başlangıç sayıları gibi oyun verilerini `ScriptableObject`'ler aracılığıyla yönetmek, kodunuzu daha temiz ve düzenlenebilir hale getirir. Bu sayede, UI'nin doğrudan bu değerlere referans vermesini sağlayabilir, hatta oyun içi ayarlar menüsüyle bu değerleri değiştirebilirsiniz.

Yaygın Hatalar ve Çözümleri

1. UI Elemanları `null` Hatası

Hata: `NullReferenceException: Object reference not set to an instance of an object` hatası alıyorsunuz çünkü betikteki `[SerializeField]` alanlarına Unity Editor'dan UI elemanlarını sürükleyip bırakmayı unuttunuz.

Çözüm: `UIManager` betiğini seçin ve Inspector penceresindeki `livesText`, `scoreText` ve `levelProgressSlider` alanlarına ilgili UI elemanlarını sürükleyip bırakın.

2. UI Güncellenmiyor

Hata: Oyunda can kaybediyor veya skor kazanıyorsunuz ancak UI üzerinde bir değişiklik olmuyor.

Çözüm: İlgili UI güncelleme metodunu (örneğin `SetLives`, `SetScore`) çağırdığınızdan emin olun. Örneğin, `PlayerController` içindeki `TakeDamage` metodunda `uiManager.SetLives(playerLives);` satırını çağırmayı unutmuş olabilirsiniz.

3. Performans Düşüşleri

Hata: Özellikle eski cihazlarda UI güncellendiğinde FPS düşüşleri yaşanıyor.

Çözüm: `TextMeshPro` kullanın. Standart `Text` bileşeni yerine `TextMeshPro` daha optimize edilmiştir. Ayrıca, UI elemanlarını sadece gerektiğinde güncelleyin. Örneğin, skor her kare güncellenmek yerine sadece skor değiştiğinde güncellenmelidir. Çok fazla `Graphic Raycaster` bileşeni olmadığından emin olun, bunlar gereksiz performans maliyetlerine neden olabilir. Her bir `Canvas` altında sadece bir tane `Graphic Raycaster` olması yeterlidir.

Performans ve Optimizasyon Notları

TextMeshPro Kullanımı: Her zaman standart `Text` yerine `TextMeshPro`'yu tercih edin. Daha iyi metin işleme ve daha düşük çizim çağrısı maliyeti sunar.
Gereksiz Güncellemelerden Kaçının: UI elemanlarını yalnızca değerleri değiştiğinde güncelleyin. Örneğin, `Update()` metodunda her kare metin güncellemek yerine, bir skor arttığında veya can azaldığında ilgili metodu çağırın.
Canvas Ayarları: `Canvas Scaler` ayarlarını doğru yapmak, farklı çözünürlüklerde UI'nizin performansını ve görünümünü optimize eder.
UI Elemanlarını Kapatma: Görünmeyen veya aktif olmayan UI elemanlarını (örneğin, oyun bitiş ekranı) `gameObject.SetActive(false)` ile kapatmak, Unity'nin onları işlememesini sağlar.

Bu optimizasyonlar, özellikle mobil platformer oyunlarında akıcı bir deneyim sağlamak için hayati öneme sahiptir.

Sonuç

Unity'de can, skor ve seviye ilerleme gibi temel Unity Platformer UI elemanlarını oluşturmak ve yönetmek, oyun geliştirme sürecinin temel bir parçasıdır. Bu makalede öğrendiğiniz teknikler ve ipuçları sayesinde, oyuncularınıza net ve bilgilendirici bir arayüz sunarak oyun deneyimlerini zenginleştirebilirsiniz. Unutmayın, iyi tasarlanmış bir UI sadece estetik değil, aynı zamanda oyunun oynanabilirliği ve sürükleyiciliği için de kritik öneme sahiptir. Kendi platformer oyunlarınızda bu bilgileri kullanarak harika UI'ler yaratmaya başlayın!