Unity Input System ile Daha Esnek ve Modern Kontroller

Oyun geliştirmede kullanıcı girişi, oyuncunun oyun dünyasıyla etkileşim kurmasının temelidir. Unity, yıllardır eski Input Manager sistemini sunsa da, modern oyunların ve farklı platformların ihtiyaçlarını karşılamak için güçlü ve esnek bir alternatif geliştirdi: Unity Input System. Bu makalede, bu yeni sistemi baştan sona inceleyecek, kurulumundan ileri seviye kullanımlarına kadar tüm detayları öğreneceğiz.

Giriş: Neden Yeni Input System?

Eski Unity Input Manager, özellikle klavye ve fare için basit girişleri yönetmekte yeterliydi. Ancak gamepad'ler, dokunmatik ekranlar ve VR kontrolcüler gibi çeşitli cihazların popülerleşmesiyle birlikte sınırlamaları ortaya çıktı. `Input.GetKeyDown()`, `Input.GetAxis()` gibi yöntemler, her cihaz için ayrı ayrı kod yazmayı gerektiriyor, tuş atamalarını değiştirmeyi zorlaştırıyor ve eşzamanlı çoklu cihaz kullanımında sorunlar yaratabiliyordu.

Yeni Unity Input System, bu sorunları çözmek için tasarlandı. Aksiyon tabanlı bir yaklaşımla, oyuncu girişlerini cihazdan bağımsız soyut aksiyonlara dönüştürür. Bu sayede:

Farklı cihazlar (klavye, fare, gamepad, dokunmatik) için tek bir kod tabanı kullanabilirsiniz.
Oyunculara çalışma zamanında tuş atamalarını değiştirme imkanı sunabilirsiniz.
Birden fazla oyuncunun aynı cihazı veya farklı cihazları kullanarak oynamasını kolaylaştırır.
Girişleri olay tabanlı (event-driven) yöneterek performans optimizasyonuna olanak tanır.
Daha kolay test edilebilir ve sürdürülebilir bir yapı sunar.

Kurulum ve Temeller

Unity Input System paketini kullanmaya başlamak için öncelikle Unity Package Manager üzerinden kurulum yapmanız gerekir:

Unity Editor'da Window > Package Manager yolunu izleyin.
Açılan pencerede sol üstteki açılır menüden Unity Registry'yi seçin.
Arama çubuğuna "Input System" yazın ve paketi seçerek Install butonuna tıklayın.
Kurulum tamamlandığında, Unity size eski Input Manager'ı devre dışı bırakıp yeni sistemi kullanmak isteyip istemediğinizi soracaktır. Yes seçeneğini işaretleyerek devam edin.

Input Actions Varlığı Oluşturma

Yeni sistemin kalbi, tüm giriş aksiyonlarınızı tanımlayacağınız Input Actions varlığıdır. Project penceresinde sağ tıklayıp Create > Input Actions seçeneğini belirleyerek yeni bir `.inputactions` dosyası oluşturun. Bu dosyayı çift tıklayarak Input Actions Editor'ı açın.

Bu editörde üç ana bölüm bulunur:

Action Maps: Farklı oyun durumları veya karakterler için giriş setleri (örn: "Player", "UI", "Driving").
Actions: Bir Action Map içindeki tekil aksiyonlar (örn: "Move", "Jump", "Attack").
Bindings: Bir aksiyonu tetikleyen fiziksel kontrol girdileri (örn: "W" tuşu, "Sol Analog Çubuk").

Örneğin, bir "Player" Action Map'i oluşturup içine "Move" ve "Jump" aksiyonlarını ekleyebilirsiniz. "Move" aksiyonuna klavyedeki WASD tuşlarını ve gamepad'in sol analog çubuğunu, "Jump" aksiyonuna ise "Space" tuşunu ve gamepad'in "A" butonunu bağlayabilirsiniz.

Kod ile Kullanım

Unity Input System aksiyonlarını kodunuzda kullanmanın birkaç yolu vardır. En yaygın ve önerilen yöntem, Input Actions varlığından C# kodu oluşturmaktır. Input Actions dosyanızı seçip Inspector penceresinde Generate C# Class kutucuğunu işaretleyin ve bir sınıf adı belirleyin. Ardından Apply'a basın.

