Obje Etkileşim Yöntemleri

Bu dersimizde Unity derslerinde öğrendiğim obje etkileşimleri ve obje yönetimi konuları üzerine değineceğim. Daha öncesinde Unity oyun motoru objelerinin nasıl oluşturulduğunu, inspector yapısını ve bazı bileşenlerini detaylıca incelemiştik. Eğer o konuyu atladıysanız, ilk önce aşağıdaki konuya göz atmanızı tavsiye ediyorum.

Unity Objeler

İlk olarak obje üzerinde değişken, dizi ve liste oluşturma konularına değineceğiz.

Objeye Değişken Tanımlama

Unity derslerimizi atlamadığınızı düşündüğüm için C# derslerinde değişken oluşturmayı öğrendiğinizi varsayıyorum. Şimdi yine değişkenler oluşturarak ve Unity tarafındaki objelerle nasıl bağdaştıracağımızı ve manipüle edeceğimizi inceleyeceğiz.

Yeni bir C# Script dosyası oluşturarak bir isim belirleyin ve Visual Studio üzerinde açarak içerisine aşağıdaki gibi çeşitli değişkenler oluşturun.

public class Degiskenler : MonoBehaviour
{
    public string karakterAdi;
    public int vurucGucu;
    public float kritikKatmani;
    public bool ozelYetenek;
    private string gorunuklukTest;
    
    void Start()
    {
    }
}

Yukarıdaki gibi public erişim belirleyicisine sahip birere adet String, Integer, Float ve Boolean değişkenler ekledik. Bir de private erişim belirleyicine sahip bir String değişken oluşturduk.

Oluşturduğumuz scripti derslerimizin başından beri bizi yalnız bırakmayan küp objemize tanımlıyoruz. Şimdi objenin Inspector alanına baktığınızda aşağıdaki gibi bir farklılık göreceksiniz.

Gördüğünüz gibi sadece private olarak belirlediğimiz değişken haricinde oluşturduğumuz her değişken objenin içerisinde gözüküyor. Bu şekilde artık objeye dışarıdan müdahale edebiliyoruz.

Public olarak belirlenen her değişken türüne dışarıdan müdahale edilebilir yani değer atanabilir fakat Private olarak belirlenen değişkenlere sadece ilgili script üzerinden değer atama işlemi gerçekleştirebiliriz. Private değişkenler ilgili scriptin dışına çıkmazlar.

Eğer script içersinden bir değer atamadıysak her değişken için Inspector penceresinde varsayılan olarak bir değer atanır. Bu durum sadece bu pencereye özel değil C# ve diğer programlama dillerinde geçerli olan bir durumdur. Aşağıda varsayılan olarak gelen değerleri belirtiyorum.

String: null
Integer: 0
Float: 0
Boolean: false

Şimdi Unity oyun motoru üzerinde değişkenlere değer atarak console ekranına düşürmeye çalışalım.

public class Degiskenler : MonoBehaviour
{
    public string karakterAdi;
    public int vurucGucu;
    public float kritikKatmani;
    public bool ozelYetenek;
 
    void Start()
    {
        Debug.Log("Karakter Adı: " + karakterAdi);
        Debug.Log("Vuruş Gücü: " + vurucGucu);
        Debug.Log("Kritik Katmanı:" + kritikKatmani);
    }

}

Şimdi Unity oyun motorunun Inspector penceresi üzerinde gelen değer alanlarına aşağıdaki gibi değerler yazalım.

Şimdi işe yaradığını görebilmek için Start fonksiyonuna Debug.Log ekleyelim.

public class Degiskenler : MonoBehaviour
{
    public string karakterAdi;
    public int vurucGucu;
    public float kritikKatmani;
    public bool ozelYetenek;
 
    void Start()
    {
        Debug.Log("Karakter Adı: " + karakterAdi);
        Debug.Log("Vuruş Gücü: " + vurucGucu);
        Debug.Log("Kritik Katmanı:" + kritikKatmani);
    }

}

Bu şekilde oyunumuzu çalıştırdığımızda başlangıçta bize değerleri yazdıracaktır. Burada anlamamız gereken unity üzerinden verdiğimiz değişken değerlerine script ile erişebiliyor.

Tabi müdahalede edebiliyoruz. Bir de müdahale için bir örnek yazalım.

public class Degiskenler : MonoBehaviour
{
    public int vurucGucu;
    public bool ozelYetenek;
 
    void Start()
    {

        if (vurucGucu > 50)
        {
            ozelYetenek = true;
            Debug.Log("Karakterin Özel Aktif Edilmiştir.");
        }
        else 
        {
            Debug.Log("Karakterin Özel Yeteneği Pasif Durumdadır.");
        }
    }
}

Bu örnekte ise eğer karakterin “vurucGucu” değişkenine verilen değer 50’den fazla ise “ozelYetenek” değişkenini true duruma getirmesini ve Unity Console ekranına log basmasını istedik.

Test için Unity üzerinde objenin özel yetenek alanını false çekerek vuruş gücünü ise 80 yaptık ve oyunu başlattık. Oyun başladıktan sonra vuruş gücü 50’den büyük olduğu için otomatik olarak özel yetenek alanı true duruma geçmiş oldu.

Objeye Array ve List Tanımlama

Bir önceki konumuzda objeye değişken tanımladığımız gibi dizi(array) ve listeler(list) tanımlamaları yapabiliriz.

Dizi ve listelerin nasıl oluşturulduğunu unuttuysanız C# Array Kullanımı ve C# List Kullanımı derslerine göz atabilirsiniz.

Objeye Array – Dizi Ekleme

Unity Oyun Motoru üzerinde yeni bir C# dosyası oluşturarak küp nesnemize atamasını gerçekleştirelim. Sonrasında ise public string[] ozelGucler; yazarak objeye bir array dizisi tanımlamış olduk.

