Unity Input Sistemi (Klavye, Mouse, Joystick ve Dokunmatik Ekran Kontrolü)

Kullanıcı tarafından gönderilen girişleri algılayarak oyuna aktarmamıza yarayan yapıya Input sistemi denmektedir. Bu dersimizde de Unity Input Sistemi nasıl kullanılır? detaylıca inceleyeceğiz.

Örneğin, bir FPS oyununda kullanıcı karakterini yönlendirmek için klavyesinden W,A,S,D tuşlarına bastığında, arka planda bunu çözümleyerek oyunda ki karakterini, kullanıcıdan alınan girdilere göre hareket ettirmemizi düşünebilirsiniz.

Tabi bunu standart yön tuşları, zıplama tuşları olarak düşünmeyin. Biz hangi tuşa basıldığında hangi işlemin yapılmasını istiyorsak ya da mobil cihazlarda ekranın hangi kısmına dokunulması istiyorsak belirleyebiliriz. Yani tüm kontrol bizde…

Bu tarz kullanıcı girişlerinin tespiti için “Input” sınıfının özellikleri ve sınıflarını kullanılmaktadır.

Unity Input Sistemi Metotları

Input sınıfının metotlarıyla, kullanıcıdan tüm girdileri alabiliriz. Genellikle true, false cevabı döndüğü için çoğunlukla if bloklarında kullanılırlar.

Birçok Input sınıfı bulunuyorken, sadece bazıları aktif olarak kullanılmaktadır. Bu kısımda tek tek metotların aldıkları paremetreleri ve ne işe yaradıklarını inceleyeceğiz.

Metotların testleri için sahneye bir obje ekledikten sonra yeni bir script oluşturarak, içersine C# Script dosyası ekliyoruz.

GetKey Metodu

Kullanıcının klavye üzerinden, belirtilen tuşa basılıp, basılmadığını tespit etmek için kullanılır.

public class InputKontrol : MonoBehaviour
{
    void Update()
    {
        if (Input.GetKey("a"))
        {
            Debug.Log("Kullanıcı A tuşuna bastı");
        }
    }
}

Yukarıda ki örnekte olduğu gibi Input.GetKey("a") yazarak kullanıcının klavyeden “a” tuşuna basıp basmadığını kontrol etmiş oluyoruz. Eğer kullanıcı “a” tuşuna bastıysa console ekranında “Kullanıcı A tuşuna bastı” yazacaktır.

Burada dikkat etmeniz gereken kısım “A” tuşuna bastığı süre boyunca bize çıktıyı verecektir. Örnek vermek gerekirse karakteri yürtmek için A tuşuna basılı tutmamızı düşünebilirsiniz.

GetKeyDown Metodu

GetKey metodunda olduğu gibi kullanıcı klavyeden belirlediğiniz tuşa bastığı zaman tetiklenmesi için kullanılır. Fakat sadece bir kere çalışır.

GetKey metodunda olduğu gibi kullanıcı parmağını “A” tuşundan çekmeden basmaya devam etse sürekli ilerleyemeyecektir. Şöyle düşünebilirsiniz karakterinizin zıplama özelliği var diyelim. Burada siz zıplama tuşuna basılı tutsanızda sadece bir kere zıplayacatır. İşte bu gibi sadece bir kere çalışacak girdiler için GetKeyDown kullanılır.

public class InputKontrol : MonoBehaviour
{

    void Update()
    {
        if (Input.GetKeyDown("space"))
        {
            Debug.Log("GetKeyDown ile Space tuşu çıktısı");
        }
    }
}

Input.GetKeyDown(“space”) yazarak “Space” tuşuna ilk basma işleminde çalışmasını sağladık. Bir daha space tuşuna bağlı olan işlemlerin gerçekleşmesi için kullanıcının parmağını çekip, tekrar basması gerekecektir.

GetKeyUp Metodu

GeyKeyDown metodunun tam tersi şekilde çalışır. Yani kullanıcı belirtilen tuşa bastığında değilde basmayı bıraktığında çalışacaktır.

public class InputKontrol : MonoBehaviour
{

    void Update()
    {
        if (Input.GetKeyDown("space"))
        {
            Debug.Log("GetKeyDown ile Space tuşu çıktısı");
        }

        if (Input.GetKeyUp("space"))
        {
            Debug.Log("GetKeyUp ile Space tuşu çıktısı");
        }
    }
}