PlayerInput Bileşeni

Sahnenizdeki bir GameObject'e PlayerInput bileşenini ekleyerek, Input Actions varlığınızı kolayca bağlayabilirsiniz. Bu bileşen, girişleri otomatik olarak yönetir ve aksiyonlar tetiklendiğinde çeşitli yöntemlerle bildirim gönderebilir:

Send Messages: Aksiyon adı ile aynı isme sahip bir metoda `SendMessage` gönderir (örn: `OnJump`).
Invoke Unity Events: Aksiyonlar için Unity Event'leri tetikler, Inspector'dan event'lere abone olabilirsiniz.
Invoke C# Events: En esnek yöntemdir, aksiyonlar için C# event'leri tetikler.

Genellikle Invoke C# Events veya Invoke Unity Events daha esnek ve performanslıdır.

C# Kodunda Aksiyonlara Abone Olma

C# sınıfını oluşturduktan sonra, onu script'inizde bir referans olarak kullanabilirsiniz:

using UnityEngine; 
using UnityEngine.InputSystem; // Bu namespace'i eklemeyi unutmayın!

public class PlayerController : MonoBehaviour
{
    private PlayerInputActions _playerInputActions;
    private Vector2 _movementInput;

    private void Awake()
    {
        _playerInputActions = new PlayerInputActions();

        // 'Move' aksiyonunun 'performed' event'ine abone ol
        _playerInputActions.Player.Move.performed += ctx => _movementInput = ctx.ReadValue();
        // 'Move' aksiyonu bittiğinde (tuş bırakıldığında) 'movementInput'ı sıfırla
        _playerInputActions.Player.Move.canceled += ctx => _movementInput = Vector2.zero;

        // 'Jump' aksiyonunun 'performed' event'ine abone ol
        _playerInputActions.Player.Jump.performed += ctx => Jump();
    }

    private void OnEnable()
    {
        // Input System aksiyonlarını etkinleştir
        _playerInputActions.Enable();
    }

    private void OnDisable()
    {
        // Input System aksiyonlarını devre dışı bırak
        _playerInputActions.Disable();
    }

    private void Update()
    {
        // Hareket girdisini kullan
        // Örneğin: transform.position += (Vector3)_movementInput * Time.deltaTime * _moveSpeed;
        Debug.Log("Hareket: " + _movementInput);
    }

    private void Jump()
    {
        Debug.Log("Zıpladım!");
        // Zıplama mantığını buraya ekle
    }
}

Yukarıdaki örnekte `_playerInputActions.Player.Move.performed` gibi ifadelerle belirli aksiyonların `performed` (aksiyonun tamamlandığı an), `started` (aksiyonun başladığı an) veya `canceled` (aksiyonun iptal edildiği an) event'lerine abone oluyoruz. `ctx.ReadValue()` ile de aksiyonun güncel değerini okuyoruz.

Pratik İpuçları

1. Binding Overrides (Tuş Atamalarını Çalışma Zamanında Değiştirme)

Oyuncuların tuş atamalarını oyun içinde değiştirmesine izin vermek, modern bir oyunun vazgeçilmezidir. Unity Input System bu özelliği kolayca sunar. `InputBinding` sınıfını ve `Input Action` nesnesinin `SaveBindingOverridesAsJson()` ve `LoadBindingOverridesFromJson()` metodlarını kullanarak oyuncu tercihlerini kaydedip yükleyebilirsiniz.

// Örnek: 'Jump' aksiyonunun ilk binding'ini değiştirme
var binding = _playerInputActions.Player.Jump.bindings[0];
binding.overridePath = "/leftShift"; // Yeni tuş
_playerInputActions.Player.Jump.ApplyBindingOverride(0, binding);

// Tüm override'ları JSON olarak kaydet
string overridesJson = _playerInputActions.SaveBindingOverridesAsJson();
PlayerPrefs.SetString("InputOverrides", overridesJson);

// Kaydedilen override'ları yükle
string loadedOverrides = PlayerPrefs.GetString("InputOverrides");
if (!string.IsNullOrEmpty(loadedOverrides))
{
    _playerInputActions.LoadBindingOverridesFromJson(loadedOverrides);
}