public class ObjeyeDiziTanimlama : MonoBehaviour
{
    public string[] ozelGucler;
    void Start()
    {
        foreach (var item in ozelGucler)
        {
            Debug.Log(item);
        }
    }
}

Unity ekranında Inspector alanına baktıysanız eğer script altına yeni bir özellik eklendiğini fark edeceksiniz. Burada belirtilen “Size” alanı sizin dizinizin boyutunu belirlemektedir. Buraya vereceğiniz sayı kadar dizinizin boyutu belirlenecektir. Örnek olarak 3 sayısını yazarak aşasında açılan “Element” bilgileri alanlarına dizinizin elemanlarını girin.

Elemanlarımızı ekledikten sonra oyunumuzu çalıştırırsak aşağıdaki gibi bir çıktı alacağız. Böylece objeye Unity oyun motoru üzerinden eleman eklemiş ve console ekranına bastırmış olduk.

Burada fark ettiyseniz foreach (var item in ozelGucler) yapısını kullandık. Önceki unity derslerinde bahsettiğimiz gibi Array-Dizi lerin elemanlarına erişerek ekrana bastırmak için foreach kullanmamız gerekmektedir.

Objeye List Ekleme

List ekleme işlemi içinde aynı Array ekleme gibi script dosyasının içerisine bir list nesnesi ekleyerek gerçekleştireceğiz.

Script dosyamızın içerisine public List<int> sayilar; yazarak bizim için “sayilar” isminde bir Integer List objesi oluşturmasını söylemiş olacağız.

Bu kodu ekledikten sonra script dosyamızı unity objemize bağladığımızda aynı Array’lerde olduğu gibi Inspector penceresinde bir alan eklendiğini göreceksiniz. Bu alandan list boyutunu belirleyerek içerisine eleman ekleme işlemini gerçekleştirebiliriz.

Yine array yani dizilerde olduğu gibi bir foreach döngüsüne sorarak içerisindeki elemanlar ulaşabiliriz. Fakat bu sefer listelerin kullanım kolaylıklarından biri olan eleman ekleme işlemi gerçekleştirelim. Bu şekilde objeye bağlı liste üzerinde elemen ekleme, çıkarma vb listelerin tüm özelliklerini gerçekleştirebilirsiniz.

public class ObjeyeListEkleme : MonoBehaviour
{
    public List<int> sayilar; 
    void Start()
    {
        sayilar.Add(25);
    } 
}

Yukarıdaki sayilar.Add(25); işlemini yaptıktan sonra listemize yeni bir eleman eklenmiş olacak. Peki zaten listemizde elemanlar vardı. Ekleme işleminden sonra nasıl bir sonuç alacak bakalım.

Gördüğünüz gibi eski elemanları silmeyerek üzerine yeni bir eleman eklemiş olduk.

Arkadaşlar, biliyorum şimdi baktığınızda bu işlemler size çok basit ya da anlamsız gelebilir ama ileride sık sık kullanacağımız için mantığını anlamamız ve elimizin alışması gerekiyor. Bu sebeple aynı örnekleri yaparak, tekrar etmenizi şiddetle tavsiye ediyorum.

Unity’de GetComponent Kullanımı

Unity Objeler konusunda gördüğümüz gibi her objenin bir Inspector sayfası vardır ve bu Inspector sayfası üzerinden eklenen bileşenlerle, objelerimize ses, animasyon, boyut gibi bir çok özellik ekleyebiliriz.

Bu bileşenlere ilerleyen konularda ve oyun yapma aşamasında detaylıca değineceğiz. Ama öncesinde script tarafında objelerin bileşenlerini nasıl yakalayabileceğimizi ve değişiklikler yapabileceğimizi inceleyeceğiz.

GetComponent aslında Unity fonksiyonlarından yani metotlarından biri ve farklı türevleri bulunmaktadır. Şimdi bunları detaylıca inceleyelim.

GetComponent Kullanımı

GetComponent ile belirli bir objenin bileşenlerini yakalayabilir ve müdahale edebiliriz.

Unity Oyun Motoru üzerinde bir obje ekledikten sonra sağ tarafta açılan Inspector bölümünde olan bileşenlerden “Box Collider” bileşenini testlerde kullanmak için seçelim.

Şimdi script tarafında eklediğimiz objenin “Box Collider” bileşeni üzerinde bazı özellikleri değiştirmek istediğimizi düşünelim. Burada daha bileşenin özelliklerinin tam olarak ne işe yaradığını düşünmenize gerek yok. Şimdilik sadece değişikliklerin nasıl yapılabileceğiniz inceleyeceğiz.

Bu işlem için GetComponent<bileşen_ismi>().bileşen_özelliği = yeni_atanacak_değer yapısı kullanılmaktadır. Hemen bir örnek verelim.

public class GetComponent : MonoBehaviour
{   
    void Start()
    {    
        GetComponent<BoxCollider>().isTrigger = true;
        GetComponent<BoxCollider>().enabled = false;      
    }
}

Örneğin yukarıdaki C# kod örneğinde şunu demek istiyoruz.

Bu script dosyasının bağlı olduğu bir objeye git(GetComponent). Objenin bileşenlerinden “BoxCollider” olanı bul ve “BoxCollider” bileşeninin “isTrigger” özelliğini false olarak değiştir.

Oyunu başlattıktan sonra objenin özelliklerinin değiştiğini görebilirsiniz.

Fakat GetComponent().isTrigger = true; şeklinde kullanım performans açısından tavsiye edilmemektedir. Eğer tasarladığınız oyun içerisinde sadece bir yerinde bu kısım geçecekse ve sadece belirli bir özelliği değiştirecekseniz kullanımı uygundur.