Örneğin yukarıdaki kodu çalıştırdığımızda ve oyun ekranından “Space” tuşuna bastığımızda önce GetKeyDown metodu için olan, sonrasında ise GetKeyUp metodu için olan çıktı ekrana yansıyacaktır.

GetMouseButton Metodu

Mouse üzerinde yer alan tuşlara basılı tutulup, tutulmadığını kontrol etmemiz için kullanılan metotdur. Mouse üzerinde yer alan tuşları ayrı ayrı kontrol edebilirsiniz.

public class InputKontrol : MonoBehaviour
{

    void Update()
    {
        if (Input.GetMouseButton(0))
        {
            Debug.Log("Mouse'da Sol Tuşa Basıldı");
        }

        if (Input.GetMouseButton(1))
        {
            Debug.Log("Mouse'da Sağ Tuşa Basıldı");
        }

        if (Input.GetMouseButton(2))
        {
            Debug.Log("Mouse'da Tekerleğe Basıldı");
        }
    }
}

Input.GetMouseButton(0) ile yani parametre olarak “0” rakamını gönderirsek mouse üzerindeki sol tuşu kontrol edecektir.

Input.GetMouseButton(1) ile yani parametre olarak “1” rakamını gönderirsek mouse üzerindeki sağ tuşu kontrol edecektir.

Input.GetMouseButton(2) ile yani parametre olarak “2” rakamını gönderirsek mouse üzerindeki tekerleğe basıldığını kontrol edecektir.

Yukarıda bahsettiğim 0,1,2 parametreleri GetMouseButtonDown ve GetMouseButtonUp metodları içinde geçerlidir.

GetMouseButtonDown Metodu

Mouse üzerinde yer alan tuşlara basılıp, basılmadığını yakalamak için kullanılan metotdur. Mouse üzerinde yer alan tuşlara basıldığında sadece bir kere çalışır. Örneğin bir sniper oyununda ateş etmek için sol tuşa sürekli basmak yerine her tıklandığında bir kere çalışarak ateş etmesini düşünebilirsiniz.

public class InputKontrol : MonoBehaviour
{

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            Debug.Log("Mouse'da sol tuşa bir kere basıldı.");
        }

        if (Input.GetMouseButtonDown(1))
        {
            Debug.Log("Mouse'da sağ tuşa bir kere basıldı.");
        }

        if (Input.GetMouseButtonDown(2))
        {
            Debug.Log("Mouse'da tekerlek tuşuna bir kere basıldı.");
        }
    }
}

GetMouseButtonUp Metodu

GetMouseButtonDown metodunun tam tersi şekilde mouse üzerindeki bir tuşa basıldıktan sonra kullanıcının elini ilgili tuştan çekmesi sonrasında çalışan metotdur.

public class InputKontrol : MonoBehaviour
{

    void Update()
    {
        if (Input.GetMouseButtonUp(0))
        {
            Debug.Log("Kullanıcı Mouse'da sol tuşa basmayı bıraktı.");
        }

        if (Input.GetMouseButtonUp(1))
        {
            Debug.Log("Kullanıcı Mouse'da sağ tuşa basmayı bıraktı.");
        }

        if (Input.GetMouseButtonUp(2))
        {
            Debug.Log("Kullanıcı Mouse'da tekerlek tuşana basmayı bıraktı.");
        }
    }
}

Burada araya girerek Up ile biten metodlar size mantıksız gelmiş ya da kafanızda oturtamamış olabilirsiniz. Bu metodları illaki oyunda yer alan bir işlem olarak düşünmeyin. Oyuncunun bir tuşa basıp elini çekmesini tespit ederek bir kod bloğu çalıştırabilirsiniz.

GetAxis Metodu

Unity oyun motorunun, bazı standart yönlendirme işlemleri için varsayılan olarak gelen bir “Input Manager” yapısı bulunuyor. GetAxis metodu ile bu hazır yapıya erişebilir ya da bizim kendi oluşturduğumuz hazır Input yapılarına erişebiliriz.

Şimdi Input Manager yapısını biraz inceleyelim.

Unity Input Manager

“Edit > Project Settings” > Input Manager” yolunu takip ederek, hazır tanımlanmış olan giriş yöntemlerin ayarlarının yapıldığı “Input Manager” bölümüne giriş yapabilirsiniz.