2. Composite Bindings (Bileşik Bağlantılar)

Input Actions Editor'da bir Binding eklerken Add Composite seçeneğini kullanarak birden fazla tuş veya kontrolü tek bir aksiyona bağlayabilirsiniz. Örneğin, "2D Vector" kompozitini kullanarak WASD veya ok tuşlarını otomatik olarak bir `Vector2` hareket girdisine dönüştürebilirsiniz. "One Modifier" kompoziti ise Shift+E gibi bir kombinasyonu dinlemenizi sağlar.

3. Control Schemes (Kontrol Şemaları)

Farklı kontrol cihazları için ayrı ayrı binding'ler tanımlamak yerine, Control Schemes kullanabilirsiniz. Örneğin, bir "Klavye & Fare" şeması ve bir "Gamepad" şeması oluşturabilirsiniz. Her aksiyon için bu şemalara özel binding'ler ekleyebilirsiniz. `PlayerInput` bileşeni, hangi cihazın bağlı olduğuna göre otomatik olarak uygun şemayı seçebilir veya siz kodunuzda şemalar arasında geçiş yapabilirsiniz.

Yaygın Hatalar ve Çözümleri

`Input Actions`'ı Etkinleştirmeyi Unutma: En sık yapılan hatalardan biridir. `_playerInputActions.Enable()` metodunu `OnEnable()` içinde çağırmayı unutmayın. Aksi takdirde hiçbir giriş algılanmayacaktır.
Yanlış Callback'i Kullanma (`started` vs `performed`): `started`, tuşa basıldığı an tetiklenir ve bir kez çalışır. `performed`, aksiyonun tamamlandığı an tetiklenir (basılı tutulan tuşlar için sürekli, tek seferlik tuşlar için basıldığı an). Çoğu zaman istediğiniz `performed`'dur. Örneğin, zıplama için `performed` uygunken, bir tuşa basılı tutarak yapılan hareket için `performed` sürekli tetiklenir.
Input Değerlerini Doğru Okuyamama: Bir `Vector2` beklerken `ctx.ReadValue()` kullanmak gibi. Her aksiyonun beklenen veri tipine (Value Type) dikkat edin (örn: Button için `float`, 2D Vector için `Vector2`).
`PlayerInput` Bileşenini Yanlış Yapılandırma: `PlayerInput` bileşenini kullanıyorsanız, `Behavior` ayarının doğru olduğundan emin olun (örn: `Invoke C# Events` veya `Invoke Unity Events`). Ayrıca `Input Actions` varlığının doğru bir şekilde atanmış olduğundan emin olun.

Performans ve Optimizasyon Notları

Unity Input System, eski sisteme göre doğası gereği daha performanslıdır. Çünkü olay tabanlı çalışır. Eski sistemde, `Update()` döngüsünde sürekli olarak `Input.GetKeyDown()` gibi metodları çağırarak her karede girişleri sorgulamanız gerekirdi. Bu, özellikle giriş olmadığında bile CPU döngüleri harcanması anlamına geliyordu.

Yeni sistemde ise aksiyonlara abone olduğunuzda, sadece ilgili giriş olduğunda callback'ler tetiklenir. Bu, gereksiz sorgulamaları ortadan kaldırarak performansı artırır. Bellek yönetimi açısından, `Input Actions` nesnesini `Awake()` içinde oluşturup `OnEnable()` ve `OnDisable()` içinde etkinleştirip devre dışı bırakmak en iyi pratiktir. Bu, kaynakların doğru bir şekilde yönetilmesini sağlar.

Sonuç

Unity Input System, modern oyun geliştirme için çok daha güçlü, esnek ve sürdürülebilir bir giriş yönetim çözümü sunar. Başlangıçta eski sisteme alışkın olanlar için bir öğrenme eğrisi olsa da, sunduğu avantajlar bu çabaya değer. Çoklu cihaz desteği, kolay tuş ataması, olay tabanlı mimari ve performans iyileştirmeleri sayesinde, oyunlarınıza daha zengin ve oyuncu dostu kontrol deneyimleri entegre edebilirsiniz. Bu sistemi öğrenerek ve kullanarak, Unity ile geliştirdiğiniz oyunların kalitesini bir üst seviyeye taşıyabilirsiniz.