Şöyle düşünün oyun esnasında bu obje içindeki bileşenin bir çok özelliğini değiştiriyorsunuz ve bunu oyunun belirli aşamalarında sürekli yapmanız gerekiyor. Bu tarz bir durumda sürekli olarak GetComponent() kullanarak çağırmanız performansı etkileyecektir. Bunun yerine bir nesne oluşturarak nesne üzerinden erişmeniz daha sağlıklı olacaktır.

Peki bunu nasıl yapacağız…

public class GetComponent : MonoBehaviour
{
    BoxCollider colliderNesne;
    void Start()
    {
        colliderNesne = GetComponent<BoxCollider>();
        colliderNesne.enabled = true;
        colliderNesne.isTrigger = false;    
    }
}

Örnekteki gibi önce değişiklik yapacağımız BoxCollider bileşeninden bir nesne oluşturuyoruz ve oluşturduğumuz nesne üzerinden bileşenin özelliklerine erişerek değişiklik gerçekleştiriyoruz.

GetComponents Kullanımı

Unity üzerindeki her ojede aynı bileşenden sadece bir tane olmak zorunda değil. Örneğin bir objenin birden fazla Collider bileşeni olabilir. Bu gibi durumlarda GetComponents() fonksiyonunu kullanmamız gerekmektedir.

Eğer birden fazla aynı component yani bileşen varsa ve GetComponents() yerine GetComponent() kullanırsanız Unity sadece ilk bulduğu bileşen üzerinde değişiklik gerçekleştirir.

Şimdi bir örnek yapalım.

public class GetComponentsKullanimi : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        BoxCollider[] colliderNesne = GetComponents<BoxCollider>();

        for (int i = 0; i < colliderNesne.Length; i++)
        {
            colliderNesne[i].isTrigger = true;
        }
    }
}

Örnekteki gibi BoxCollider[] colliderNesne = GetComponents(); yazarak BoxCollider türünde bir liste oluşturuyoruz çünkü birden fazla bileşeni “colliderNesne” isimli nesnemize atacağız.

Sonrasında ise bir for döngüsüne sokarak tüm “BoxCollider” bileşenlerinin “isTrigger” özelliğini true durumuna getirdik. Burada sadece belirli bir “BoxCollider” üzerinde değişiklik yapacaksanız eleman numarasını yazarak kullanabilirsiniz. Örneğin colliderNesne[1].isTrigger = true; gibi.

GetComponentInParent ve GetComponentInChildren Kullanımı

GetComponentInParent fonksiyonu bir objenin dahil olduğu parent objeyi değiştirmek için kullanılır.

Örneğin aşağıdaki gibi bir obje hiyerarşiniz var ve en alta yer alan “Elaman” objesinden “TakimLideri” objesinin bir özelliğini değiştirmek istiyorsunuz. Bu gibi parent durumda olan bir objeye müdahale etmek istiyorsak GetComponentInParent fonksiyonu kullanılır.

Parent – Child yapısı için “Create Empty” oluşturmamız gerekiyor. Nasıl oluşturulacağına Unity Objeler konusunda değindim için bu kısmı yapabildiğinizi varsayıyorum.

Oluşturduğumuz objelerden “TakimLideri” isimli objenin içine bir “Rigidbody” bileşen(component) ekleyin.

Şimdi oluşturduğumuz objelerden “Eleman” isimli olana bir C# Script dosyası oluşturarak içerisine aşağıdaki kodları yazarak atamasını gerçekleştirin.

public class GetComponentInParentKullanimi : MonoBehaviour
{
    void Start()
    {
        GetComponentInParent<Rigidbody>().isKinematic = true;
    }

}

Şimdi elimizde “Rigidbody” bileşeni ekli olmayan ve sadece scipt eklenmiş olan, “Eleman” objesi(child) ile tam tersi şekilde “Rigidbody” bileşeni ekli olan ve script ataması yapılmamış olan “TakimLideri” objesi(parent) yer alıyor.

Biz GetComponentInParent<Rigidbody>().isKinematic = true; yazarak eleman objesinin parent objelerinden birinde eğer “Rigidbody” bileşeni varsa Is Kinematic özelliğini true duruma getir demiş olduk.

Burada Parent ismi sizi yanıltmasın. GetComponentInParent yapısında aşağıdaki kurallar geçerli olacaktır.

• Eğer değişiklik yapılmasını istenen bileşen child objede varsa sadece kendi bileşeninin özelliğini değiştirir.
• Child durumda olan objenin tüm Parent objelerinde özellik kontrol edilir ve sadece ilk bulduğunda değişikliği gerçekleştirir.

Örneğimizdeki hiyerarşide olduğu gibi eğer “Rigidbody” bileşeni hem “TakimLideri” hem de “Yonetici” bileşeninde varsa sadece ilk bulduğunu yani ilk parent objesi “TakımLideri” için değişiklik gerçekleştirecektir.

GetComponentInChildren ise GetComponentInParent fonksiyonunun tam tersi şekilde çalışır.

GetComponentInChildren<Rigidbody>().isKinematic = true;

Parent durumdaki objeye eklenmiş script üzerinden diğer child objelerin bileşenlerine müdahale edebilirsiniz. Tabi burada parent yapısında olduğu gibi sadece ilk bulduğu üzerinde değişiklik işlemini gerçekleştirir.

Tüm parent ya da child objelerde değişiklik yapmak istiyorsanız bu fonksiyonların çoğulu olan GetComponentsInParent ve GetComponentsInChildren fonksiyonunu kullanmanız gerekmektedir.

GetComponentsInParent ve GetComponentsInChildren Kullanımı

Yukarıda belirttiğim gibi bir child objenin tüm parent objelerinde yer alan bileşenlerde değişiklik yapmak istiyorsanız GetComponentsInParent fonksiyonunu kullanırız.