Input Manager penceresine giriş yaptığınızda karşınıza açılan pencerede Unity tarafından eklenen hazır tanımlamarı göreceksiniz. Bu pencere yer alan “Horizontal” ya da “Vertical” pencersini açtığınızda aşağıdaki gibi bir görüntü ile karşılacaksınız. Aslında bu pencereye baktığınızda kafanızın üstünde bir ampul yanması lazım.

Örneğin “Horizontal” içinde oyunumuzdaki yatay girişleri algılamak için gerekli ayarları göreceksiniz. Gördüğünüz gibi “A” ve “D” tuşları ile “Sol Yön Tuşu” ve “Sağ Yön Tuşu” için tanımlama yapılmış. “Vertical” içinde aynı mantıkta “W” ve “S” tuşları ile “Aşağı Yön Tuşu” ve “Yukarı Yön Tuşu” için hazır tanımlama bulunuyor.

Bu hazır “Axes” yapılarını “Input Manager” aracılığıyla çağırarak, oyuncunun bu tuşlara basması durumunda yatay ya da dikey yönde hareket etmesi için işlem yaptırtabiliriz.

Çağırma yöntem olarak Input sınıfından GetAxis metodunu aşağıdaki gibi kullanacağız. Mesela “Vertical” hazır Axes tanımlaması için tırnak işaretleri içinde Axes ismini yazmamız yeterli oluyor.

Input.GetAxis("Vertical")

Diğer hazır tanımlamara baktığınızda da göreceksiniz ki mouse hareketleri, mouse tuşları, zıplama vb en çok kullanılan ve standartlaşmış tanımlamalar bulunuyor.

Tabi burada sizde oyununuza göre yeni bir tanımlama ekleyebiliyorsunuz. Bunun için “Input Manager” penceresinde yer alan “Size” sayısını arttırmanız yeterli olacaktır. “Size” sayını arttırdığınızda en son eklenmiş olan Axes ismini çoğaltacaktır. Eğer bu pencere ilk defa girdiyseniz yeni bir “Cancel” eklemiş olacaktır.

Siz de bu tanımlamaya girerek kendi tuş, mouse, joystick yapılandırmanızı oluşturabilirsiniz. Tabi önce içindeki ayarları anlamanız gerekiyor. O yüzden biraz ayarlarını inceleyelim.

Input Manager Axes Ayarları

Input Manager içerisinde yer alan Axes ayarlarını aşağıda başlık, başlık inceliyoruz.

Name: Axes’e vereceğimiz isimdir. GetAxis metodunu kullanırken burada belirttiğimiz isim üzerinden çağıracağız.

Descriptive Name: Bu alanın kullanımı işlev dışıdır. Unity tarafından yakında kaldırılacağı bildirildi.

Descriptive Negative Name:Bu alanın da kullanımı işlev dışıdır. Unity tarafından yakında kaldırılacağı bildirildi.

Negative Button: İlgili ekseni negatif yönte itmek için kullanılan tanımlamadır. Bu alana fare, klavye ya da joystick üzerindeki herhangi bir tanımlamayı yapabilirsiniz.

Positive Button: Negative Button tanımlamasının tam tersi şekilde pozitif yönde tanımlama yapmak için kullanılır. Örneğin sol yön tuşu için “Positive Button” alanına “left” yazdıysanız “Negative Button” alanına da “right” yazabilsiniz. Ayrıca tanımlama yaparken illaki bir “Negative Button” belirtmenize gerek yok. Mesela zıplama için sadece bu alana “space” yazabilrsiniz.

Alt Negative Button: “Negative Button” ile tanımladığımız kısayollara negatif yönde alternatif bir atama yapmak için kullanılan alandır. Doldurulması zorunlu değildir.

Alt Positive Button:”Positive Button” ile tanımladğımız kısayollara pozitif yönde alternatif bir atama yapmak için kullanılan alandır. Bu alanında doldurulması zorunlu değildir.

Gravity: Bu kısımdaki ayarda, tanımlanan bir kısayola basma işlemini bıraktıktan sonraki saniye başına birim hızı belirtilir. Belirlenen pozitif ve negatif yönler arasındaki geçiş hassasiyetinin ayarlandığı kısımdır. Örneğin sol yön tuşuna basmayı bırakıp, sağ yön tuşuna bastığımızdaki hassasiyet diye düşünebilirsiniz.

Dead: Analog yapıların hassasiyetinin belirlendiği kısımdır. Örneğin Joistik üzerinde yer alan dokunmatik alanı ne kadar sağ tarafa çekersek algılamaya başlaması gerektiğini ayarladığımızı düşünebilirsiniz. Ayar ne kadar yüksek olursa hafif dokunmaları algılayamaz mantığıyla çalışır.

Sensitivity: Mobil cihazlarda olan ayarlardır. Saniye başına birim hızının belirlendiği kısımdır. Örneğin mouse hareketlerinin hızının ayarlanmasının mobil cihazlar için olanı olarak düşünebilirsiniz.

Snap: Bu alan seçili olduğu zaman eksen değeri sıfırlanmaktadır. Örneğik karakteri sol tarafa doğru yönlendirirken, sağ taraf yönüne gitmesi için basarsanız eksenini otomatik olarak sıfırlayarak direk diğer hareket başlaması için kullanılır.

Ivert: Belirlenen eksenlerin tam tersi şekilde çalışması için kullanılır. Sağ tuşa basında sol tarafa ve sol tuşa basında sağ tarafa gitmesini sağlamak olarak düşünebilirsiniz.

Type: Yaptığımız kısayolların hangi yapıya göre ayarlanacağının belirlendiği kısımdır.

• Key or Mouse Button: Klavye ve mouse için geçerli olması için kullanılır.
• Mouse: Sadece mouse için geçerli olaması için kullanılır.
• Joystick Axis: Sadece oyun kolları için kullanılır.

Axis: Bağlı cihazın eksenininin belirlendiği yani hangi eksene göre hareket edeceğini belirlendiği kısımdır.

JoyNum: Oyun kolları için kullanılan ayarlardır. Örneğin oyunda kullanılan tüm kolların aynı olarak çalışması için “Get Motion frol all Joysticks” ayarı kullanılır fakat her oyun kolu için farklı tanımlamalar yaparak birbirlerinden farklı çalışmasını sağlayabilirsiniz.

Input Manager ile Objeye Hareket Verme Örneği

Klavye, mouse ve joystick üzerinden kullanıcının girdi olarak kullanacağı tuşları kontrol ederek log atma işlemleri yaptık ama elle tutulur bir örnek ile daha net anlayabileceğinizi düşünüyorum.

Şimdi şöyle birşey yapalım. Sahnede bir topumuz olsun ve klavye üzerinden topumuzu yön tuşları ya da w,a,s,d tuşlarıyla hareket ettirebilelim. Hatta bir labirente sokarak çıklarmaya çalışalım. Böylece ileride karakter üzerinde yapacağımız işlemler için bir hazırlık olur.

Yukarıdaki gibi basit bir sahne tasarımı yaptım. Her zaman söylediğim gibi el alışkanlığı olması için kendi sahnenizi kendiniz oluşturun ama yine de bu adresteki paketi indirerek Unity’e import edebilirsiniz.

Sahnenizi hazırladıktan sonra şimdi gelelim C# ile topumuzu yuvarlamaya. Bunun için elimizde iki yöntem bulunuyor. Birincisi topu sahnede yuvarlamadan süzülerek gitmesi ya da gerçekçi bir şekilde fizik kurallarına uyarak yuvarlanarak gitmesi.

Şimdi “InputKontrol” isminde bir C# dosyası oluşturarak top objemize atalım. Dosyamızın içerisine aşağıdaki kodları yazarak çalıştırdığımızda işlemin başarılı olduğunu göreceksiniz. Tabi ki kodların içeriğini teker teker inceleyeceğiz. Biraz daha aşağı kaydırın 🙂

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class InputKontrol : MonoBehaviour
{
    float xEkseni, zEkseni;
    public float hiz = 33f;

    private Rigidbody rg;

    private void Start()
    {
        rg = transform.GetComponent<Rigidbody>();
    }

    private void FixedUpdate()
    {
        xEkseni = Input.GetAxis("Horizontal");
        zEkseni = Input.GetAxis("Vertical");

        Vector3 hareket = new Vector3(xEkseni, 0f, zEkseni) * hiz * Time.deltaTime;
        rg.AddForce(hareket * hiz);
        
    }

}