Yonetici/TakimLideri/Eleman obje hiyerarşisi üzerinden inceleyelim. Örneğin hem “Yonetici” hem de “TakimLideri” parent objelerinde “Rigidbody” bileşeninin “Is Kinematic” özelliğini true yapalım.

public class GetComponentInParentKullanimi : MonoBehaviour
{
    void Start()
    {

        Rigidbody[] nesne = GetComponentsInParent<Rigidbody>();

        foreach (var parent in nesne)
        {
            parent.GetComponentInParent<Rigidbody>().isKinematic = true;
        }
    }
}

Yukarıdaki örnekteki kodu biraz inceleyelim.

Rigidbody[] nesne = GetComponentsInParent<Rigidbody>(); yazarak birden fazla obje içinde değişiklik yapacağımız için bir dizi oluşturduk. Sonrasında ise foreach döngüsüne sorarak dizinin eleman sayısı kadar döndürerek parent.GetComponentInParent().isKinematic = true; koduyla değişiklik işlemini gerçekleştirdik.

Tam tersi şekilde bir parent objeden içerisinde yer alan tüm child durumdaki objelere müdahale etmek için GetComponentsInChildren fonksiyonu kullanılır.

Bunu şöyle düşünebilirsiniz. Oyununuzda bir çok düşman objeleri var ve bunların hepsini bir parent objeye bağladınız.

public class GetComponentInParentKullanimi : MonoBehaviour
{
    void Start()
    {
        Rigidbody[] nesne = GetComponentsInChildren<Rigidbody>();

        foreach (var parent in nesne)
        {
            parent.GetComponentInChildren<Rigidbody>().isKinematic = true;
        }
    }

}

Sonrasında ise yukarıdaki kod ile parent objenin içinde yer alan düşman karakterlerinde aradığım bileşen(Rigidbody) varsa özelliğini bu şekilde(isKinematic = true) değiştir diyerek tüm child durumdaki objelere aynı anda müdahale edebilirsiniz.

GameObject.Find Fonksiyonu

Evet önceki konularda parent ve child ilişkisi olan objeler müdahale etmeyi öğrendik. Peki bu şekilde bir ilişkisi olmayan ve sahnede yer alan objeler için ne yapacağız?

İşte bu aşamada Gameobject sınıfından “Find” fonksiyonu devreye gidiyor. Find fonksiyonu ile sahne içerisinde yer herhangi bir objeye erişebilir ve bileşenlerinin özelliklerine müdahale edebiliriz.

Şimdi Find ve FindWithTag için yapacağımız örneklerimizde kullanacağımız yapımızı oluşturalım.

Sahnemiz içi bir “3D Object/ Cube” oluşturarak ismini “Karakter” yaptık. Sonrasında “Create Empty” diyerek ismini “Seviye” olarak değiştirdik. Son olarak “Seviye” objesinin içerisine iki adet “3D Object/ Cube” oluşturarak isimlerini “BirinciSeviyeDusman” ve “IkinciSeviyeDusman” olarak değiştirdik. Yani aşağıdaki gibi bir yapı oluşturmuş olduk.

Sonrasında ise “SeviyeBir” isminde bir C# Script dosyası oluşturuk ve içerisine aşağıdaki kodları ekledik. Sonrasında ise “BirinciSeviyeDusman” objesine atamasını gerçekleştirdik.

public class SeviyeBir : MonoBehaviour
{
    public int saglik;
    public int guc;
    public bool ozekYetenek;

    void Start()
    {      
    }
}

Son olarak çalışmalarımızı gerçekleştireceğimiz “Karakter” isminde bir C# Script dosyası oluşturduk ve aynı isimdeki “Karakter” objesine atadık. Artık tüm işlemlerimizi bu “Karakter” script dosyası üzerinden gerçekleştireceğiz.

Şimdi “Karakter” script içerisine aşağıdaki kodu yazın ve sonrasında beraber inceleyelim.

public class Karakter : MonoBehaviour
{
    void Start()
    {
        GameObject.Find("BirinciSeviyeDusman").GetComponent<SeviyeBir>().saglik = 55;
    }
}

Find fonksiyonu GameObject sınıfının bir fonksiyonu olduğu için GameObject.Find() olarak yazılıyor. GameObject.Find("BirinciSeviyeDusman") yazarak GameObject içinde yani oyunun içinde “BirinciSeviyeDusman” isminde bir objeyi bulmasını söyledik. Sonrasında ise GetComponent<SeviyeBir>() yazarak bu objeye bağlı “SeviyeBir” isminde bir bileşen(script) olduğunu belirttik. Son olarak ise .saglik = 55; yazarak bu script içindeki “saglik” değişkeninin değerini değiştirdik.

Burada obje ismi belirtirken istersek GameObject.Find(“Seviye/BirinciSeviyeDusman”) şeklinde yazabilirsiniz. Bu şekilde direk hiyerarşi belirterek yaptığınız aramalar daha performanslı gerçekleşecektir.

Oyunu çalıştırdıktan sonra “BirinciSeviyeDusman” objesinin Inspector alanında “saglik” değerinin değiştiğini görebilirsiniz. Böylece başka bir objeye bağlı scripti GameObject.Find() fonksiyonu ile bularak içerindeki değişkenlerin değerini değiştirebileceğimizi öğrenmiş olduk.

Fakat bu aşamada “Find” objesinin sistemi çok yorduğunu ve Unity resmi sitesinde kullanılmasının tavsiye edilmediğini belirteyim. Çünkü “Find” objesi ile ilgili bir arama yaparken tüm sahnedeki objeler içinde arama yaptığı için sistemi zorlamaktadır. Özellikle Update() fonksiyonu içerisinde kullanımı, sürekli çalışacağı için tavsiye edilmemektedir.