• float xEkseni, zEkseni; yazarak iki adet Float türünde değişken oluşturduk. Bu değişkenlere bugün öğrendiğimiz GetAxis metodunu kullanarak, Unity’de hazır tanımlı olarak gelen Axis leri aktaracağız.
• public float hiz = 33f; yazarak topumuza hız uygulayacağız. Ayrıca public olarak belirledik ki, sahne üzerinden de kolayca değiştirebilelim.
• private Rigidbody rg; yazarak ise Rigidbody türünde yani Fizik bileşenine erişebilmek için bir obje oluşturduk.
• Şimdi oyun başlar başlamaz çalışması için yani Start metodunun içerisine rg = transform.GetComponent<Rigidbody>(); yazarak scriptin bağlı olduğu objenin fizi bileşenine erişmiş oluyoruz. GetComponent konusuna yabancıysanız GetComponent Kullanımı isimli dersimize göz atabilirsiniz.
• Şimdi sıra geldi dersimizin konusuna; xEkseni = Input.GetAxis("Horizontal"); ve zEkseni = Input.GetAxis("Vertical"); yazarak ise Unity tarafından varsayılan olarak eklenen Axis lere erişiyoruz.

Unuttuysanız hatırlatayım “Edit > Project Settings” > Input Manager” altında tanımlı olarak gelen tanımlamalar bunlar. Horizontal tanımlamasıyla yatay eksende Vertical ile ise dikey eksende hareket edebiliriz.

• Şimdi objemizi hareket etmek için bir kuvvet uygulayacağız ama bunun içinde bize Vector3 türünde bir obje gerekiyor. Bunun için Vector3 hareket = new Vector3(xEkseni, 0f, zEkseni) * hiz * Time.deltaTime; yazarak bir obje oluşturuyoruz.

Vector3 sınıfı için x, y ve z eksenleri yazmamız gerekiyor fakat dikkat ettiyseniz. X ve Z eksenini kullandık. 3D bir altyapı olduğu için burada topun yukarı aşağı gitmesi Z ekseni olmaktadır. Eğer top sahnede zıplasaydı Y ekseni boyunca zıplayacaktır.

Bir de eğer hiz * Time.deltaTime nedir ya da Vector3 nedir diye acaba diye soruyorsanız biraz eski dersleri kontrol etmeniz gerekiyor. Vector3 Metodları dersinde bakabilirsiniz. Time.deltaTime için yinede bir not bırakıyorum buraya.

Time.deltaTime:  Update() metodu her bir karede bir kere çalışır. Örneğin 35. kareden, 36. kareye geçerken ki süreyi bize bildirir. Eğer biz işlemimizde time.deltaTİme yerine manuel olarak bir değer atarsak oyunu oynayan kişinin sistem performansına göre oyun ya yavaşlayacak ya da çok hızlı hareket edecektir.

• Son olarak topumuzun fiziğine eriştiğimiz rg nesnesi üzerinden AddForce metoduna erişerek oluşturduğumuz Vector3 ve hiz değişkenlerini parametre olarak gönderiyoruz. Yani rg.AddForce(hareket * hiz); yazıyoruz.

Oyunu çalıştırdığımızda aşağıdaki gibi işlemleri gerçekleştirebiliyor olmanı gerekiyor.

Şimdi sırada mobil cihazlarda yani dokunmatik cihazlarda kullanıcıdan alınan girdileri nasıl kontrol edeceğimizi öğrenelim.

Dokunmatik Ekran Kontrolü Nasıl Yapılır?

Dokunmatik ekran özelliğine sahip cihazlarda parmağımızla ya da dokunmatik kalem ile gerçekleşen temasları algılayabilmeyi öğreneceğiz.

Bu işlem sayesinde ekrana herhangi bir parmak dokunuşu oluyor mu, kaç parmak dokunuyor, parmağı kaydırma işlemi oluyor mu ya da ekranın hangi kısmına dokunuş sağlanmış gibi birçok durumu tespit edebiliyoruz.

Input.touchCount Özelliğinin Kullanımı

Input sınıfının statik özelliklerinden biri olan touchCount ile ekrana kaç adet parmağın dokunduğunu tespit edebiliriz.

Aşağıdaki örnek kodda görüldüğü gibi Input.touchCount genellikle if bloğuna sokarak o sırada ekranda kaç edey parmağın temas ettiğini sorgulayabilir ve parmak sayısına göre işlemlerinizi gerçekleştirebilirsiniz.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Debug.Log("Ekrana " + Input.touchCount + " adet parmak temas ediyor.");         
        }
    }
}