GameObject.FindWithTag Fonksiyonu

Unity objelerinde tag yani etiket kullanımını Unity objeler konusunda detaylıca incelemiştik. Hatırlamayan arkadaşlar Objeye Nasıl Etiket Eklenir? başlığına tekrar bakabilirler.

GameObject.FindWithTag() fonksiyonu da tıpkı GameObject.Find() fonksiyonu gibi çalışır. Fakat obje ismi ile arama yerine objelere verdiğimiz etiketler üzerinden arama yapmaktadır.

Arama yapısı olarak her ne kadar benzerlik gösterse de Unity resmi sitesinde performans bakımından GameObject.FindWithTag() fonksiyonunun tercih edilmesi tavsiye edilmiş.

GameObject.Find() için verdiğimiz örnek şablon üzerinden devam ediyoruz. “IkinciSeviyeDusman” isimli objemiz için yeni bir etiket oluşturalım ve ismini “Dusman” olarak belirleyelim.

Şimdi oluşturduğumuz tag üzerinden objeye erişerek, objenin “Box Collider” bileşeninin “Is Trigger” özelliğini aktif(true) duruma getirmeye çalışalım.

public class Karakter : MonoBehaviour
{
    public GameObject nesne;
   
    void Start()
    {
        nesne = GameObject.FindWithTag("Dusman");
        nesne.GetComponent<BoxCollider>().isTrigger = true;
    }
}

Burada önce GameObject sınıfında bir nesne oluşturduk. Sonrasında Start() fonksiyonunun içerisinde nesne objemize GameObject.FindWithTag("Dusman"); yazarak “Dusman” isminde etiketi aramasını belirttik. En sonda ise nesne.GetComponent<BoxCollider>().isTrigger = true; ile bulduğu objenin özelliğini değiştirmesini sağladık. Oyunumuzu çalıştırdıktan sonra Box Collider altındaki Is Trigger özelliği true olarak değiştiğini görebilirsiniz.

Not: FindWithTag() fonksiyonu yapısı itibariyle Find() fonksiynu gibi tek satırda yazmamıza izin vermemektedir.

Transform.Find Fonksiyonu

Transform.Find Fonksiyonu

Objeler için alt çocuklarda arama yapacağımızda Transform.Find fonksiyonu GameObject.Find fonksiyuna göre daha iyi bir performans sergilemektedir. Unity resmi sitesinde de Transform.Find fonksiyonunun kullanılması tavsiye ediliyor.

Yukarıda ki cümlede özellikle alt çocuklar kısmına dikkat etmeniz gerekiyor. Çünkü find.transform fonksiyonu sadece alt çocuklar içinde arama yapmaktadır. Örneğin aşağıdaki bir hiyerarşimiz varsa ve find.transform fonksiyonunu “Seviye” objesinin içerisinden çağırırsak. Sadece “BirinciSeviyeDusman” ve “IkinciSeviyeDusman” içerisinde arama yapmamızı sağlayacaktır.

Şimdi bir örnek yaparak test edelim.

Yeni bir C# Script dosyası oluşturarak “Seviye” isimli objemize atayarak içerisine aşağıdaki kodu yazalım.

public class TransformFindFonksiyonu : MonoBehaviour
{
    void Start()
    {
        transform.Find("BirinciSeviyeDusman").GetComponent<BoxCollider>().isTrigger = true;
    }

}

Şimdi burada yaptığımız işlem, transform.find("BirinciSeviyeDusman") yazarak sahnede alt çocuklardan birinde “BirinciSeviyeDusman” ismine sahip olan varsa bul dedikten sonra GetComponent<BoxCollider>() diyerek bulduğun objenin “BoxCollider” bileşenini çek. Son olarak ise .isTrigger = true; diyerek bu bileşenin “isTrigger” özelliğini değiştir demiş oluyoruz. Oyunumuzu çalıştırdığımızda özelliğin otomatik olarak değiştiğini görebilirsiniz.

GameObject.FindGameObjectsWithTag ve GameObject.FindGameObjectWithTag Fonksiyonu

GameObject.FindGameObjectWithTag Önceki başlıkta gördüğümüz GameObject.FindWithTag gibi objelere verilen etiketler içinde arama yapmamızı sağlayan bir fonksiyondur. GameObject.FindGameObjectsWithTag fonksiyonunun farkı ise tüm bileşenlerde arama yaparak istediğimiz değişiklikleri gerçekleştirmemizi sağlar.

Eğer fonksiyon içerisinde FindGameObjectsWithTag gibi “s” takısı varsa bir etikete sahip tüm objelerde arama yapacağını ve bize bir array yani dizi olarak döndüreceğini düşünebilirsiniz. Diğer türlü FindGameObjectWithTag ya da FindWithTag fonksiyonunu kullanırsak sadece ilk bulduğu etikete sahip objeyi döndürecektir.

Şimdi bunu bir örnekle pekiştirelim. Örneğimize FindGameObjectsWithTag yani çoklu arama yapmak için olan üzerinden devam edeceğiz.

Önce daha önceden de kullandığımız aşağıdaki gibi bir hiyerarşi kuruyoruz.

Sonrasında ise yukarıdaki görselde altı çizili olarak belirttiğim objeler için yeni bir C# Script oluşturarak içerisine aşağıdaki kodları ekliyoruz. Bu şekilde objelere değişken tanımlamış olduk.

public class Ozellikler : MonoBehaviour
{
    public int saglik;
    public int guc;
    public bool ozekYetenek;

    void Start()
    {
        
    }

}

Objelere script bağlamalarını yaptıktan sonra “Dusman” isminde etiket oluşturarak bağlama işlemini gerçekleştiriyoruz. Son durum aşağıdaki gibi olması gerekiyor.