Input.GetTouch(i).phase Özelliğinin Kullanımı

Phase komutu ile gerçekleşen dokunuşun detaylarını almamıza yarayan bir özelliktir. Örneğin parmak ekrana temas ediyor mu, teması kesildi mi, ekranda kaydırılıp kaydırılmadığı gibi birçok bilgi almamızı sağlar.

TouchPhase enum yapısıyla beraber kullanılmaktadır. İçerisinde Began, Moved, Stationary, Ended ve Canceled gibi sabitler bulunmaktadır. Daha iyi anlayabilmeniz için bu sabitleri incelememiz gerekecek.

TouchPhase.Began Kullanımı

Ekrana herhangi bir dokunuş olduğunda ilk çalışacak sabittir. Böylece ekrana herhangi bir temasın olup, olmadığını kontrol edebiliriz.

Aşağıdaki örnek kod yapısında görüldüğü gibi önce kendimize Touch dokunus = Input.GetTouch(0); yazarak Touch sınıfından bir nesne oluşturduk ve if bloğuna sokarak dokunus.phase == TouchPhase.Began ile ekrana temas eden bir dokunuş olup olmadığının kontrolünü sağladık.

Burada önce ekrana dokunan parmak sayısı 0’dan fazla mı diye kontrol ettikten sonra, parmağın ekrana dokunmaya devam edip, etmediğini kontrol ettik.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{
  
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Touch dokunus = Input.GetTouch(0);

            if (dokunus.phase == TouchPhase.Began)
            {
                Debug.Log("Ekrana temas eden " + Input.touchCount.ToString() + " adet parmak bulunuyor.");
            }
        }
    }
}

TouchPhase.Stationary Kullanımı

TouchPhase.Stationary sabiti ise o sırada ekrana temas eden parmağın hareketsiz olduğunu tespit etmemize yaramaktadır. Çalışması için parmağın ekrana temas etmesi ama hareket etmemesi gerekmektedir.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{ 
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Touch dokunus = Input.GetTouch(0);

            if (dokunus.phase == TouchPhase.Stationary)
            {
                Debug.Log("Parmak hareket etmiyor.");
            }
        }
    }
}

TouchPhase.Moved Kullanımı

TouchPhase.Moved sabiti ise ekrana dokunan parmağın hareket halinde olduğunun tespiti için kullanılmaktadır.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{ 
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Touch dokunus = Input.GetTouch(0);

            if (dokunus.phase == TouchPhase.Moved)
            {
                Debug.Log("Parmak hareket ediyor.");
            }
        }
    }
}

TouchPhase.Ended Kullanımı

TouchPhase.Ended sabiti ise ekrana temas eden parmağın kaldırılmasının tespiti için kullanılmaktadır.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{ 
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Touch dokunus = Input.GetTouch(0);

            if (dokunus.phase == TouchPhase.Ended)
            {
                Debug.Log("Parmak ekrandan kaldırıldı.");
            }
        }
    }
}

TouchPhase.Canceled Kullanımı

TouchPhase.Canceled sabiti ise ekrana dokunuşunun takibi sırasında oluşan bir sistemsel sorunun tespiti için kullanılmaktadır.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{ 
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Touch dokunus = Input.GetTouch(0);

            if (dokunus.phase == TouchPhase.Canceled)
            {
                Debug.Log("Takip sırasınad sorun oluştu.");
            }
        }
    }
}

Çoklu Dokunuşları Yakalama

Ekrana temas eden parmakların durumlarını nasıl kontrol edeceğimizi yukarıda kontrol etmiştik. Fakat ekrana birden fazla temas eden parmak varsa ve oyununuzu bu temaslara göre kontrol etme planınız varsa for döngüsü kullanmanız gerekecektir.

Örneğin aşağıdaki gibi bir for döngüsü ile ekrana dokunan parmakların hangisinin hareket edip etmediğini görebilirsiniz.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{
  
    void Update()
    {
        if (Input.touchCount > 0)
        {
            for (int i = 0; i < Input.touchCount; i++)
            {
                if (Input.GetTouch(i).phase == TouchPhase.Moved)
                {
                    Debug.Log("Ekrana temas eden " + i + " numaralı parmak hareket ediyor.");
                }
            }
                   
        }
    }
}