Şimdi gelelim son işleme. Yeni bir script oluşturarak aşağıda kodları yazıyoruz ve “Seviye” isminde olan objemize atama işlemini gerçekleştiriyoruz.

public class TransformFindFonksiyonu : MonoBehaviour
{
    GameObject[] objeler;

    void Start()
    {
        objeler = GameObject.FindGameObjectsWithTag("Dusman");

        foreach (var item in objeler)
        {
            item.GetComponent<Ozellikler>().saglik = 100;
        }        
    }

}

Unity üzerinden oyunumuzu çalıştırdığımızda “BirinciDusmanKarakteri” ve “IkinciDusmanKarakteri” içinde yer alan “saglik” değerlerinin 100 olarak değiştiğini görebilirsiniz.

Biraz detaylı inceleyelim. İlk başta GameObject[] objeler; yazarak GameObject sınıfından bir dizi – array oluşturduk. Sonrasında oluşturduğumuz bu dizinin içerisine GameObject.FindGameObjectsWithTag("Dusman"); yazarak tüm “Dusman” etiketine sahip olan objelerin atamasını gerçekleştirdik.

Son olarak ise dizimizi(objeler) foreach döngüsüne sokarak, dizi içinde yer alan her objenin saglik değerini değiştirmek için item.GetComponent<Ozellikler>().saglik = 100; yazdık.

Dışarıdan Public Obje Atama İşlemi

Şimdi ise Unity ile oyun yapmak için en çok kullanacağınız yöntemlerden birini öğreneceğiz. Bu yöntemle script içerisinden sahnede yer alan tüm obje bileşenleri ya da belirli bir etikete sahip olan objeleri aramak yerine kabaca bir örnekle atama yaparak kullanıyoruz

İyice anlamamız için hemen bir örnek yapmaya geçelim. Alt yapımız için iki adet “Create Empty” diyerek obje oluşturuyoruz ve isimlerini “Birinci” ve “Ikinci” olarak değiştiriyoruz. Daha sonra testin sonuçlarını görebilmemiz için “Ikinci” isimli objemize “Rigidbody” bileşeni ekliyoruz.

Son olarak yeni bir script oluşturup, içerisine aşağıdaki kodları ekleyoruz ve “Birinci” isimli objemize atıyoruz.

public class DisaridanObjeVerme : MonoBehaviour
{
    public GameObject disaridanObje;
    void Start()
    {
        disaridanObje.GetComponent<Rigidbody>().isKinematic = true;
    }
 
}

Şimdi burada yaptığımızı ve diğer çalışmalardan farkını inceleyelim.

Fark ettiyseniz eğer public GameObject disaridanObje; yazaraj ilk defa Public olarak bir nesne oluşturduk. Public erişim belirleyicisi sayesinde Unity üzerinden işlem gerçekleştirebileceğiz.

Unity oyun motoru üzerinde “Birinci” isimli objemize tıkladığımızda Inspector penceresinde aşağıdaki gibi yeni bir alanın açıldığını göreceksiniz. Bu alanda yer alan yuvarlak simgeye tıklayarak “Ikinci” ismindeki objeyi atıyoruz. (Sürükleme işlemi de yapabilirsiniz.)

disaridanObje.GetComponent<Rigidbody>().isKinematic = true; yazarak ise atama işlemini gerçekleştireceğimiz objenin “Rigidbody” bileşenini bul ve “isKinematic” özelliğini “true” olarak değiştir demiş oluyoruz.

Özetle birinci objemize bağlı script üzerinde sana bir obje atanacak ve bu objenin şu özelliğini değiştir demiş oluyoruz.

Obje İçinde Değişiklik Yapma(gameObject)

Evet arkadaşlar şimdi gameObject mantığını anlamaya çalışacağız. Bundan önce gördüklerimiz GameObject üzerinde çalışan fonksiyonlardı. Fakat şimdi gameObject mantığını inceleyeceğiz.

Aralarında sadece bir büyük-küçük harf farkı olduğunu görüp kafanız karışmasın. Mantığını şu şekilde düşünebilirsiniz “GameObject” olanı sahnede yer alan tüm objeleriniz yani oyununuz olarak düşünebilirsiniz”. “gameObject” ise içinde bulunduğunuz obje anlamına geliyor.

Bu sebeple önce parent ve child mantığını inceledik. Şimdi ise script ile atama yapılan obje üzerinde direk işlem gerçekleştireceğiz.

GetComponent Fonksiyonu

Önceden işlediğimiz GetComponent fonksiyonun aynısı ama bu sefer tüm oyun yerine sadece dahil olduğumuz obje üzerinde bileşenlerine erişeceğiz.

Öncelikte örnek ile anlatabilmem için unity oyun motoru üzerinde bir “Cube” objesi oluşturalım ve ismini “UnityOgreniyoruz” yapalım. Sonrasında ise bir script oluşturalım ve içerisine aşağıdaki kodları yazarak, “UnityOgreniyoruz” objesine atayalım.

public class Ogreniyoruz : MonoBehaviour
{
    BoxCollider colliderim;
    void Start()
    {
        colliderim = gameObject.GetComponent(typeof(BoxCollider)) as BoxCollider;
        colliderim.isTrigger = true;
    }
}

Burada kullandığımız “gameObject” aslında Unity tarafından “GameObject” sınıfında otomatik olarak oluşturulmuş olan bir nesne.

Şimdi ilk başta “BoxCollider” bileşeni üzerinde işlem yapacağımız için BoxCollider colliderim; yazarak “BoxCollider” sınıfından bir nesne oluşturuyoruz.

Sonrasında ise colliderim = gameObject.GetComponent(typeof(BoxCollider)) as BoxCollider; yazarak, oluşturduğumuz “colliderim” nesnesine GetComponent ile içinde bulunduğumuz objenin bileşenini atıyoruz.