Aralarda söylüyorum ama tekrar belirteceğim. Bu örneklere bakarak kafanızda canlandırma yapabilmemiz gerekiyor. Mesela oyunumda ekrana ikinci parmak temas ettiğinde ve hareket ettirildiğinde silahın yakınlaştırma özelliğini açacağım şeklinde düşünebilirsiniz. Biz burada bu kısmı nasıl yakalayacağımızı inceliyoruz. Ama ilerde beraber oyun yaparken parçaları daha iyi birleştireceğiz.

Ekrana Dokunarak Oyunda Obje Oluşturma Örneği

Evet şimdi biraz daha farklı bir örnek yapalım. Mesela oyununuzun sahnesinde dokunmatik ekrana dokunduğunuzda yeni bir obje oluşturmasını sağlayabiliriz.

Bu özelliği genellikle Tower Defense ve Zombie Survive oyunlarında kalenize ya da size doğru gelen düşmanları engellemek için duvar çekmek ya da kule oluşturma işlemlerinde kullanırlar. Tabi biz burada en basit halini yani dokunmatik ekranlarda istediğimiz pozisyona obje koyabilmeyi görebilmek için yapacağız.

Sahneme sadece bir adet plane yani zemin koydum. Ekrana dokunduğumuzda sadece bu alan içinde yani oyun sahnesi üzerinde yeni obje oluşturacağız. Bize bir de ekrana dokunduğumuzda oluşacak olan bir obje gerekiyor. Bunun içinde prefab haline getirdiğim bir küp oluşturdum ve renk verdim.

Basit sahnemizi hazırladıysanız, 3D oyunlarda ekranda dokulunan alanı tespit etmek için kameramızı kullanacağız. Yapabileceğimiz tek yöntem bu değil fakat yaygın olarak kullanılan olduğu için bu yöntemi anlatacağım.

Sahnede yer alan “Main Camera” objemizin içerisine C# script dosyası oluşturarak ekliyoruz. C# script dosyasının içerisine ise aşağıdaki kodları ekliyoruz.

using UnityEngine;
public class GetTouchKontrolu : MonoBehaviour
{
    public GameObject eklenecekObje;
    void Update()
    {
        if (Input.touchCount > 0)
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.GetTouch(0).position);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit))
            {
                Instantiate(eklenecekObje, hit.point, Quaternion.identity);              
            }         
        }
    }
}

Şimdi biraz yazdığımız kodları yorumlayalım.

• public GameObject eklenecekObje; yazarak ekranda dokunduğumuzda oluşacak objeyi belirtmek için public bir nesne oluşturduk. Böylece dışarıdan prefab objemizi aşağıdaki gibi ekleyebiliyoruz.

• Ray ray = Camera.main.ScreenPointToRay(Input.GetTouch(0).position); yazarak ileride oluşturacağımız Physics sınıfındaki Raycast metodu için Vector3 türünde bir pozisyon bilgisi verdik. Buradaki Input.GetTouch(0).position dokunma işleminin gerçekleştiği birinci parmağın pozisyonunu ifade etmektedir. Dokunduğumuz yeri tespit etmek içinse kameramızı kullandık.
• Işının çarpığı objedeki bilgileri almak için ise RaycastHit hit; yazdık.
• İf içerisinde ışının gideceği pozisyonu belirlemek için Raycast metoduna ray ve out hit parametrelerini Physics.Raycast(ray, out hit) yazarak gönderdik. Böylece dokunduğumuz alanda bir obje varsa yani sahne içerisindeyse true cevabı dönecek ve if bloğunun içerisine girmiş olacak.

Raycast ışın sistemi hakkında olan konumuzu atladıysanız Unity Raycast Sistemi isimli dersimize bakmayı unutmayın.

• Son olarak ise yeni bir obje yaratmak için Instantiate metodunu Instantiate(eklenecekObje, hit.point, Quaternion.identity); yazarak kullandık.

Instantiate metodunun kullanımını öğrenmek için de Instantiate Metodu dersimize bakabilirsiniz.

Oyunumuzu başlattığımızda ekrana parmağımızla dokunduğumuz yerde istediğimiz objenin oluştuğunu görebilirsiniz. Videoda NoxPlayer kullandığım için mouse imleci göreceksiniz. Mouse imlecini parmağınız olarak düşünebilirsiniz.

Bir sonraki dersimiz olan Unity Yapay Zeka konumuza aşağıdaki bağlantıdan erişebilirsiniz.

Unity 3D Yapay Zeka – AI ve Navigation Dersleri