Yani mevcut objemizin içinde bir bileşene(Component) işlem yapmak için colliderim = gameObject.GetComponent(typeof(BoxCollider)) as BoxCollider; kalıbını yazmamız gerekiyor.

Bu uzun yöntemi öğrendiysek eğer bunun daha kısa bir yöntemi olan colliderim = GetComponent("BoxCollider") as BoxCollider; yazarakda kullanabilirsiniz. Yani aşağıdaki gibi…

public class Ogreniyoruz : MonoBehaviour
{
    BoxCollider colliderim;
    void Start()
    {
        colliderim = GetComponent("BoxCollider") as BoxCollider;
        colliderim.isTrigger = true;
    }
}

FindObjectOfType Fonksiyonu

Obje bileşenlerini yakalamak için kullanabileceğimiz fonksiyonlardan biride FindObjectOfType fonksiyonudur.

Örneğin bir if döngüsüne sokarak aşağıdaki gibi kullanabiliriz. Bu şekilde objenizde bir bileşen olup, olmadığını teyit ettikten sonra işlem gerçekleştirebilirsiniz.

Yazım standarttı (BoxCollider)FindObjectOfType(typeof(BoxCollider)); şeklindedir.

public class Ogreniyoruz : MonoBehaviour
{
    BoxCollider colliderim;
    void Start()
    {
        colliderim = (BoxCollider)FindObjectOfType(typeof(BoxCollider));
        
        if (colliderim)
        {
            colliderim.isTrigger = true;
        }
    }
}

SetActive Fonksiyonu Kullanımı

Bir objeyi oyunumuzun sahnesinde pasif duruma getirmek yani gizlemek için kullandığımız bir özelliktir..

Örneğin aşağıdaki gibi Start fonksiyonunun içerisine gameOject.SetActive(false) yazarsak scriptin bağlı olduğu objeyi oyunun başlangıcında otomatik olarak gizleyecektir.

public class Ogreniyoruz : MonoBehaviour
{
    void Start()
    {
        gameObject.SetActive(false);
    }
}

Bir objeyi script içinden false yapabilir yani gizleyebiliriz ama pasif bir objeyi içindeki script üzerinden aktif edemeyiz. Yani tek taraflı olarak çalışmaktadır. Mantıken obje pasif olduğu için içindeki scripte çalışamaz duruma geleceği için tekrar aktif duruma getirilemez. Farklı script ve obje üzerinden işlemi gerçekleştirmemiz gerekecektir.

activeSelf Propery Kullanımı

activeSelf özelliği ile bir objenin aktif ya da pasif durumda olup, olmadığını öğrenebiliriz. activeSelf true ya da false olarak geri dönüş yapar.

Örneğin aşağıdaki gibi bir if .. else döngüsüne sokarak ilgili objenin aktif olup olmadığına bakalım. Burada Unity Console ekranına Log bastırdık ama bunu döngüye girdikten sonra oyun ile ilgili işlemler yapacak şeklinde düşünebilirsiniz.

public class Ogreniyoruz : MonoBehaviour
{
    void Start()
    {
        if (gameObject.activeSelf)
        {
            Debug.Log("Obje Aktif Durumda");
        }
        else { 
            Debug.Log("Obje Pasif Durumda")
        }
    }
}

tag Property Kullanımı

Unity’de gameObject.tag özelliği ile objenin etiketini değiştirebilirsiniz. Örneğin herhangi bir etiket atanmamış bir objeye oyun başlangıcında aşağıdaki gibi etiket ataması yapabilirsiniz.

public class CompareTag : MonoBehaviour
{
    void Start()
    {
        gameObject.tag = "Dusman";       
    }
}

Daha önceden eklediğiniz etiketleri ya da Unity ile varsayılan olarak gelen etiketleri kullanabilirsiniz. Mevcut olmayan bir etiket kullandığınızda “not defined” hatası alırsınız.

CompareTag Fonksiyonu

Unity oyun motorunda CompareTag fonksiyonunu kullanarak objenin etiketinin belirttiğiniz etiketle aynı olup olmadığına bakabilirsiniz. True ve False olarak geri dönüş yapar.

Aşağıdaki örnekteki gibi bir objeye bağlı script içinde aşağıdaki kodu çalıştırdığınızda objedeki etiketin “Dusman” olup olmadığını kontrol ederek bir if .. else döngüsüne sokabilirsiniz.

public class CompareTag : MonoBehaviour
{
    void Start()
    {

        if (gameObject.CompareTag("Dusman"))
        {
            Debug.Log("Etiket doğru belirlenmiş.");
        }
      
    }
}

AddComponent Fonksiyonu

AddComponent fonksiyonu ile oyununuzun çalışması sırasında objeye istediğiniz bileşeni ekleyebilirsiniz.

Örneğin aşağıdaki kodu yazarak C# Script dosyasının ekli olduğu obje içine oyunun açılmasıyla birlikte “Rigidbody” bileşenini eklemiş olduk.

 public class CompareTag : MonoBehaviour
{
    void Start()
    {
        Rigidbody bilesen = gameObject.AddComponent<Rigidbody>() as Rigidbody;
    }
}

Eğer ekleyeceğiniz bileşen yapısı gereği objeye birden fazla eklenebiliyorsa sorunsuz şekilde ekleyecektir. Ama örneğin “Rigidbody” gibi bir kere eklenebilen bir obje ise aşağıdaki uyarıyı vererek ekleme yapmayacaktır.

Can't add component 'Rigidbody' to Ogreniyoruz because such a component is already added to the game object!

SendMessage Fonksiyonu

SendMessage fonksiyonu ile script içierisnde yer alan farklı bir fonksiyonun çalışmasını sağlayabiliriz.

Aşağıda verdiğim örnekte “SiteAdi” isminde String bir değer alan fonksiyon oluşturduk ve gameObject.SendMessage("SiteAdi", "ogreniyoruz.net"); yazarak fonksiyonun çalışmasını sağladık.

Yazım kalıbı olarak gameObject.SendMessage(“Çağrılacak_Fonksiyon_İsmi”, “Gönderilen_Değer”)

public class SendMessageFonksiyonu : MonoBehaviour
{
    void Start()
    {
        gameObject.SendMessage("SiteAdi", "ogreniyoruz.net");
    }

    public void SiteAdi(string ad) {

        Debug.Log("Site adı: " + ad);

    }
}

Sonuç: Site adı: ogreniyoruz.net şeklinde olacaktır.

Çağrılacak fonksiyon isminin hatalı ise “has no receiver!” hatası alınmaktadır. Eğer bu hatanın alınmasını istemiyorsak aşağıdaki gibi SendMessageOptions.DontRequireReceiver parametresi eklenir.

gameObject.SendMessage("SiteAd1i", "ogreniyoruz.net", SendMessageOptions.DontRequireReceiver);

Yukarıdaki örnek için konuşmak gerekirse aslında script içerisinde gameObject.SendMessage("SiteAdi", "ogreniyoruz.net"); yazmak ile SiteAdi("ogreniyoruz.net") yazmak arasında bir fark bulunmamaktadır. Buradaki amacımız derinlemesine yapıyı öğrenmeye çalışmak olduğu için inceledik.

BroadcastMessage Fonksiyonu

“BroadcastMessage” fonksiyonu “SendMessage” fonksiyonuna benzer parametreler alır fakat objenin tüm alt objelerinde eğer çağırdığı fonksiyon varsa otomatik olarak çalışır.

Örneğin “Düşman” isminde bir objeniz var ve içerisinde 10 tane farklı obje child olarak yani alt obje olarak yer aldığı bir hiyerarşiniz olduğunu düşünün. Bu 10 farklı objede aynı fonksiyonunuz var ve oyunun belirli bir aşamasında hepsinin aynı anda çalışması gerekiyor.

İşte bu tarz durumlarda BroadcastMessage fonksiyonu sayesinde ana objenizin altında olan tüm objelerde olan fonksiyonları çağırabilirsiniz.

Şimdi bir örnek ile pekiştirelim.

Aşağıdaki gibi bir yapı oluşturarak parent, child ilişkisi kurduk. “IkinciBasamak” ve “UcuncuBasamak” ismindeki objelerin hepsine farklı bir script ekleyerek içerisine aşağıda belirttiğim fonksiyonu ekledik.

public class IkinciBasamak : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }
    void BroadcastFonksiyon() {

        Debug.Log("İkinci Basamak Fonksiyonundan Geliyor.");
        
    }
}

Not: Her obje için farklı bir Debug.Log yazarak sonucu daha iyi anlayabilirsiniz.

Son olarak yeni bir C# Script oluşturarak “BirinciBasamak” objesine atadık ve aşağıdaki kodu ekledik.

public class BroadcastMessageFonksiyonu : MonoBehaviour
{
    void Start()
    {
        gameObject.BroadcastMessage("BroadcastFonksiyon");
    }
}

Böylece “BirinciBasamak” objesine dahil olan tüm alt objelerin içerisinde eğer “BroadcastFonksiyon” isminde bir fonksiyon varsa çalıştırmasını istemiş olduk.

SendMessage fonksiyonunda olduğu gibi değer gönderip kullanabiliriz. gameObject.SendMessage(“Çağrılacak_Fonksiyon_İsmi”, “Gönderilecek_Değer”)

Destroy Fonksiyonları

Destroy fonksiyonuna vereceğimiz parametrelerle içinde bulunduğumuz obje üzerinde çeşitli silme işlemleri gerçekleştirebiliriz.

Destroy(gameObject) Kullanımı

Destroy fonksiyonuna aşağıdaki gibi “gameObject” parametresini verdiğimiz zaman script dosyasının içinde bulunduğu objeyi tamamen sahneden silebilirsiniz.

Daha önce bahsettiğimiz gibi burada geçen gameObject terimi scriptin bağlı olduğu objeyi ifade etmektedir.

public class DestroyFonksiyonlari : MonoBehaviour
{
    void Start()
    {
        Destroy(gameObject);
    }
}

Eğer objenin belirli bir saniye sonrasında otomatik olarak sahneden silinmesini istiyorsanız Destroy(gameObject, 3f); şeklinde bir Float değer vererek 3 sn sonra sonra silinmesini belirtebilirsiniz.

Destroy(this) Kullanımı

Destroy fonksionuna this parametresini vererek kullanırsanız objeye eklenmiş olan script dosyasını silecektir. Tıpkı Destroy(gameObject) fonksiyonunda olduğu gibi Float bir değer vererek, belirli bir süre sonra silinmesini isteyebilirsiniz.

public class DestroyFonksiyonlari : MonoBehaviour
{
    void Start()
    {
        Destroy(this,2f);
    }
}

Destroy(GetComponent<T>()) Kullanımı

Destroy fonksiyonunda GetComponent fonksiyonunu kullanarak objeye bağlı olan bileşenlerden silme işlemi gerçekleştirebilirsiniz.

Örneğin objemizde “Rigidbody” bileşenin ekli olduğu varsayarak aşağıdaki kodu çalıştırdığımızda oyun başladıktan 5 sn sonra otomatik olarak “Rigidbody” bileşenini silecektir.

public class DestroyFonksiyonlari : MonoBehaviour
{
    void Start()
    {
        Destroy(GetComponent<Rigidbody>(), 2f);
    }
}

Sonraki derse aşağıdaki bağlantıdan erişebilirsiniz.

Unity Vector3 Metodları ve Değişkenleri